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    collections::HashMap,
12    fmt::{Display, Formatter, Result as FmtResult},
13};
14
15use crate::{Acronym, GameModSimple, GameMode, SettingSimple};
16
17mod all_structs {
18    /// Larger circles, more forgiving HP drain, less accuracy required, and extra lives!
19    #[derive(Clone, Debug, Default, PartialEq)]
20    #[cfg_attr(
21        feature = "rkyv",
22        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
23    )]
24    pub struct EasyOsu {
25        /// Number of extra lives
26        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
27        pub retries: Option<f64>,
28    }
29    /// You can't fail, no matter what.
30    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
31    #[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))]
32    pub struct NoFailOsu {}
33    /// Less zoom...
34    #[derive(Clone, Debug, Default, PartialEq)]
35    #[cfg_attr(
36        feature = "rkyv",
37        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
38    )]
39    pub struct HalfTimeOsu {
40        /// The actual decrease to apply
41        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
42        pub speed_change: Option<f64>,
43        /// Should pitch be adjusted with speed
44        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
45        pub adjust_pitch: Option<bool>,
46    }
47    /// Whoaaaaa...
48    #[derive(Clone, Debug, Default, PartialEq)]
49    #[cfg_attr(
50        feature = "rkyv",
51        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
52    )]
53    pub struct DaycoreOsu {
54        /// The actual decrease to apply
55        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
56        pub speed_change: Option<f64>,
57    }
58    /// Everything just got a bit harder...
59    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
60    #[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))]
61    pub struct HardRockOsu {}
62    /// Miss and fail.
63    #[derive(Clone, Debug, Default, PartialEq)]
64    #[cfg_attr(
65        feature = "rkyv",
66        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
67    )]
68    pub struct SuddenDeathOsu {
69        ///
70        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
71        pub fail_on_slider_tail: Option<bool>,
72        /// Automatically restarts when failed.
73        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
74        pub restart: Option<bool>,
75    }
76    /// SS or quit.
77    #[derive(Clone, Debug, Default, PartialEq)]
78    #[cfg_attr(
79        feature = "rkyv",
80        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
81    )]
82    pub struct PerfectOsu {
83        /// Automatically restarts when failed.
84        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
85        pub restart: Option<bool>,
86    }
87    /// Zoooooooooom...
88    #[derive(Clone, Debug, Default, PartialEq)]
89    #[cfg_attr(
90        feature = "rkyv",
91        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
92    )]
93    pub struct DoubleTimeOsu {
94        /// The actual increase to apply
95        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
96        pub speed_change: Option<f64>,
97        /// Should pitch be adjusted with speed
98        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
99        pub adjust_pitch: Option<bool>,
100    }
101    /// Uguuuuuuuu...
102    #[derive(Clone, Debug, Default, PartialEq)]
103    #[cfg_attr(
104        feature = "rkyv",
105        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
106    )]
107    pub struct NightcoreOsu {
108        /// The actual increase to apply
109        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
110        pub speed_change: Option<f64>,
111    }
112    /// Play with no approach circles and fading circles/sliders.
113    #[derive(Clone, Debug, Default, PartialEq)]
114    #[cfg_attr(
115        feature = "rkyv",
116        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
117    )]
118    pub struct HiddenOsu {
119        /// The main object body will not fade when enabled.
120        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
121        pub only_fade_approach_circles: Option<bool>,
122    }
123    /// Put your faith in the approach circles...
124    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
125    #[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))]
126    pub struct TraceableOsu {}
127    /// Restricted view area.
128    #[derive(Clone, Debug, Default, PartialEq)]
129    #[cfg_attr(
130        feature = "rkyv",
131        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
132    )]
133    pub struct FlashlightOsu {
134        /// Milliseconds until the flashlight reaches the cursor
135        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
136        pub follow_delay: Option<f64>,
137        /// Multiplier applied to the default flashlight size.
138        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
139        pub size_multiplier: Option<f64>,
140        /// Decrease the flashlight size as combo increases.
141        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
142        pub combo_based_size: Option<bool>,
143    }
144    /// Play with blinds on your screen.
145    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
146    #[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))]
147    pub struct BlindsOsu {}
148    /// Once you start a slider, follow precisely or get a miss.
149    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
150    #[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))]
151    pub struct StrictTrackingOsu {}
152    /// Fail if your accuracy drops too low!
153    #[derive(Clone, Debug, Default, PartialEq)]
154    #[cfg_attr(
155        feature = "rkyv",
156        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
157    )]
158    pub struct AccuracyChallengeOsu {
159        /// Trigger a failure if your accuracy goes below this value.
160        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
161        pub minimum_accuracy: Option<f64>,
162        /// The mode of accuracy that will trigger failure.
163        pub accuracy_judge_mode: Option<String>,
164        /// Automatically restarts when failed.
165        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
166        pub restart: Option<bool>,
167    }
168    /// Practice keeping up with the beat of the song.
169    #[derive(Clone, Debug, Default, PartialEq)]
170    #[cfg_attr(
171        feature = "rkyv",
172        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
173    )]
174    pub struct TargetPracticeOsu {
175        /// Use a custom seed instead of a random one
176        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
177        pub seed: Option<f64>,
178        /// Whether a metronome beat should play in the background
179        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
180        pub metronome: Option<bool>,
181    }
182    /// Override a beatmap's difficulty settings.
183    #[derive(Clone, Debug, Default, PartialEq)]
184    #[cfg_attr(
185        feature = "rkyv",
186        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
187    )]
188    pub struct DifficultyAdjustOsu {
189        /// Override a beatmap's set CS.
190        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
191        pub circle_size: Option<f64>,
192        /// Override a beatmap's set AR.
193        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
194        pub approach_rate: Option<f64>,
195        /// Override a beatmap's set HP.
196        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
197        pub drain_rate: Option<f64>,
198        /// Override a beatmap's set OD.
199        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
200        pub overall_difficulty: Option<f64>,
201        /// Adjust difficulty beyond sane limits.
202        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
203        pub extended_limits: Option<bool>,
204    }
205    /// Feeling nostalgic?
206    #[derive(Clone, Debug, Default, PartialEq)]
207    #[cfg_attr(
208        feature = "rkyv",
209        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
210    )]
211    pub struct ClassicOsu {
212        /// Scores sliders proportionally to the number of ticks hit.
213        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
214        pub no_slider_head_accuracy: Option<bool>,
215        /// Applies note lock to the full hit window.
216        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
217        pub classic_note_lock: Option<bool>,
218        /// Always plays a slider's tail sample regardless of whether it was hit or not.
219        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
220        pub always_play_tail_sample: Option<bool>,
221        /// Make hit circles fade out into a miss, rather than after it.
222        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
223        pub fade_hit_circle_early: Option<bool>,
224        /// More closely resembles the original HP drain mechanics.
225        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
226        pub classic_health: Option<bool>,
227    }
228    /// It never gets boring!
229    #[derive(Clone, Debug, Default, PartialEq)]
230    #[cfg_attr(
231        feature = "rkyv",
232        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
233    )]
234    pub struct RandomOsu {
235        /// How sharp angles should be
236        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
237        pub angle_sharpness: Option<f64>,
238        /// Use a custom seed instead of a random one
239        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
240        pub seed: Option<f64>,
241    }
242    /// Flip objects on the chosen axes.
243    #[derive(Clone, Debug, Default, PartialEq)]
244    #[cfg_attr(
245        feature = "rkyv",
246        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
247    )]
248    pub struct MirrorOsu {
249        ///
250        pub reflection: Option<String>,
251    }
252    /// Don't use the same key twice in a row!
253    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
254    #[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))]
255    pub struct AlternateOsu {}
256    /// You must only use one key!
257    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
258    #[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))]
259    pub struct SingleTapOsu {}
260    /// Watch a perfect automated play through the song.
261    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
262    #[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))]
263    pub struct AutoplayOsu {}
264    /// Watch the video without visual distractions.
265    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
266    #[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))]
267    pub struct CinemaOsu {}
268    /// You don't need to click. Give your clicking/tapping fingers a break from the heat of things.
269    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
270    #[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))]
271    pub struct RelaxOsu {}
272    /// Automatic cursor movement - just follow the rhythm.
273    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
274    #[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))]
275    pub struct AutopilotOsu {}
276    /// Spinners will be automatically completed.
277    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
278    #[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))]
279    pub struct SpunOutOsu {}
280    /// Everything rotates. EVERYTHING.
281    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
282    #[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))]
283    pub struct TransformOsu {}
284    /// They just won't stay still...
285    #[derive(Clone, Debug, Default, PartialEq)]
286    #[cfg_attr(
287        feature = "rkyv",
288        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
289    )]
290    pub struct WiggleOsu {
291        /// Multiplier applied to the wiggling strength.
292        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
293        pub strength: Option<f64>,
294    }
295    /// Circles spin in. No approach circles.
296    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
297    #[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))]
298    pub struct SpinInOsu {}
299    /// Hit them at the right size!
300    #[derive(Clone, Debug, Default, PartialEq)]
301    #[cfg_attr(
302        feature = "rkyv",
303        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
304    )]
305    pub struct GrowOsu {
306        /// The initial size multiplier applied to all objects.
307        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
308        pub start_scale: Option<f64>,
309    }
310    /// Hit them at the right size!
311    #[derive(Clone, Debug, Default, PartialEq)]
312    #[cfg_attr(
313        feature = "rkyv",
314        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
315    )]
316    pub struct DeflateOsu {
317        /// The initial size multiplier applied to all objects.
318        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
319        pub start_scale: Option<f64>,
320    }
321    /// Can you keep up?
322    #[derive(Clone, Debug, Default, PartialEq)]
323    #[cfg_attr(
324        feature = "rkyv",
325        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
326    )]
327    pub struct WindUpOsu {
328        /// The starting speed of the track
329        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
330        pub initial_rate: Option<f64>,
331        /// The final speed to ramp to
332        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
333        pub final_rate: Option<f64>,
334        /// Should pitch be adjusted with speed
335        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
336        pub adjust_pitch: Option<bool>,
337    }
338    /// Sloooow doooown...
339    #[derive(Clone, Debug, Default, PartialEq)]
340    #[cfg_attr(
341        feature = "rkyv",
342        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
343    )]
344    pub struct WindDownOsu {
345        /// The starting speed of the track
346        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
347        pub initial_rate: Option<f64>,
348        /// The final speed to ramp to
349        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
350        pub final_rate: Option<f64>,
351        /// Should pitch be adjusted with speed
352        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
353        pub adjust_pitch: Option<bool>,
354    }
355    /// The whole playfield is on a wheel!
356    #[derive(Clone, Debug, Default, PartialEq)]
357    #[cfg_attr(
358        feature = "rkyv",
359        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
360    )]
361    pub struct BarrelRollOsu {
362        /// Rotations per minute
363        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
364        pub spin_speed: Option<f64>,
365        /// The direction of rotation
366        pub direction: Option<String>,
367    }
368    /// Never trust the approach circles...
369    #[derive(Clone, Debug, Default, PartialEq)]
370    #[cfg_attr(
371        feature = "rkyv",
372        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
373    )]
374    pub struct ApproachDifferentOsu {
375        /// Change the initial size of the approach circle, relative to hit circles.
376        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
377        pub scale: Option<f64>,
378        /// Change the animation style of the approach circles.
379        pub style: Option<String>,
380    }
381    /// Can you still feel the rhythm without music?
382    #[derive(Clone, Debug, Default, PartialEq)]
383    #[cfg_attr(
384        feature = "rkyv",
385        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
386    )]
387    pub struct MutedOsu {
388        /// Increase volume as combo builds.
389        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
390        pub inverse_muting: Option<bool>,
391        /// Add a metronome beat to help you keep track of the rhythm.
392        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
393        pub enable_metronome: Option<bool>,
394        /// The combo count at which point the track reaches its final volume.
395        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
396        pub mute_combo_count: Option<f64>,
397        /// Hit sounds are also muted alongside the track.
398        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
399        pub affects_hit_sounds: Option<bool>,
400    }
401    /// Where's the cursor?
402    #[derive(Clone, Debug, Default, PartialEq)]
403    #[cfg_attr(
404        feature = "rkyv",
405        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
406    )]
407    pub struct NoScopeOsu {
408        /// The combo count at which the cursor becomes completely hidden
409        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
410        pub hidden_combo_count: Option<f64>,
411    }
412    /// No need to chase the circles – your cursor is a magnet!
413    #[derive(Clone, Debug, Default, PartialEq)]
414    #[cfg_attr(
415        feature = "rkyv",
416        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
417    )]
418    pub struct MagnetisedOsu {
419        /// How strong the pull is.
420        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
421        pub attraction_strength: Option<f64>,
422    }
423    /// Hit objects run away!
424    #[derive(Clone, Debug, Default, PartialEq)]
425    #[cfg_attr(
426        feature = "rkyv",
427        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
428    )]
429    pub struct RepelOsu {
430        /// How strong the repulsion is.
431        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
432        pub repulsion_strength: Option<f64>,
433    }
434    /// Let track speed adapt to you.
435    #[derive(Clone, Debug, Default, PartialEq)]
436    #[cfg_attr(
437        feature = "rkyv",
438        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
439    )]
440    pub struct AdaptiveSpeedOsu {
441        /// The starting speed of the track
442        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
443        pub initial_rate: Option<f64>,
444        /// Should pitch be adjusted with speed
445        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
446        pub adjust_pitch: Option<bool>,
447    }
448    /// Burn the notes into your memory.
449    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
450    #[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))]
451    pub struct FreezeFrameOsu {}
452    /// Don't let their popping distract you!
453    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
454    #[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))]
455    pub struct BubblesOsu {}
456    /// Colours hit objects based on the rhythm.
457    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
458    #[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))]
459    pub struct SynesthesiaOsu {}
460    /// 3D. Almost.
461    #[derive(Clone, Debug, Default, PartialEq)]
462    #[cfg_attr(
463        feature = "rkyv",
464        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
465    )]
466    pub struct DepthOsu {
467        /// How far away objects appear.
468        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
469        pub max_depth: Option<f64>,
470        /// Whether approach circles should be visible.
471        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
472        pub show_approach_circles: Option<bool>,
473    }
474    /// The cursor blooms into.. a larger cursor!
475    #[derive(Clone, Debug, Default, PartialEq)]
476    #[cfg_attr(
477        feature = "rkyv",
478        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
479    )]
480    pub struct BloomOsu {
481        /// The combo count at which the cursor reaches its maximum size
482        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
483        pub max_size_combo_count: Option<f64>,
484        /// The multiplier applied to cursor size when combo reaches maximum
485        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
486        pub max_cursor_size: Option<f64>,
487    }
488    /// Automatically applied to plays on devices with a touchscreen.
489    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
490    #[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))]
491    pub struct TouchDeviceOsu {}
492    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
493    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
494    #[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))]
495    pub struct ScoreV2Osu {}
496    /// Beats move slower, and less accuracy required!
497    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
498    #[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))]
499    pub struct EasyTaiko {}
500    /// You can't fail, no matter what.
501    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
502    #[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))]
503    pub struct NoFailTaiko {}
504    /// Less zoom...
505    #[derive(Clone, Debug, Default, PartialEq)]
506    #[cfg_attr(
507        feature = "rkyv",
508        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
509    )]
510    pub struct HalfTimeTaiko {
511        /// The actual decrease to apply
512        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
513        pub speed_change: Option<f64>,
514        /// Should pitch be adjusted with speed
515        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
516        pub adjust_pitch: Option<bool>,
517    }
518    /// Whoaaaaa...
519    #[derive(Clone, Debug, Default, PartialEq)]
520    #[cfg_attr(
521        feature = "rkyv",
522        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
523    )]
524    pub struct DaycoreTaiko {
525        /// The actual decrease to apply
526        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
527        pub speed_change: Option<f64>,
528    }
529    /// Simplify tricky rhythms!
530    #[derive(Clone, Debug, Default, PartialEq)]
531    #[cfg_attr(
532        feature = "rkyv",
533        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
534    )]
535    pub struct SimplifiedRhythmTaiko {
536        /// Converts 1/3 patterns to 1/2 rhythm.
537        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
538        pub one_third_conversion: Option<bool>,
539        /// Converts 1/6 patterns to 1/4 rhythm.
540        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
541        pub one_sixth_conversion: Option<bool>,
542        /// Converts 1/8 patterns to 1/4 rhythm.
543        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
544        pub one_eighth_conversion: Option<bool>,
545    }
546    /// Everything just got a bit harder...
547    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
548    #[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))]
549    pub struct HardRockTaiko {}
550    /// Miss and fail.
551    #[derive(Clone, Debug, Default, PartialEq)]
552    #[cfg_attr(
553        feature = "rkyv",
554        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
555    )]
556    pub struct SuddenDeathTaiko {
557        /// Automatically restarts when failed.
558        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
559        pub restart: Option<bool>,
560    }
561    /// SS or quit.
562    #[derive(Clone, Debug, Default, PartialEq)]
563    #[cfg_attr(
564        feature = "rkyv",
565        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
566    )]
567    pub struct PerfectTaiko {
568        /// Automatically restarts when failed.
569        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
570        pub restart: Option<bool>,
571    }
572    /// Zoooooooooom...
573    #[derive(Clone, Debug, Default, PartialEq)]
574    #[cfg_attr(
575        feature = "rkyv",
576        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
577    )]
578    pub struct DoubleTimeTaiko {
579        /// The actual increase to apply
580        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
581        pub speed_change: Option<f64>,
582        /// Should pitch be adjusted with speed
583        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
584        pub adjust_pitch: Option<bool>,
585    }
586    /// Uguuuuuuuu...
587    #[derive(Clone, Debug, Default, PartialEq)]
588    #[cfg_attr(
589        feature = "rkyv",
590        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
591    )]
592    pub struct NightcoreTaiko {
593        /// The actual increase to apply
594        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
595        pub speed_change: Option<f64>,
596    }
597    /// Beats fade out before you hit them!
598    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
599    #[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))]
600    pub struct HiddenTaiko {}
601    /// Restricted view area.
602    #[derive(Clone, Debug, Default, PartialEq)]
603    #[cfg_attr(
604        feature = "rkyv",
605        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
606    )]
607    pub struct FlashlightTaiko {
608        /// Multiplier applied to the default flashlight size.
609        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
610        pub size_multiplier: Option<f64>,
611        /// Decrease the flashlight size as combo increases.
612        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
613        pub combo_based_size: Option<bool>,
614    }
615    /// Fail if your accuracy drops too low!
616    #[derive(Clone, Debug, Default, PartialEq)]
617    #[cfg_attr(
618        feature = "rkyv",
619        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
620    )]
621    pub struct AccuracyChallengeTaiko {
622        /// Trigger a failure if your accuracy goes below this value.
623        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
624        pub minimum_accuracy: Option<f64>,
625        /// The mode of accuracy that will trigger failure.
626        pub accuracy_judge_mode: Option<String>,
627        /// Automatically restarts when failed.
628        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
629        pub restart: Option<bool>,
630    }
631    /// Shuffle around the colours!
632    #[derive(Clone, Debug, Default, PartialEq)]
633    #[cfg_attr(
634        feature = "rkyv",
635        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
636    )]
637    pub struct RandomTaiko {
638        /// Use a custom seed instead of a random one
639        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
640        pub seed: Option<f64>,
641    }
642    /// Override a beatmap's difficulty settings.
643    #[derive(Clone, Debug, Default, PartialEq)]
644    #[cfg_attr(
645        feature = "rkyv",
646        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
647    )]
648    pub struct DifficultyAdjustTaiko {
649        /// Adjust a beatmap's set scroll speed
650        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
651        pub scroll_speed: Option<f64>,
652        /// Override a beatmap's set HP.
653        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
654        pub drain_rate: Option<f64>,
655        /// Override a beatmap's set OD.
656        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
657        pub overall_difficulty: Option<f64>,
658        /// Adjust difficulty beyond sane limits.
659        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
660        pub extended_limits: Option<bool>,
661    }
662    /// Feeling nostalgic?
663    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
664    #[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))]
665    pub struct ClassicTaiko {}
666    /// Dons become kats, kats become dons
667    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
668    #[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))]
669    pub struct SwapTaiko {}
670    /// One key for dons, one key for kats.
671    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
672    #[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))]
673    pub struct SingleTapTaiko {}
674    /// No more tricky speed changes!
675    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
676    #[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))]
677    pub struct ConstantSpeedTaiko {}
678    /// Watch a perfect automated play through the song.
679    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
680    #[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))]
681    pub struct AutoplayTaiko {}
682    /// Watch the video without visual distractions.
683    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
684    #[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))]
685    pub struct CinemaTaiko {}
686    /// No need to remember which key is correct anymore!
687    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
688    #[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))]
689    pub struct RelaxTaiko {}
690    /// Can you keep up?
691    #[derive(Clone, Debug, Default, PartialEq)]
692    #[cfg_attr(
693        feature = "rkyv",
694        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
695    )]
696    pub struct WindUpTaiko {
697        /// The starting speed of the track
698        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
699        pub initial_rate: Option<f64>,
700        /// The final speed to ramp to
701        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
702        pub final_rate: Option<f64>,
703        /// Should pitch be adjusted with speed
704        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
705        pub adjust_pitch: Option<bool>,
706    }
707    /// Sloooow doooown...
708    #[derive(Clone, Debug, Default, PartialEq)]
709    #[cfg_attr(
710        feature = "rkyv",
711        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
712    )]
713    pub struct WindDownTaiko {
714        /// The starting speed of the track
715        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
716        pub initial_rate: Option<f64>,
717        /// The final speed to ramp to
718        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
719        pub final_rate: Option<f64>,
720        /// Should pitch be adjusted with speed
721        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
722        pub adjust_pitch: Option<bool>,
723    }
724    /// Can you still feel the rhythm without music?
725    #[derive(Clone, Debug, Default, PartialEq)]
726    #[cfg_attr(
727        feature = "rkyv",
728        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
729    )]
730    pub struct MutedTaiko {
731        /// Increase volume as combo builds.
732        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
733        pub inverse_muting: Option<bool>,
734        /// Add a metronome beat to help you keep track of the rhythm.
735        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
736        pub enable_metronome: Option<bool>,
737        /// The combo count at which point the track reaches its final volume.
738        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
739        pub mute_combo_count: Option<f64>,
740        /// Hit sounds are also muted alongside the track.
741        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
742        pub affects_hit_sounds: Option<bool>,
743    }
744    /// Let track speed adapt to you.
745    #[derive(Clone, Debug, Default, PartialEq)]
746    #[cfg_attr(
747        feature = "rkyv",
748        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
749    )]
750    pub struct AdaptiveSpeedTaiko {
751        /// The starting speed of the track
752        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
753        pub initial_rate: Option<f64>,
754        /// Should pitch be adjusted with speed
755        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
756        pub adjust_pitch: Option<bool>,
757    }
758    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
759    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
760    #[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))]
761    pub struct ScoreV2Taiko {}
762    /// Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!
763    #[derive(Clone, Debug, Default, PartialEq)]
764    #[cfg_attr(
765        feature = "rkyv",
766        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
767    )]
768    pub struct EasyCatch {
769        /// Number of extra lives
770        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
771        pub retries: Option<f64>,
772    }
773    /// You can't fail, no matter what.
774    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
775    #[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))]
776    pub struct NoFailCatch {}
777    /// Less zoom...
778    #[derive(Clone, Debug, Default, PartialEq)]
779    #[cfg_attr(
780        feature = "rkyv",
781        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
782    )]
783    pub struct HalfTimeCatch {
784        /// The actual decrease to apply
785        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
786        pub speed_change: Option<f64>,
787        /// Should pitch be adjusted with speed
788        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
789        pub adjust_pitch: Option<bool>,
790    }
791    /// Whoaaaaa...
792    #[derive(Clone, Debug, Default, PartialEq)]
793    #[cfg_attr(
794        feature = "rkyv",
795        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
796    )]
797    pub struct DaycoreCatch {
798        /// The actual decrease to apply
799        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
800        pub speed_change: Option<f64>,
801    }
802    /// Everything just got a bit harder...
803    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
804    #[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))]
805    pub struct HardRockCatch {}
806    /// Miss and fail.
807    #[derive(Clone, Debug, Default, PartialEq)]
808    #[cfg_attr(
809        feature = "rkyv",
810        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
811    )]
812    pub struct SuddenDeathCatch {
813        /// Automatically restarts when failed.
814        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
815        pub restart: Option<bool>,
816    }
817    /// SS or quit.
818    #[derive(Clone, Debug, Default, PartialEq)]
819    #[cfg_attr(
820        feature = "rkyv",
821        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
822    )]
823    pub struct PerfectCatch {
824        /// Automatically restarts when failed.
825        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
826        pub restart: Option<bool>,
827    }
828    /// Zoooooooooom...
829    #[derive(Clone, Debug, Default, PartialEq)]
830    #[cfg_attr(
831        feature = "rkyv",
832        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
833    )]
834    pub struct DoubleTimeCatch {
835        /// The actual increase to apply
836        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
837        pub speed_change: Option<f64>,
838        /// Should pitch be adjusted with speed
839        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
840        pub adjust_pitch: Option<bool>,
841    }
842    /// Uguuuuuuuu...
843    #[derive(Clone, Debug, Default, PartialEq)]
844    #[cfg_attr(
845        feature = "rkyv",
846        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
847    )]
848    pub struct NightcoreCatch {
849        /// The actual increase to apply
850        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
851        pub speed_change: Option<f64>,
852    }
853    /// Play with fading fruits.
854    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
855    #[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))]
856    pub struct HiddenCatch {}
857    /// Restricted view area.
858    #[derive(Clone, Debug, Default, PartialEq)]
859    #[cfg_attr(
860        feature = "rkyv",
861        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
862    )]
863    pub struct FlashlightCatch {
864        /// Multiplier applied to the default flashlight size.
865        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
866        pub size_multiplier: Option<f64>,
867        /// Decrease the flashlight size as combo increases.
868        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
869        pub combo_based_size: Option<bool>,
870    }
871    /// Fail if your accuracy drops too low!
872    #[derive(Clone, Debug, Default, PartialEq)]
873    #[cfg_attr(
874        feature = "rkyv",
875        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
876    )]
877    pub struct AccuracyChallengeCatch {
878        /// Trigger a failure if your accuracy goes below this value.
879        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
880        pub minimum_accuracy: Option<f64>,
881        /// The mode of accuracy that will trigger failure.
882        pub accuracy_judge_mode: Option<String>,
883        /// Automatically restarts when failed.
884        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
885        pub restart: Option<bool>,
886    }
887    /// Override a beatmap's difficulty settings.
888    #[derive(Clone, Debug, Default, PartialEq)]
889    #[cfg_attr(
890        feature = "rkyv",
891        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
892    )]
893    pub struct DifficultyAdjustCatch {
894        /// Override a beatmap's set CS.
895        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
896        pub circle_size: Option<f64>,
897        /// Override a beatmap's set AR.
898        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
899        pub approach_rate: Option<f64>,
900        /// Adjust the patterns as if Hard Rock is enabled.
901        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
902        pub hard_rock_offsets: Option<bool>,
903        /// Override a beatmap's set HP.
904        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
905        pub drain_rate: Option<f64>,
906        /// Override a beatmap's set OD.
907        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
908        pub overall_difficulty: Option<f64>,
909        /// Adjust difficulty beyond sane limits.
910        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
911        pub extended_limits: Option<bool>,
912    }
913    /// Feeling nostalgic?
914    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
915    #[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))]
916    pub struct ClassicCatch {}
917    /// Fruits are flipped horizontally.
918    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
919    #[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))]
920    pub struct MirrorCatch {}
921    /// Watch a perfect automated play through the song.
922    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
923    #[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))]
924    pub struct AutoplayCatch {}
925    /// Watch the video without visual distractions.
926    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
927    #[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))]
928    pub struct CinemaCatch {}
929    /// Use the mouse to control the catcher.
930    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
931    #[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))]
932    pub struct RelaxCatch {}
933    /// Can you keep up?
934    #[derive(Clone, Debug, Default, PartialEq)]
935    #[cfg_attr(
936        feature = "rkyv",
937        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
938    )]
939    pub struct WindUpCatch {
940        /// The starting speed of the track
941        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
942        pub initial_rate: Option<f64>,
943        /// The final speed to ramp to
944        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
945        pub final_rate: Option<f64>,
946        /// Should pitch be adjusted with speed
947        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
948        pub adjust_pitch: Option<bool>,
949    }
950    /// Sloooow doooown...
951    #[derive(Clone, Debug, Default, PartialEq)]
952    #[cfg_attr(
953        feature = "rkyv",
954        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
955    )]
956    pub struct WindDownCatch {
957        /// The starting speed of the track
958        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
959        pub initial_rate: Option<f64>,
960        /// The final speed to ramp to
961        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
962        pub final_rate: Option<f64>,
963        /// Should pitch be adjusted with speed
964        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
965        pub adjust_pitch: Option<bool>,
966    }
967    /// The fruits are... floating?
968    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
969    #[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))]
970    pub struct FloatingFruitsCatch {}
971    /// Can you still feel the rhythm without music?
972    #[derive(Clone, Debug, Default, PartialEq)]
973    #[cfg_attr(
974        feature = "rkyv",
975        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
976    )]
977    pub struct MutedCatch {
978        /// Increase volume as combo builds.
979        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
980        pub inverse_muting: Option<bool>,
981        /// Add a metronome beat to help you keep track of the rhythm.
982        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
983        pub enable_metronome: Option<bool>,
984        /// The combo count at which point the track reaches its final volume.
985        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
986        pub mute_combo_count: Option<f64>,
987        /// Hit sounds are also muted alongside the track.
988        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
989        pub affects_hit_sounds: Option<bool>,
990    }
991    /// Where's the catcher?
992    #[derive(Clone, Debug, Default, PartialEq)]
993    #[cfg_attr(
994        feature = "rkyv",
995        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
996    )]
997    pub struct NoScopeCatch {
998        /// The combo count at which the cursor becomes completely hidden
999        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1000        pub hidden_combo_count: Option<f64>,
1001    }
1002    /// Dashing by default, slow down!
1003    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1004    #[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))]
1005    pub struct MovingFastCatch {}
1006    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
1007    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1008    #[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))]
1009    pub struct ScoreV2Catch {}
1010    /// More forgiving HP drain, less accuracy required, and extra lives!
1011    #[derive(Clone, Debug, Default, PartialEq)]
1012    #[cfg_attr(
1013        feature = "rkyv",
1014        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1015    )]
1016    pub struct EasyMania {
1017        /// Number of extra lives
1018        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1019        pub retries: Option<f64>,
1020    }
1021    /// You can't fail, no matter what.
1022    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1023    #[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))]
1024    pub struct NoFailMania {}
1025    /// Less zoom...
1026    #[derive(Clone, Debug, Default, PartialEq)]
1027    #[cfg_attr(
1028        feature = "rkyv",
1029        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1030    )]
1031    pub struct HalfTimeMania {
1032        /// The actual decrease to apply
1033        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1034        pub speed_change: Option<f64>,
1035        /// Should pitch be adjusted with speed
1036        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1037        pub adjust_pitch: Option<bool>,
1038    }
1039    /// Whoaaaaa...
1040    #[derive(Clone, Debug, Default, PartialEq)]
1041    #[cfg_attr(
1042        feature = "rkyv",
1043        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1044    )]
1045    pub struct DaycoreMania {
1046        /// The actual decrease to apply
1047        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1048        pub speed_change: Option<f64>,
1049    }
1050    /// No more timing the end of hold notes.
1051    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1052    #[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))]
1053    pub struct NoReleaseMania {}
1054    /// Everything just got a bit harder...
1055    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1056    #[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))]
1057    pub struct HardRockMania {}
1058    /// Miss and fail.
1059    #[derive(Clone, Debug, Default, PartialEq)]
1060    #[cfg_attr(
1061        feature = "rkyv",
1062        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1063    )]
1064    pub struct SuddenDeathMania {
1065        /// Automatically restarts when failed.
1066        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1067        pub restart: Option<bool>,
1068    }
1069    /// SS or quit.
1070    #[derive(Clone, Debug, Default, PartialEq)]
1071    #[cfg_attr(
1072        feature = "rkyv",
1073        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1074    )]
1075    pub struct PerfectMania {
1076        ///
1077        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1078        pub require_perfect_hits: Option<bool>,
1079        /// Automatically restarts when failed.
1080        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1081        pub restart: Option<bool>,
1082    }
1083    /// Zoooooooooom...
1084    #[derive(Clone, Debug, Default, PartialEq)]
1085    #[cfg_attr(
1086        feature = "rkyv",
1087        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1088    )]
1089    pub struct DoubleTimeMania {
1090        /// The actual increase to apply
1091        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1092        pub speed_change: Option<f64>,
1093        /// Should pitch be adjusted with speed
1094        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1095        pub adjust_pitch: Option<bool>,
1096    }
1097    /// Uguuuuuuuu...
1098    #[derive(Clone, Debug, Default, PartialEq)]
1099    #[cfg_attr(
1100        feature = "rkyv",
1101        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1102    )]
1103    pub struct NightcoreMania {
1104        /// The actual increase to apply
1105        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1106        pub speed_change: Option<f64>,
1107    }
1108    /// Keys appear out of nowhere!
1109    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1110    #[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))]
1111    pub struct FadeInMania {}
1112    /// Keys fade out before you hit them!
1113    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1114    #[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))]
1115    pub struct HiddenMania {}
1116    /// Decrease the playfield's viewing area.
1117    #[derive(Clone, Debug, Default, PartialEq)]
1118    #[cfg_attr(
1119        feature = "rkyv",
1120        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1121    )]
1122    pub struct CoverMania {
1123        /// The proportion of playfield height that notes will be hidden for.
1124        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1125        pub coverage: Option<f64>,
1126        /// The direction on which the cover is applied
1127        pub direction: Option<String>,
1128    }
1129    /// Restricted view area.
1130    #[derive(Clone, Debug, Default, PartialEq)]
1131    #[cfg_attr(
1132        feature = "rkyv",
1133        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1134    )]
1135    pub struct FlashlightMania {
1136        /// Multiplier applied to the default flashlight size.
1137        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1138        pub size_multiplier: Option<f64>,
1139        /// Decrease the flashlight size as combo increases.
1140        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1141        pub combo_based_size: Option<bool>,
1142    }
1143    /// Fail if your accuracy drops too low!
1144    #[derive(Clone, Debug, Default, PartialEq)]
1145    #[cfg_attr(
1146        feature = "rkyv",
1147        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1148    )]
1149    pub struct AccuracyChallengeMania {
1150        /// Trigger a failure if your accuracy goes below this value.
1151        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1152        pub minimum_accuracy: Option<f64>,
1153        /// The mode of accuracy that will trigger failure.
1154        pub accuracy_judge_mode: Option<String>,
1155        /// Automatically restarts when failed.
1156        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1157        pub restart: Option<bool>,
1158    }
1159    /// Shuffle around the keys!
1160    #[derive(Clone, Debug, Default, PartialEq)]
1161    #[cfg_attr(
1162        feature = "rkyv",
1163        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1164    )]
1165    pub struct RandomMania {
1166        /// Use a custom seed instead of a random one
1167        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1168        pub seed: Option<f64>,
1169    }
1170    /// Double the stages, double the fun!
1171    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1172    #[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))]
1173    pub struct DualStagesMania {}
1174    /// Notes are flipped horizontally.
1175    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1176    #[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))]
1177    pub struct MirrorMania {}
1178    /// Override a beatmap's difficulty settings.
1179    #[derive(Clone, Debug, Default, PartialEq)]
1180    #[cfg_attr(
1181        feature = "rkyv",
1182        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1183    )]
1184    pub struct DifficultyAdjustMania {
1185        /// Override a beatmap's set OD.
1186        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1187        pub overall_difficulty: Option<f64>,
1188        /// Override a beatmap's set HP.
1189        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1190        pub drain_rate: Option<f64>,
1191        /// Adjust difficulty beyond sane limits.
1192        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1193        pub extended_limits: Option<bool>,
1194    }
1195    /// Feeling nostalgic?
1196    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1197    #[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))]
1198    pub struct ClassicMania {}
1199    /// Hold the keys. To the beat.
1200    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1201    #[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))]
1202    pub struct InvertMania {}
1203    /// No more tricky speed changes!
1204    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1205    #[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))]
1206    pub struct ConstantSpeedMania {}
1207    /// Replaces all hold notes with normal notes.
1208    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1209    #[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))]
1210    pub struct HoldOffMania {}
1211    /// Play with one key.
1212    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1213    #[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))]
1214    pub struct OneKeyMania {}
1215    /// Play with two keys.
1216    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1217    #[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))]
1218    pub struct TwoKeysMania {}
1219    /// Play with three keys.
1220    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1221    #[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))]
1222    pub struct ThreeKeysMania {}
1223    /// Play with four keys.
1224    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1225    #[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))]
1226    pub struct FourKeysMania {}
1227    /// Play with five keys.
1228    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1229    #[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))]
1230    pub struct FiveKeysMania {}
1231    /// Play with six keys.
1232    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1233    #[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))]
1234    pub struct SixKeysMania {}
1235    /// Play with seven keys.
1236    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1237    #[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))]
1238    pub struct SevenKeysMania {}
1239    /// Play with eight keys.
1240    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1241    #[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))]
1242    pub struct EightKeysMania {}
1243    /// Play with nine keys.
1244    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1245    #[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))]
1246    pub struct NineKeysMania {}
1247    /// Play with ten keys.
1248    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1249    #[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))]
1250    pub struct TenKeysMania {}
1251    /// Watch a perfect automated play through the song.
1252    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1253    #[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))]
1254    pub struct AutoplayMania {}
1255    /// Watch the video without visual distractions.
1256    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1257    #[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))]
1258    pub struct CinemaMania {}
1259    /// Can you keep up?
1260    #[derive(Clone, Debug, Default, PartialEq)]
1261    #[cfg_attr(
1262        feature = "rkyv",
1263        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1264    )]
1265    pub struct WindUpMania {
1266        /// The starting speed of the track
1267        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1268        pub initial_rate: Option<f64>,
1269        /// The final speed to ramp to
1270        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1271        pub final_rate: Option<f64>,
1272        /// Should pitch be adjusted with speed
1273        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1274        pub adjust_pitch: Option<bool>,
1275    }
1276    /// Sloooow doooown...
1277    #[derive(Clone, Debug, Default, PartialEq)]
1278    #[cfg_attr(
1279        feature = "rkyv",
1280        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1281    )]
1282    pub struct WindDownMania {
1283        /// The starting speed of the track
1284        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1285        pub initial_rate: Option<f64>,
1286        /// The final speed to ramp to
1287        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1288        pub final_rate: Option<f64>,
1289        /// Should pitch be adjusted with speed
1290        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1291        pub adjust_pitch: Option<bool>,
1292    }
1293    /// Can you still feel the rhythm without music?
1294    #[derive(Clone, Debug, Default, PartialEq)]
1295    #[cfg_attr(
1296        feature = "rkyv",
1297        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1298    )]
1299    pub struct MutedMania {
1300        /// Increase volume as combo builds.
1301        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1302        pub inverse_muting: Option<bool>,
1303        /// Add a metronome beat to help you keep track of the rhythm.
1304        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1305        pub enable_metronome: Option<bool>,
1306        /// The combo count at which point the track reaches its final volume.
1307        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1308        pub mute_combo_count: Option<f64>,
1309        /// Hit sounds are also muted alongside the track.
1310        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1311        pub affects_hit_sounds: Option<bool>,
1312    }
1313    /// Let track speed adapt to you.
1314    #[derive(Clone, Debug, Default, PartialEq)]
1315    #[cfg_attr(
1316        feature = "rkyv",
1317        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1318    )]
1319    pub struct AdaptiveSpeedMania {
1320        /// The starting speed of the track
1321        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1322        pub initial_rate: Option<f64>,
1323        /// Should pitch be adjusted with speed
1324        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1325        pub adjust_pitch: Option<bool>,
1326    }
1327    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
1328    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1329    #[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))]
1330    pub struct ScoreV2Mania {}
1331    /// Any unknown mod.
1332    #[derive(Copy, Eq, Clone, Debug, PartialEq, PartialOrd, Ord, Hash)]
1333    #[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),)]
1334    pub struct UnknownMod {
1335        pub acronym: crate::Acronym,
1336    }
1337}
1338use crate::GameModKind;
1339pub use all_structs::{
1340    AccuracyChallengeCatch, AccuracyChallengeMania, AccuracyChallengeOsu, AccuracyChallengeTaiko,
1341    AdaptiveSpeedMania, AdaptiveSpeedOsu, AdaptiveSpeedTaiko, AlternateOsu, ApproachDifferentOsu,
1342    AutopilotOsu, AutoplayCatch, AutoplayMania, AutoplayOsu, AutoplayTaiko, BarrelRollOsu,
1343    BlindsOsu, BloomOsu, BubblesOsu, CinemaCatch, CinemaMania, CinemaOsu, CinemaTaiko,
1344    ClassicCatch, ClassicMania, ClassicOsu, ClassicTaiko, ConstantSpeedMania, ConstantSpeedTaiko,
1345    CoverMania, DaycoreCatch, DaycoreMania, DaycoreOsu, DaycoreTaiko, DeflateOsu, DepthOsu,
1346    DifficultyAdjustCatch, DifficultyAdjustMania, DifficultyAdjustOsu, DifficultyAdjustTaiko,
1347    DoubleTimeCatch, DoubleTimeMania, DoubleTimeOsu, DoubleTimeTaiko, DualStagesMania, EasyCatch,
1348    EasyMania, EasyOsu, EasyTaiko, EightKeysMania, FadeInMania, FiveKeysMania, FlashlightCatch,
1349    FlashlightMania, FlashlightOsu, FlashlightTaiko, FloatingFruitsCatch, FourKeysMania,
1350    FreezeFrameOsu, GrowOsu, HalfTimeCatch, HalfTimeMania, HalfTimeOsu, HalfTimeTaiko,
1351    HardRockCatch, HardRockMania, HardRockOsu, HardRockTaiko, HiddenCatch, HiddenMania, HiddenOsu,
1352    HiddenTaiko, HoldOffMania, InvertMania, MagnetisedOsu, MirrorCatch, MirrorMania, MirrorOsu,
1353    MovingFastCatch, MutedCatch, MutedMania, MutedOsu, MutedTaiko, NightcoreCatch, NightcoreMania,
1354    NightcoreOsu, NightcoreTaiko, NineKeysMania, NoFailCatch, NoFailMania, NoFailOsu, NoFailTaiko,
1355    NoReleaseMania, NoScopeCatch, NoScopeOsu, OneKeyMania, PerfectCatch, PerfectMania, PerfectOsu,
1356    PerfectTaiko, RandomMania, RandomOsu, RandomTaiko, RelaxCatch, RelaxOsu, RelaxTaiko, RepelOsu,
1357    ScoreV2Catch, ScoreV2Mania, ScoreV2Osu, ScoreV2Taiko, SevenKeysMania, SimplifiedRhythmTaiko,
1358    SingleTapOsu, SingleTapTaiko, SixKeysMania, SpinInOsu, SpunOutOsu, StrictTrackingOsu,
1359    SuddenDeathCatch, SuddenDeathMania, SuddenDeathOsu, SuddenDeathTaiko, SwapTaiko,
1360    SynesthesiaOsu, TargetPracticeOsu, TenKeysMania, ThreeKeysMania, TouchDeviceOsu, TraceableOsu,
1361    TransformOsu, TwoKeysMania, UnknownMod, WiggleOsu, WindDownCatch, WindDownMania, WindDownOsu,
1362    WindDownTaiko, WindUpCatch, WindUpMania, WindUpOsu, WindUpTaiko,
1363};
1364pub use gamemod::GameMod;
1365pub use intermode::GameModIntermode;
1366/// Types for (de)serialization through `rkyv`.
1367#[cfg(feature = "rkyv")]
1368#[cfg_attr(all(docsrs, not(doctest)), doc(cfg(feature = "rkyv")))]
1369#[doc(hidden)]
1370pub mod rkyv {
1371    pub use super::all_structs::{
1372        AccuracyChallengeCatchResolver, AccuracyChallengeManiaResolver,
1373        AccuracyChallengeOsuResolver, AccuracyChallengeTaikoResolver, AdaptiveSpeedManiaResolver,
1374        AdaptiveSpeedOsuResolver, AdaptiveSpeedTaikoResolver, AlternateOsuResolver,
1375        ApproachDifferentOsuResolver, ArchivedAccuracyChallengeCatch,
1376        ArchivedAccuracyChallengeMania, ArchivedAccuracyChallengeOsu,
1377        ArchivedAccuracyChallengeTaiko, ArchivedAdaptiveSpeedMania, ArchivedAdaptiveSpeedOsu,
1378        ArchivedAdaptiveSpeedTaiko, ArchivedApproachDifferentOsu, ArchivedBarrelRollOsu,
1379        ArchivedBloomOsu, ArchivedClassicOsu, ArchivedCoverMania, ArchivedDaycoreCatch,
1380        ArchivedDaycoreMania, ArchivedDaycoreOsu, ArchivedDaycoreTaiko, ArchivedDeflateOsu,
1381        ArchivedDepthOsu, ArchivedDifficultyAdjustCatch, ArchivedDifficultyAdjustMania,
1382        ArchivedDifficultyAdjustOsu, ArchivedDifficultyAdjustTaiko, ArchivedDoubleTimeCatch,
1383        ArchivedDoubleTimeMania, ArchivedDoubleTimeOsu, ArchivedDoubleTimeTaiko, ArchivedEasyCatch,
1384        ArchivedEasyMania, ArchivedEasyOsu, ArchivedFlashlightCatch, ArchivedFlashlightMania,
1385        ArchivedFlashlightOsu, ArchivedFlashlightTaiko, ArchivedGrowOsu, ArchivedHalfTimeCatch,
1386        ArchivedHalfTimeMania, ArchivedHalfTimeOsu, ArchivedHalfTimeTaiko, ArchivedHiddenOsu,
1387        ArchivedMagnetisedOsu, ArchivedMirrorOsu, ArchivedMutedCatch, ArchivedMutedMania,
1388        ArchivedMutedOsu, ArchivedMutedTaiko, ArchivedNightcoreCatch, ArchivedNightcoreMania,
1389        ArchivedNightcoreOsu, ArchivedNightcoreTaiko, ArchivedNoScopeCatch, ArchivedNoScopeOsu,
1390        ArchivedPerfectCatch, ArchivedPerfectMania, ArchivedPerfectOsu, ArchivedPerfectTaiko,
1391        ArchivedRandomMania, ArchivedRandomOsu, ArchivedRandomTaiko, ArchivedRepelOsu,
1392        ArchivedSimplifiedRhythmTaiko, ArchivedSuddenDeathCatch, ArchivedSuddenDeathMania,
1393        ArchivedSuddenDeathOsu, ArchivedSuddenDeathTaiko, ArchivedTargetPracticeOsu,
1394        ArchivedWiggleOsu, ArchivedWindDownCatch, ArchivedWindDownMania, ArchivedWindDownOsu,
1395        ArchivedWindDownTaiko, ArchivedWindUpCatch, ArchivedWindUpMania, ArchivedWindUpOsu,
1396        ArchivedWindUpTaiko, AutopilotOsuResolver, AutoplayCatchResolver, AutoplayManiaResolver,
1397        AutoplayOsuResolver, AutoplayTaikoResolver, BarrelRollOsuResolver, BlindsOsuResolver,
1398        BloomOsuResolver, BubblesOsuResolver, CinemaCatchResolver, CinemaManiaResolver,
1399        CinemaOsuResolver, CinemaTaikoResolver, ClassicCatchResolver, ClassicManiaResolver,
1400        ClassicOsuResolver, ClassicTaikoResolver, ConstantSpeedManiaResolver,
1401        ConstantSpeedTaikoResolver, CoverManiaResolver, DaycoreCatchResolver, DaycoreManiaResolver,
1402        DaycoreOsuResolver, DaycoreTaikoResolver, DeflateOsuResolver, DepthOsuResolver,
1403        DifficultyAdjustCatchResolver, DifficultyAdjustManiaResolver, DifficultyAdjustOsuResolver,
1404        DifficultyAdjustTaikoResolver, DoubleTimeCatchResolver, DoubleTimeManiaResolver,
1405        DoubleTimeOsuResolver, DoubleTimeTaikoResolver, DualStagesManiaResolver, EasyCatchResolver,
1406        EasyManiaResolver, EasyOsuResolver, EasyTaikoResolver, EightKeysManiaResolver,
1407        FadeInManiaResolver, FiveKeysManiaResolver, FlashlightCatchResolver,
1408        FlashlightManiaResolver, FlashlightOsuResolver, FlashlightTaikoResolver,
1409        FloatingFruitsCatchResolver, FourKeysManiaResolver, FreezeFrameOsuResolver,
1410        GrowOsuResolver, HalfTimeCatchResolver, HalfTimeManiaResolver, HalfTimeOsuResolver,
1411        HalfTimeTaikoResolver, HardRockCatchResolver, HardRockManiaResolver, HardRockOsuResolver,
1412        HardRockTaikoResolver, HiddenCatchResolver, HiddenManiaResolver, HiddenOsuResolver,
1413        HiddenTaikoResolver, HoldOffManiaResolver, InvertManiaResolver, MagnetisedOsuResolver,
1414        MirrorCatchResolver, MirrorManiaResolver, MirrorOsuResolver, MovingFastCatchResolver,
1415        MutedCatchResolver, MutedManiaResolver, MutedOsuResolver, MutedTaikoResolver,
1416        NightcoreCatchResolver, NightcoreManiaResolver, NightcoreOsuResolver,
1417        NightcoreTaikoResolver, NineKeysManiaResolver, NoFailCatchResolver, NoFailManiaResolver,
1418        NoFailOsuResolver, NoFailTaikoResolver, NoReleaseManiaResolver, NoScopeCatchResolver,
1419        NoScopeOsuResolver, OneKeyManiaResolver, PerfectCatchResolver, PerfectManiaResolver,
1420        PerfectOsuResolver, PerfectTaikoResolver, RandomManiaResolver, RandomOsuResolver,
1421        RandomTaikoResolver, RelaxCatchResolver, RelaxOsuResolver, RelaxTaikoResolver,
1422        RepelOsuResolver, ScoreV2CatchResolver, ScoreV2ManiaResolver, ScoreV2OsuResolver,
1423        ScoreV2TaikoResolver, SevenKeysManiaResolver, SimplifiedRhythmTaikoResolver,
1424        SingleTapOsuResolver, SingleTapTaikoResolver, SixKeysManiaResolver, SpinInOsuResolver,
1425        SpunOutOsuResolver, StrictTrackingOsuResolver, SuddenDeathCatchResolver,
1426        SuddenDeathManiaResolver, SuddenDeathOsuResolver, SuddenDeathTaikoResolver,
1427        SwapTaikoResolver, SynesthesiaOsuResolver, TargetPracticeOsuResolver, TenKeysManiaResolver,
1428        ThreeKeysManiaResolver, TouchDeviceOsuResolver, TraceableOsuResolver, TransformOsuResolver,
1429        TwoKeysManiaResolver, UnknownModResolver, WiggleOsuResolver, WindDownCatchResolver,
1430        WindDownManiaResolver, WindDownOsuResolver, WindDownTaikoResolver, WindUpCatchResolver,
1431        WindUpManiaResolver, WindUpOsuResolver, WindUpTaikoResolver,
1432    };
1433    pub use super::gamemod::{ArchivedGameMod, GameModResolver};
1434    pub use super::intermode::GameModIntermodeResolver;
1435    pub use crate::kind::GameModKindResolver;
1436}
1437impl EasyOsu {
1438    /// The acronym of [`EasyOsu`]
1439    pub const fn acronym() -> Acronym {
1440        unsafe { Acronym::from_str_unchecked("EZ") }
1441    }
1442    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyOsu`]
1443    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1444        unsafe {
1445            [
1446                Acronym::from_str_unchecked("HR"),
1447                Acronym::from_str_unchecked("AC"),
1448                Acronym::from_str_unchecked("DA"),
1449            ]
1450        }
1451        .into_iter()
1452    }
1453    /// The description of [`EasyOsu`]
1454    pub const fn description() -> &'static str {
1455        "Larger circles, more forgiving HP drain, less accuracy required, and extra lives!"
1456    }
1457    /// The [`GameModKind`] of [`EasyOsu`]
1458    pub const fn kind() -> GameModKind {
1459        GameModKind::DifficultyReduction
1460    }
1461    /// Bit value of [`EasyOsu`]
1462    ///
1463    /// See <https://github.com/ppy/osu-api/wiki#mods>
1464    pub const fn bits() -> u32 {
1465        2
1466    }
1467}
1468impl NoFailOsu {
1469    /// The acronym of [`NoFailOsu`]
1470    pub const fn acronym() -> Acronym {
1471        unsafe { Acronym::from_str_unchecked("NF") }
1472    }
1473    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailOsu`]
1474    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1475        unsafe {
1476            [
1477                Acronym::from_str_unchecked("SD"),
1478                Acronym::from_str_unchecked("PF"),
1479                Acronym::from_str_unchecked("AC"),
1480                Acronym::from_str_unchecked("CN"),
1481            ]
1482        }
1483        .into_iter()
1484    }
1485    /// The description of [`NoFailOsu`]
1486    pub const fn description() -> &'static str {
1487        "You can't fail, no matter what."
1488    }
1489    /// The [`GameModKind`] of [`NoFailOsu`]
1490    pub const fn kind() -> GameModKind {
1491        GameModKind::DifficultyReduction
1492    }
1493    /// Bit value of [`NoFailOsu`]
1494    ///
1495    /// See <https://github.com/ppy/osu-api/wiki#mods>
1496    pub const fn bits() -> u32 {
1497        1
1498    }
1499}
1500impl HalfTimeOsu {
1501    /// The acronym of [`HalfTimeOsu`]
1502    pub const fn acronym() -> Acronym {
1503        unsafe { Acronym::from_str_unchecked("HT") }
1504    }
1505    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeOsu`]
1506    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1507        unsafe {
1508            [
1509                Acronym::from_str_unchecked("DC"),
1510                Acronym::from_str_unchecked("DT"),
1511                Acronym::from_str_unchecked("NC"),
1512                Acronym::from_str_unchecked("WU"),
1513                Acronym::from_str_unchecked("WD"),
1514                Acronym::from_str_unchecked("AS"),
1515            ]
1516        }
1517        .into_iter()
1518    }
1519    /// The description of [`HalfTimeOsu`]
1520    pub const fn description() -> &'static str {
1521        "Less zoom..."
1522    }
1523    /// The [`GameModKind`] of [`HalfTimeOsu`]
1524    pub const fn kind() -> GameModKind {
1525        GameModKind::DifficultyReduction
1526    }
1527    /// Bit value of [`HalfTimeOsu`]
1528    ///
1529    /// See <https://github.com/ppy/osu-api/wiki#mods>
1530    pub const fn bits() -> u32 {
1531        256
1532    }
1533}
1534impl DaycoreOsu {
1535    /// The acronym of [`DaycoreOsu`]
1536    pub const fn acronym() -> Acronym {
1537        unsafe { Acronym::from_str_unchecked("DC") }
1538    }
1539    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreOsu`]
1540    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1541        unsafe {
1542            [
1543                Acronym::from_str_unchecked("HT"),
1544                Acronym::from_str_unchecked("DT"),
1545                Acronym::from_str_unchecked("NC"),
1546                Acronym::from_str_unchecked("WU"),
1547                Acronym::from_str_unchecked("WD"),
1548                Acronym::from_str_unchecked("AS"),
1549            ]
1550        }
1551        .into_iter()
1552    }
1553    /// The description of [`DaycoreOsu`]
1554    pub const fn description() -> &'static str {
1555        "Whoaaaaa..."
1556    }
1557    /// The [`GameModKind`] of [`DaycoreOsu`]
1558    pub const fn kind() -> GameModKind {
1559        GameModKind::DifficultyReduction
1560    }
1561}
1562impl HardRockOsu {
1563    /// The acronym of [`HardRockOsu`]
1564    pub const fn acronym() -> Acronym {
1565        unsafe { Acronym::from_str_unchecked("HR") }
1566    }
1567    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockOsu`]
1568    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1569        unsafe {
1570            [
1571                Acronym::from_str_unchecked("EZ"),
1572                Acronym::from_str_unchecked("DA"),
1573                Acronym::from_str_unchecked("MR"),
1574            ]
1575        }
1576        .into_iter()
1577    }
1578    /// The description of [`HardRockOsu`]
1579    pub const fn description() -> &'static str {
1580        "Everything just got a bit harder..."
1581    }
1582    /// The [`GameModKind`] of [`HardRockOsu`]
1583    pub const fn kind() -> GameModKind {
1584        GameModKind::DifficultyIncrease
1585    }
1586    /// Bit value of [`HardRockOsu`]
1587    ///
1588    /// See <https://github.com/ppy/osu-api/wiki#mods>
1589    pub const fn bits() -> u32 {
1590        16
1591    }
1592}
1593impl SuddenDeathOsu {
1594    /// The acronym of [`SuddenDeathOsu`]
1595    pub const fn acronym() -> Acronym {
1596        unsafe { Acronym::from_str_unchecked("SD") }
1597    }
1598    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathOsu`]
1599    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1600        unsafe {
1601            [
1602                Acronym::from_str_unchecked("NF"),
1603                Acronym::from_str_unchecked("PF"),
1604                Acronym::from_str_unchecked("TP"),
1605                Acronym::from_str_unchecked("CN"),
1606            ]
1607        }
1608        .into_iter()
1609    }
1610    /// The description of [`SuddenDeathOsu`]
1611    pub const fn description() -> &'static str {
1612        "Miss and fail."
1613    }
1614    /// The [`GameModKind`] of [`SuddenDeathOsu`]
1615    pub const fn kind() -> GameModKind {
1616        GameModKind::DifficultyIncrease
1617    }
1618    /// Bit value of [`SuddenDeathOsu`]
1619    ///
1620    /// See <https://github.com/ppy/osu-api/wiki#mods>
1621    pub const fn bits() -> u32 {
1622        32
1623    }
1624}
1625impl PerfectOsu {
1626    /// The acronym of [`PerfectOsu`]
1627    pub const fn acronym() -> Acronym {
1628        unsafe { Acronym::from_str_unchecked("PF") }
1629    }
1630    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectOsu`]
1631    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1632        unsafe {
1633            [
1634                Acronym::from_str_unchecked("NF"),
1635                Acronym::from_str_unchecked("SD"),
1636                Acronym::from_str_unchecked("AC"),
1637                Acronym::from_str_unchecked("CN"),
1638            ]
1639        }
1640        .into_iter()
1641    }
1642    /// The description of [`PerfectOsu`]
1643    pub const fn description() -> &'static str {
1644        "SS or quit."
1645    }
1646    /// The [`GameModKind`] of [`PerfectOsu`]
1647    pub const fn kind() -> GameModKind {
1648        GameModKind::DifficultyIncrease
1649    }
1650    /// Bit value of [`PerfectOsu`]
1651    ///
1652    /// See <https://github.com/ppy/osu-api/wiki#mods>
1653    pub const fn bits() -> u32 {
1654        16416
1655    }
1656}
1657impl DoubleTimeOsu {
1658    /// The acronym of [`DoubleTimeOsu`]
1659    pub const fn acronym() -> Acronym {
1660        unsafe { Acronym::from_str_unchecked("DT") }
1661    }
1662    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeOsu`]
1663    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1664        unsafe {
1665            [
1666                Acronym::from_str_unchecked("HT"),
1667                Acronym::from_str_unchecked("DC"),
1668                Acronym::from_str_unchecked("NC"),
1669                Acronym::from_str_unchecked("WU"),
1670                Acronym::from_str_unchecked("WD"),
1671                Acronym::from_str_unchecked("AS"),
1672            ]
1673        }
1674        .into_iter()
1675    }
1676    /// The description of [`DoubleTimeOsu`]
1677    pub const fn description() -> &'static str {
1678        "Zoooooooooom..."
1679    }
1680    /// The [`GameModKind`] of [`DoubleTimeOsu`]
1681    pub const fn kind() -> GameModKind {
1682        GameModKind::DifficultyIncrease
1683    }
1684    /// Bit value of [`DoubleTimeOsu`]
1685    ///
1686    /// See <https://github.com/ppy/osu-api/wiki#mods>
1687    pub const fn bits() -> u32 {
1688        64
1689    }
1690}
1691impl NightcoreOsu {
1692    /// The acronym of [`NightcoreOsu`]
1693    pub const fn acronym() -> Acronym {
1694        unsafe { Acronym::from_str_unchecked("NC") }
1695    }
1696    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreOsu`]
1697    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1698        unsafe {
1699            [
1700                Acronym::from_str_unchecked("HT"),
1701                Acronym::from_str_unchecked("DC"),
1702                Acronym::from_str_unchecked("DT"),
1703                Acronym::from_str_unchecked("WU"),
1704                Acronym::from_str_unchecked("WD"),
1705                Acronym::from_str_unchecked("AS"),
1706            ]
1707        }
1708        .into_iter()
1709    }
1710    /// The description of [`NightcoreOsu`]
1711    pub const fn description() -> &'static str {
1712        "Uguuuuuuuu..."
1713    }
1714    /// The [`GameModKind`] of [`NightcoreOsu`]
1715    pub const fn kind() -> GameModKind {
1716        GameModKind::DifficultyIncrease
1717    }
1718    /// Bit value of [`NightcoreOsu`]
1719    ///
1720    /// See <https://github.com/ppy/osu-api/wiki#mods>
1721    pub const fn bits() -> u32 {
1722        576
1723    }
1724}
1725impl HiddenOsu {
1726    /// The acronym of [`HiddenOsu`]
1727    pub const fn acronym() -> Acronym {
1728        unsafe { Acronym::from_str_unchecked("HD") }
1729    }
1730    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenOsu`]
1731    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1732        unsafe {
1733            [
1734                Acronym::from_str_unchecked("TC"),
1735                Acronym::from_str_unchecked("SI"),
1736                Acronym::from_str_unchecked("AD"),
1737                Acronym::from_str_unchecked("FR"),
1738                Acronym::from_str_unchecked("DP"),
1739            ]
1740        }
1741        .into_iter()
1742    }
1743    /// The description of [`HiddenOsu`]
1744    pub const fn description() -> &'static str {
1745        "Play with no approach circles and fading circles/sliders."
1746    }
1747    /// The [`GameModKind`] of [`HiddenOsu`]
1748    pub const fn kind() -> GameModKind {
1749        GameModKind::DifficultyIncrease
1750    }
1751    /// Bit value of [`HiddenOsu`]
1752    ///
1753    /// See <https://github.com/ppy/osu-api/wiki#mods>
1754    pub const fn bits() -> u32 {
1755        8
1756    }
1757}
1758impl TraceableOsu {
1759    /// The acronym of [`TraceableOsu`]
1760    pub const fn acronym() -> Acronym {
1761        unsafe { Acronym::from_str_unchecked("TC") }
1762    }
1763    /// Iterator of [`Acronym`] for mods that are incompatible with [`TraceableOsu`]
1764    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1765        unsafe {
1766            [
1767                Acronym::from_str_unchecked("HD"),
1768                Acronym::from_str_unchecked("TP"),
1769                Acronym::from_str_unchecked("SI"),
1770                Acronym::from_str_unchecked("GR"),
1771                Acronym::from_str_unchecked("DF"),
1772                Acronym::from_str_unchecked("DP"),
1773            ]
1774        }
1775        .into_iter()
1776    }
1777    /// The description of [`TraceableOsu`]
1778    pub const fn description() -> &'static str {
1779        "Put your faith in the approach circles..."
1780    }
1781    /// The [`GameModKind`] of [`TraceableOsu`]
1782    pub const fn kind() -> GameModKind {
1783        GameModKind::DifficultyIncrease
1784    }
1785}
1786impl FlashlightOsu {
1787    /// The acronym of [`FlashlightOsu`]
1788    pub const fn acronym() -> Acronym {
1789        unsafe { Acronym::from_str_unchecked("FL") }
1790    }
1791    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightOsu`]
1792    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1793        unsafe {
1794            [
1795                Acronym::from_str_unchecked("BL"),
1796                Acronym::from_str_unchecked("BM"),
1797            ]
1798        }
1799        .into_iter()
1800    }
1801    /// The description of [`FlashlightOsu`]
1802    pub const fn description() -> &'static str {
1803        "Restricted view area."
1804    }
1805    /// The [`GameModKind`] of [`FlashlightOsu`]
1806    pub const fn kind() -> GameModKind {
1807        GameModKind::DifficultyIncrease
1808    }
1809    /// Bit value of [`FlashlightOsu`]
1810    ///
1811    /// See <https://github.com/ppy/osu-api/wiki#mods>
1812    pub const fn bits() -> u32 {
1813        1024
1814    }
1815}
1816impl BlindsOsu {
1817    /// The acronym of [`BlindsOsu`]
1818    pub const fn acronym() -> Acronym {
1819        unsafe { Acronym::from_str_unchecked("BL") }
1820    }
1821    /// Iterator of [`Acronym`] for mods that are incompatible with [`BlindsOsu`]
1822    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1823        unsafe { [Acronym::from_str_unchecked("FL")] }.into_iter()
1824    }
1825    /// The description of [`BlindsOsu`]
1826    pub const fn description() -> &'static str {
1827        "Play with blinds on your screen."
1828    }
1829    /// The [`GameModKind`] of [`BlindsOsu`]
1830    pub const fn kind() -> GameModKind {
1831        GameModKind::DifficultyIncrease
1832    }
1833}
1834impl StrictTrackingOsu {
1835    /// The acronym of [`StrictTrackingOsu`]
1836    pub const fn acronym() -> Acronym {
1837        unsafe { Acronym::from_str_unchecked("ST") }
1838    }
1839    /// Iterator of [`Acronym`] for mods that are incompatible with [`StrictTrackingOsu`]
1840    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1841        unsafe {
1842            [
1843                Acronym::from_str_unchecked("TP"),
1844                Acronym::from_str_unchecked("CL"),
1845            ]
1846        }
1847        .into_iter()
1848    }
1849    /// The description of [`StrictTrackingOsu`]
1850    pub const fn description() -> &'static str {
1851        "Once you start a slider, follow precisely or get a miss."
1852    }
1853    /// The [`GameModKind`] of [`StrictTrackingOsu`]
1854    pub const fn kind() -> GameModKind {
1855        GameModKind::DifficultyIncrease
1856    }
1857}
1858impl AccuracyChallengeOsu {
1859    /// The acronym of [`AccuracyChallengeOsu`]
1860    pub const fn acronym() -> Acronym {
1861        unsafe { Acronym::from_str_unchecked("AC") }
1862    }
1863    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeOsu`]
1864    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1865        unsafe {
1866            [
1867                Acronym::from_str_unchecked("EZ"),
1868                Acronym::from_str_unchecked("NF"),
1869                Acronym::from_str_unchecked("PF"),
1870                Acronym::from_str_unchecked("CN"),
1871            ]
1872        }
1873        .into_iter()
1874    }
1875    /// The description of [`AccuracyChallengeOsu`]
1876    pub const fn description() -> &'static str {
1877        "Fail if your accuracy drops too low!"
1878    }
1879    /// The [`GameModKind`] of [`AccuracyChallengeOsu`]
1880    pub const fn kind() -> GameModKind {
1881        GameModKind::DifficultyIncrease
1882    }
1883}
1884impl TargetPracticeOsu {
1885    /// The acronym of [`TargetPracticeOsu`]
1886    pub const fn acronym() -> Acronym {
1887        unsafe { Acronym::from_str_unchecked("TP") }
1888    }
1889    /// Iterator of [`Acronym`] for mods that are incompatible with [`TargetPracticeOsu`]
1890    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1891        unsafe {
1892            [
1893                Acronym::from_str_unchecked("SD"),
1894                Acronym::from_str_unchecked("TC"),
1895                Acronym::from_str_unchecked("ST"),
1896                Acronym::from_str_unchecked("DA"),
1897                Acronym::from_str_unchecked("RD"),
1898                Acronym::from_str_unchecked("SO"),
1899                Acronym::from_str_unchecked("AD"),
1900                Acronym::from_str_unchecked("DP"),
1901            ]
1902        }
1903        .into_iter()
1904    }
1905    /// The description of [`TargetPracticeOsu`]
1906    pub const fn description() -> &'static str {
1907        "Practice keeping up with the beat of the song."
1908    }
1909    /// The [`GameModKind`] of [`TargetPracticeOsu`]
1910    pub const fn kind() -> GameModKind {
1911        GameModKind::Conversion
1912    }
1913    /// Bit value of [`TargetPracticeOsu`]
1914    ///
1915    /// See <https://github.com/ppy/osu-api/wiki#mods>
1916    pub const fn bits() -> u32 {
1917        8388608
1918    }
1919}
1920impl DifficultyAdjustOsu {
1921    /// The acronym of [`DifficultyAdjustOsu`]
1922    pub const fn acronym() -> Acronym {
1923        unsafe { Acronym::from_str_unchecked("DA") }
1924    }
1925    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustOsu`]
1926    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1927        unsafe {
1928            [
1929                Acronym::from_str_unchecked("EZ"),
1930                Acronym::from_str_unchecked("HR"),
1931                Acronym::from_str_unchecked("TP"),
1932            ]
1933        }
1934        .into_iter()
1935    }
1936    /// The description of [`DifficultyAdjustOsu`]
1937    pub const fn description() -> &'static str {
1938        "Override a beatmap's difficulty settings."
1939    }
1940    /// The [`GameModKind`] of [`DifficultyAdjustOsu`]
1941    pub const fn kind() -> GameModKind {
1942        GameModKind::Conversion
1943    }
1944}
1945impl ClassicOsu {
1946    /// The acronym of [`ClassicOsu`]
1947    pub const fn acronym() -> Acronym {
1948        unsafe { Acronym::from_str_unchecked("CL") }
1949    }
1950    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicOsu`]
1951    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1952        unsafe { [Acronym::from_str_unchecked("ST")] }.into_iter()
1953    }
1954    /// The description of [`ClassicOsu`]
1955    pub const fn description() -> &'static str {
1956        "Feeling nostalgic?"
1957    }
1958    /// The [`GameModKind`] of [`ClassicOsu`]
1959    pub const fn kind() -> GameModKind {
1960        GameModKind::Conversion
1961    }
1962}
1963impl RandomOsu {
1964    /// The acronym of [`RandomOsu`]
1965    pub const fn acronym() -> Acronym {
1966        unsafe { Acronym::from_str_unchecked("RD") }
1967    }
1968    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomOsu`]
1969    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1970        unsafe { [Acronym::from_str_unchecked("TP")] }.into_iter()
1971    }
1972    /// The description of [`RandomOsu`]
1973    pub const fn description() -> &'static str {
1974        "It never gets boring!"
1975    }
1976    /// The [`GameModKind`] of [`RandomOsu`]
1977    pub const fn kind() -> GameModKind {
1978        GameModKind::Conversion
1979    }
1980    /// Bit value of [`RandomOsu`]
1981    ///
1982    /// See <https://github.com/ppy/osu-api/wiki#mods>
1983    pub const fn bits() -> u32 {
1984        2097152
1985    }
1986}
1987impl MirrorOsu {
1988    /// The acronym of [`MirrorOsu`]
1989    pub const fn acronym() -> Acronym {
1990        unsafe { Acronym::from_str_unchecked("MR") }
1991    }
1992    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorOsu`]
1993    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1994        unsafe { [Acronym::from_str_unchecked("HR")] }.into_iter()
1995    }
1996    /// The description of [`MirrorOsu`]
1997    pub const fn description() -> &'static str {
1998        "Flip objects on the chosen axes."
1999    }
2000    /// The [`GameModKind`] of [`MirrorOsu`]
2001    pub const fn kind() -> GameModKind {
2002        GameModKind::Conversion
2003    }
2004    /// Bit value of [`MirrorOsu`]
2005    ///
2006    /// See <https://github.com/ppy/osu-api/wiki#mods>
2007    pub const fn bits() -> u32 {
2008        1073741824
2009    }
2010}
2011impl AlternateOsu {
2012    /// The acronym of [`AlternateOsu`]
2013    pub const fn acronym() -> Acronym {
2014        unsafe { Acronym::from_str_unchecked("AL") }
2015    }
2016    /// Iterator of [`Acronym`] for mods that are incompatible with [`AlternateOsu`]
2017    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2018        unsafe {
2019            [
2020                Acronym::from_str_unchecked("SG"),
2021                Acronym::from_str_unchecked("AT"),
2022                Acronym::from_str_unchecked("CN"),
2023                Acronym::from_str_unchecked("RX"),
2024            ]
2025        }
2026        .into_iter()
2027    }
2028    /// The description of [`AlternateOsu`]
2029    pub const fn description() -> &'static str {
2030        "Don't use the same key twice in a row!"
2031    }
2032    /// The [`GameModKind`] of [`AlternateOsu`]
2033    pub const fn kind() -> GameModKind {
2034        GameModKind::Conversion
2035    }
2036}
2037impl SingleTapOsu {
2038    /// The acronym of [`SingleTapOsu`]
2039    pub const fn acronym() -> Acronym {
2040        unsafe { Acronym::from_str_unchecked("SG") }
2041    }
2042    /// Iterator of [`Acronym`] for mods that are incompatible with [`SingleTapOsu`]
2043    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2044        unsafe {
2045            [
2046                Acronym::from_str_unchecked("AL"),
2047                Acronym::from_str_unchecked("AT"),
2048                Acronym::from_str_unchecked("CN"),
2049                Acronym::from_str_unchecked("RX"),
2050            ]
2051        }
2052        .into_iter()
2053    }
2054    /// The description of [`SingleTapOsu`]
2055    pub const fn description() -> &'static str {
2056        "You must only use one key!"
2057    }
2058    /// The [`GameModKind`] of [`SingleTapOsu`]
2059    pub const fn kind() -> GameModKind {
2060        GameModKind::Conversion
2061    }
2062}
2063impl AutoplayOsu {
2064    /// The acronym of [`AutoplayOsu`]
2065    pub const fn acronym() -> Acronym {
2066        unsafe { Acronym::from_str_unchecked("AT") }
2067    }
2068    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayOsu`]
2069    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2070        unsafe {
2071            [
2072                Acronym::from_str_unchecked("AL"),
2073                Acronym::from_str_unchecked("SG"),
2074                Acronym::from_str_unchecked("CN"),
2075                Acronym::from_str_unchecked("RX"),
2076                Acronym::from_str_unchecked("AP"),
2077                Acronym::from_str_unchecked("SO"),
2078                Acronym::from_str_unchecked("MG"),
2079                Acronym::from_str_unchecked("RP"),
2080                Acronym::from_str_unchecked("AS"),
2081                Acronym::from_str_unchecked("TD"),
2082            ]
2083        }
2084        .into_iter()
2085    }
2086    /// The description of [`AutoplayOsu`]
2087    pub const fn description() -> &'static str {
2088        "Watch a perfect automated play through the song."
2089    }
2090    /// The [`GameModKind`] of [`AutoplayOsu`]
2091    pub const fn kind() -> GameModKind {
2092        GameModKind::Automation
2093    }
2094    /// Bit value of [`AutoplayOsu`]
2095    ///
2096    /// See <https://github.com/ppy/osu-api/wiki#mods>
2097    pub const fn bits() -> u32 {
2098        2048
2099    }
2100}
2101impl CinemaOsu {
2102    /// The acronym of [`CinemaOsu`]
2103    pub const fn acronym() -> Acronym {
2104        unsafe { Acronym::from_str_unchecked("CN") }
2105    }
2106    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaOsu`]
2107    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2108        unsafe {
2109            [
2110                Acronym::from_str_unchecked("NF"),
2111                Acronym::from_str_unchecked("SD"),
2112                Acronym::from_str_unchecked("PF"),
2113                Acronym::from_str_unchecked("AC"),
2114                Acronym::from_str_unchecked("AL"),
2115                Acronym::from_str_unchecked("SG"),
2116                Acronym::from_str_unchecked("AT"),
2117                Acronym::from_str_unchecked("RX"),
2118                Acronym::from_str_unchecked("AP"),
2119                Acronym::from_str_unchecked("SO"),
2120                Acronym::from_str_unchecked("MG"),
2121                Acronym::from_str_unchecked("RP"),
2122                Acronym::from_str_unchecked("AS"),
2123                Acronym::from_str_unchecked("TD"),
2124            ]
2125        }
2126        .into_iter()
2127    }
2128    /// The description of [`CinemaOsu`]
2129    pub const fn description() -> &'static str {
2130        "Watch the video without visual distractions."
2131    }
2132    /// The [`GameModKind`] of [`CinemaOsu`]
2133    pub const fn kind() -> GameModKind {
2134        GameModKind::Automation
2135    }
2136    /// Bit value of [`CinemaOsu`]
2137    ///
2138    /// See <https://github.com/ppy/osu-api/wiki#mods>
2139    pub const fn bits() -> u32 {
2140        4194304
2141    }
2142}
2143impl RelaxOsu {
2144    /// The acronym of [`RelaxOsu`]
2145    pub const fn acronym() -> Acronym {
2146        unsafe { Acronym::from_str_unchecked("RX") }
2147    }
2148    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxOsu`]
2149    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2150        unsafe {
2151            [
2152                Acronym::from_str_unchecked("AL"),
2153                Acronym::from_str_unchecked("SG"),
2154                Acronym::from_str_unchecked("AT"),
2155                Acronym::from_str_unchecked("CN"),
2156                Acronym::from_str_unchecked("AP"),
2157                Acronym::from_str_unchecked("MG"),
2158            ]
2159        }
2160        .into_iter()
2161    }
2162    /// The description of [`RelaxOsu`]
2163    pub const fn description() -> &'static str {
2164        "You don't need to click. Give your clicking/tapping fingers a break from the heat of things."
2165    }
2166    /// The [`GameModKind`] of [`RelaxOsu`]
2167    pub const fn kind() -> GameModKind {
2168        GameModKind::Automation
2169    }
2170    /// Bit value of [`RelaxOsu`]
2171    ///
2172    /// See <https://github.com/ppy/osu-api/wiki#mods>
2173    pub const fn bits() -> u32 {
2174        128
2175    }
2176}
2177impl AutopilotOsu {
2178    /// The acronym of [`AutopilotOsu`]
2179    pub const fn acronym() -> Acronym {
2180        unsafe { Acronym::from_str_unchecked("AP") }
2181    }
2182    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutopilotOsu`]
2183    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2184        unsafe {
2185            [
2186                Acronym::from_str_unchecked("AT"),
2187                Acronym::from_str_unchecked("CN"),
2188                Acronym::from_str_unchecked("RX"),
2189                Acronym::from_str_unchecked("SO"),
2190                Acronym::from_str_unchecked("MG"),
2191                Acronym::from_str_unchecked("RP"),
2192                Acronym::from_str_unchecked("TD"),
2193            ]
2194        }
2195        .into_iter()
2196    }
2197    /// The description of [`AutopilotOsu`]
2198    pub const fn description() -> &'static str {
2199        "Automatic cursor movement - just follow the rhythm."
2200    }
2201    /// The [`GameModKind`] of [`AutopilotOsu`]
2202    pub const fn kind() -> GameModKind {
2203        GameModKind::Automation
2204    }
2205    /// Bit value of [`AutopilotOsu`]
2206    ///
2207    /// See <https://github.com/ppy/osu-api/wiki#mods>
2208    pub const fn bits() -> u32 {
2209        8192
2210    }
2211}
2212impl SpunOutOsu {
2213    /// The acronym of [`SpunOutOsu`]
2214    pub const fn acronym() -> Acronym {
2215        unsafe { Acronym::from_str_unchecked("SO") }
2216    }
2217    /// Iterator of [`Acronym`] for mods that are incompatible with [`SpunOutOsu`]
2218    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2219        unsafe {
2220            [
2221                Acronym::from_str_unchecked("TP"),
2222                Acronym::from_str_unchecked("AT"),
2223                Acronym::from_str_unchecked("CN"),
2224                Acronym::from_str_unchecked("AP"),
2225            ]
2226        }
2227        .into_iter()
2228    }
2229    /// The description of [`SpunOutOsu`]
2230    pub const fn description() -> &'static str {
2231        "Spinners will be automatically completed."
2232    }
2233    /// The [`GameModKind`] of [`SpunOutOsu`]
2234    pub const fn kind() -> GameModKind {
2235        GameModKind::Automation
2236    }
2237    /// Bit value of [`SpunOutOsu`]
2238    ///
2239    /// See <https://github.com/ppy/osu-api/wiki#mods>
2240    pub const fn bits() -> u32 {
2241        4096
2242    }
2243}
2244impl TransformOsu {
2245    /// The acronym of [`TransformOsu`]
2246    pub const fn acronym() -> Acronym {
2247        unsafe { Acronym::from_str_unchecked("TR") }
2248    }
2249    /// Iterator of [`Acronym`] for mods that are incompatible with [`TransformOsu`]
2250    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2251        unsafe {
2252            [
2253                Acronym::from_str_unchecked("WG"),
2254                Acronym::from_str_unchecked("MG"),
2255                Acronym::from_str_unchecked("RP"),
2256                Acronym::from_str_unchecked("FR"),
2257                Acronym::from_str_unchecked("DP"),
2258            ]
2259        }
2260        .into_iter()
2261    }
2262    /// The description of [`TransformOsu`]
2263    pub const fn description() -> &'static str {
2264        "Everything rotates. EVERYTHING."
2265    }
2266    /// The [`GameModKind`] of [`TransformOsu`]
2267    pub const fn kind() -> GameModKind {
2268        GameModKind::Fun
2269    }
2270}
2271impl WiggleOsu {
2272    /// The acronym of [`WiggleOsu`]
2273    pub const fn acronym() -> Acronym {
2274        unsafe { Acronym::from_str_unchecked("WG") }
2275    }
2276    /// Iterator of [`Acronym`] for mods that are incompatible with [`WiggleOsu`]
2277    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2278        unsafe {
2279            [
2280                Acronym::from_str_unchecked("TR"),
2281                Acronym::from_str_unchecked("MG"),
2282                Acronym::from_str_unchecked("RP"),
2283                Acronym::from_str_unchecked("DP"),
2284            ]
2285        }
2286        .into_iter()
2287    }
2288    /// The description of [`WiggleOsu`]
2289    pub const fn description() -> &'static str {
2290        "They just won't stay still..."
2291    }
2292    /// The [`GameModKind`] of [`WiggleOsu`]
2293    pub const fn kind() -> GameModKind {
2294        GameModKind::Fun
2295    }
2296}
2297impl SpinInOsu {
2298    /// The acronym of [`SpinInOsu`]
2299    pub const fn acronym() -> Acronym {
2300        unsafe { Acronym::from_str_unchecked("SI") }
2301    }
2302    /// Iterator of [`Acronym`] for mods that are incompatible with [`SpinInOsu`]
2303    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2304        unsafe {
2305            [
2306                Acronym::from_str_unchecked("HD"),
2307                Acronym::from_str_unchecked("TC"),
2308                Acronym::from_str_unchecked("GR"),
2309                Acronym::from_str_unchecked("DF"),
2310                Acronym::from_str_unchecked("AD"),
2311                Acronym::from_str_unchecked("DP"),
2312            ]
2313        }
2314        .into_iter()
2315    }
2316    /// The description of [`SpinInOsu`]
2317    pub const fn description() -> &'static str {
2318        "Circles spin in. No approach circles."
2319    }
2320    /// The [`GameModKind`] of [`SpinInOsu`]
2321    pub const fn kind() -> GameModKind {
2322        GameModKind::Fun
2323    }
2324}
2325impl GrowOsu {
2326    /// The acronym of [`GrowOsu`]
2327    pub const fn acronym() -> Acronym {
2328        unsafe { Acronym::from_str_unchecked("GR") }
2329    }
2330    /// Iterator of [`Acronym`] for mods that are incompatible with [`GrowOsu`]
2331    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2332        unsafe {
2333            [
2334                Acronym::from_str_unchecked("TC"),
2335                Acronym::from_str_unchecked("SI"),
2336                Acronym::from_str_unchecked("DF"),
2337                Acronym::from_str_unchecked("AD"),
2338                Acronym::from_str_unchecked("DP"),
2339            ]
2340        }
2341        .into_iter()
2342    }
2343    /// The description of [`GrowOsu`]
2344    pub const fn description() -> &'static str {
2345        "Hit them at the right size!"
2346    }
2347    /// The [`GameModKind`] of [`GrowOsu`]
2348    pub const fn kind() -> GameModKind {
2349        GameModKind::Fun
2350    }
2351}
2352impl DeflateOsu {
2353    /// The acronym of [`DeflateOsu`]
2354    pub const fn acronym() -> Acronym {
2355        unsafe { Acronym::from_str_unchecked("DF") }
2356    }
2357    /// Iterator of [`Acronym`] for mods that are incompatible with [`DeflateOsu`]
2358    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2359        unsafe {
2360            [
2361                Acronym::from_str_unchecked("TC"),
2362                Acronym::from_str_unchecked("SI"),
2363                Acronym::from_str_unchecked("GR"),
2364                Acronym::from_str_unchecked("AD"),
2365                Acronym::from_str_unchecked("DP"),
2366            ]
2367        }
2368        .into_iter()
2369    }
2370    /// The description of [`DeflateOsu`]
2371    pub const fn description() -> &'static str {
2372        "Hit them at the right size!"
2373    }
2374    /// The [`GameModKind`] of [`DeflateOsu`]
2375    pub const fn kind() -> GameModKind {
2376        GameModKind::Fun
2377    }
2378}
2379impl WindUpOsu {
2380    /// The acronym of [`WindUpOsu`]
2381    pub const fn acronym() -> Acronym {
2382        unsafe { Acronym::from_str_unchecked("WU") }
2383    }
2384    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpOsu`]
2385    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2386        unsafe {
2387            [
2388                Acronym::from_str_unchecked("HT"),
2389                Acronym::from_str_unchecked("DC"),
2390                Acronym::from_str_unchecked("DT"),
2391                Acronym::from_str_unchecked("NC"),
2392                Acronym::from_str_unchecked("WD"),
2393                Acronym::from_str_unchecked("AS"),
2394            ]
2395        }
2396        .into_iter()
2397    }
2398    /// The description of [`WindUpOsu`]
2399    pub const fn description() -> &'static str {
2400        "Can you keep up?"
2401    }
2402    /// The [`GameModKind`] of [`WindUpOsu`]
2403    pub const fn kind() -> GameModKind {
2404        GameModKind::Fun
2405    }
2406}
2407impl WindDownOsu {
2408    /// The acronym of [`WindDownOsu`]
2409    pub const fn acronym() -> Acronym {
2410        unsafe { Acronym::from_str_unchecked("WD") }
2411    }
2412    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownOsu`]
2413    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2414        unsafe {
2415            [
2416                Acronym::from_str_unchecked("HT"),
2417                Acronym::from_str_unchecked("DC"),
2418                Acronym::from_str_unchecked("DT"),
2419                Acronym::from_str_unchecked("NC"),
2420                Acronym::from_str_unchecked("WU"),
2421                Acronym::from_str_unchecked("AS"),
2422            ]
2423        }
2424        .into_iter()
2425    }
2426    /// The description of [`WindDownOsu`]
2427    pub const fn description() -> &'static str {
2428        "Sloooow doooown..."
2429    }
2430    /// The [`GameModKind`] of [`WindDownOsu`]
2431    pub const fn kind() -> GameModKind {
2432        GameModKind::Fun
2433    }
2434}
2435impl BarrelRollOsu {
2436    /// The acronym of [`BarrelRollOsu`]
2437    pub const fn acronym() -> Acronym {
2438        unsafe { Acronym::from_str_unchecked("BR") }
2439    }
2440    /// Iterator of [`Acronym`] for mods that are incompatible with [`BarrelRollOsu`]
2441    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2442        unsafe { [Acronym::from_str_unchecked("BU")] }.into_iter()
2443    }
2444    /// The description of [`BarrelRollOsu`]
2445    pub const fn description() -> &'static str {
2446        "The whole playfield is on a wheel!"
2447    }
2448    /// The [`GameModKind`] of [`BarrelRollOsu`]
2449    pub const fn kind() -> GameModKind {
2450        GameModKind::Fun
2451    }
2452}
2453impl ApproachDifferentOsu {
2454    /// The acronym of [`ApproachDifferentOsu`]
2455    pub const fn acronym() -> Acronym {
2456        unsafe { Acronym::from_str_unchecked("AD") }
2457    }
2458    /// Iterator of [`Acronym`] for mods that are incompatible with [`ApproachDifferentOsu`]
2459    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2460        unsafe {
2461            [
2462                Acronym::from_str_unchecked("HD"),
2463                Acronym::from_str_unchecked("TP"),
2464                Acronym::from_str_unchecked("SI"),
2465                Acronym::from_str_unchecked("GR"),
2466                Acronym::from_str_unchecked("DF"),
2467                Acronym::from_str_unchecked("FR"),
2468            ]
2469        }
2470        .into_iter()
2471    }
2472    /// The description of [`ApproachDifferentOsu`]
2473    pub const fn description() -> &'static str {
2474        "Never trust the approach circles..."
2475    }
2476    /// The [`GameModKind`] of [`ApproachDifferentOsu`]
2477    pub const fn kind() -> GameModKind {
2478        GameModKind::Fun
2479    }
2480}
2481impl MutedOsu {
2482    /// The acronym of [`MutedOsu`]
2483    pub const fn acronym() -> Acronym {
2484        unsafe { Acronym::from_str_unchecked("MU") }
2485    }
2486    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedOsu`]
2487    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2488        [].into_iter()
2489    }
2490    /// The description of [`MutedOsu`]
2491    pub const fn description() -> &'static str {
2492        "Can you still feel the rhythm without music?"
2493    }
2494    /// The [`GameModKind`] of [`MutedOsu`]
2495    pub const fn kind() -> GameModKind {
2496        GameModKind::Fun
2497    }
2498}
2499impl NoScopeOsu {
2500    /// The acronym of [`NoScopeOsu`]
2501    pub const fn acronym() -> Acronym {
2502        unsafe { Acronym::from_str_unchecked("NS") }
2503    }
2504    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoScopeOsu`]
2505    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2506        unsafe { [Acronym::from_str_unchecked("BM")] }.into_iter()
2507    }
2508    /// The description of [`NoScopeOsu`]
2509    pub const fn description() -> &'static str {
2510        "Where's the cursor?"
2511    }
2512    /// The [`GameModKind`] of [`NoScopeOsu`]
2513    pub const fn kind() -> GameModKind {
2514        GameModKind::Fun
2515    }
2516}
2517impl MagnetisedOsu {
2518    /// The acronym of [`MagnetisedOsu`]
2519    pub const fn acronym() -> Acronym {
2520        unsafe { Acronym::from_str_unchecked("MG") }
2521    }
2522    /// Iterator of [`Acronym`] for mods that are incompatible with [`MagnetisedOsu`]
2523    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2524        unsafe {
2525            [
2526                Acronym::from_str_unchecked("AT"),
2527                Acronym::from_str_unchecked("CN"),
2528                Acronym::from_str_unchecked("RX"),
2529                Acronym::from_str_unchecked("AP"),
2530                Acronym::from_str_unchecked("TR"),
2531                Acronym::from_str_unchecked("WG"),
2532                Acronym::from_str_unchecked("RP"),
2533                Acronym::from_str_unchecked("BU"),
2534                Acronym::from_str_unchecked("DP"),
2535            ]
2536        }
2537        .into_iter()
2538    }
2539    /// The description of [`MagnetisedOsu`]
2540    pub const fn description() -> &'static str {
2541        "No need to chase the circles – your cursor is a magnet!"
2542    }
2543    /// The [`GameModKind`] of [`MagnetisedOsu`]
2544    pub const fn kind() -> GameModKind {
2545        GameModKind::Fun
2546    }
2547}
2548impl RepelOsu {
2549    /// The acronym of [`RepelOsu`]
2550    pub const fn acronym() -> Acronym {
2551        unsafe { Acronym::from_str_unchecked("RP") }
2552    }
2553    /// Iterator of [`Acronym`] for mods that are incompatible with [`RepelOsu`]
2554    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2555        unsafe {
2556            [
2557                Acronym::from_str_unchecked("AT"),
2558                Acronym::from_str_unchecked("CN"),
2559                Acronym::from_str_unchecked("AP"),
2560                Acronym::from_str_unchecked("TR"),
2561                Acronym::from_str_unchecked("WG"),
2562                Acronym::from_str_unchecked("MG"),
2563                Acronym::from_str_unchecked("BU"),
2564                Acronym::from_str_unchecked("DP"),
2565            ]
2566        }
2567        .into_iter()
2568    }
2569    /// The description of [`RepelOsu`]
2570    pub const fn description() -> &'static str {
2571        "Hit objects run away!"
2572    }
2573    /// The [`GameModKind`] of [`RepelOsu`]
2574    pub const fn kind() -> GameModKind {
2575        GameModKind::Fun
2576    }
2577}
2578impl AdaptiveSpeedOsu {
2579    /// The acronym of [`AdaptiveSpeedOsu`]
2580    pub const fn acronym() -> Acronym {
2581        unsafe { Acronym::from_str_unchecked("AS") }
2582    }
2583    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedOsu`]
2584    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2585        unsafe {
2586            [
2587                Acronym::from_str_unchecked("HT"),
2588                Acronym::from_str_unchecked("DC"),
2589                Acronym::from_str_unchecked("DT"),
2590                Acronym::from_str_unchecked("NC"),
2591                Acronym::from_str_unchecked("AT"),
2592                Acronym::from_str_unchecked("CN"),
2593                Acronym::from_str_unchecked("WU"),
2594                Acronym::from_str_unchecked("WD"),
2595            ]
2596        }
2597        .into_iter()
2598    }
2599    /// The description of [`AdaptiveSpeedOsu`]
2600    pub const fn description() -> &'static str {
2601        "Let track speed adapt to you."
2602    }
2603    /// The [`GameModKind`] of [`AdaptiveSpeedOsu`]
2604    pub const fn kind() -> GameModKind {
2605        GameModKind::Fun
2606    }
2607}
2608impl FreezeFrameOsu {
2609    /// The acronym of [`FreezeFrameOsu`]
2610    pub const fn acronym() -> Acronym {
2611        unsafe { Acronym::from_str_unchecked("FR") }
2612    }
2613    /// Iterator of [`Acronym`] for mods that are incompatible with [`FreezeFrameOsu`]
2614    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2615        unsafe {
2616            [
2617                Acronym::from_str_unchecked("HD"),
2618                Acronym::from_str_unchecked("TR"),
2619                Acronym::from_str_unchecked("AD"),
2620                Acronym::from_str_unchecked("DP"),
2621            ]
2622        }
2623        .into_iter()
2624    }
2625    /// The description of [`FreezeFrameOsu`]
2626    pub const fn description() -> &'static str {
2627        "Burn the notes into your memory."
2628    }
2629    /// The [`GameModKind`] of [`FreezeFrameOsu`]
2630    pub const fn kind() -> GameModKind {
2631        GameModKind::Fun
2632    }
2633}
2634impl BubblesOsu {
2635    /// The acronym of [`BubblesOsu`]
2636    pub const fn acronym() -> Acronym {
2637        unsafe { Acronym::from_str_unchecked("BU") }
2638    }
2639    /// Iterator of [`Acronym`] for mods that are incompatible with [`BubblesOsu`]
2640    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2641        unsafe {
2642            [
2643                Acronym::from_str_unchecked("BR"),
2644                Acronym::from_str_unchecked("MG"),
2645                Acronym::from_str_unchecked("RP"),
2646            ]
2647        }
2648        .into_iter()
2649    }
2650    /// The description of [`BubblesOsu`]
2651    pub const fn description() -> &'static str {
2652        "Don't let their popping distract you!"
2653    }
2654    /// The [`GameModKind`] of [`BubblesOsu`]
2655    pub const fn kind() -> GameModKind {
2656        GameModKind::Fun
2657    }
2658}
2659impl SynesthesiaOsu {
2660    /// The acronym of [`SynesthesiaOsu`]
2661    pub const fn acronym() -> Acronym {
2662        unsafe { Acronym::from_str_unchecked("SY") }
2663    }
2664    /// Iterator of [`Acronym`] for mods that are incompatible with [`SynesthesiaOsu`]
2665    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2666        [].into_iter()
2667    }
2668    /// The description of [`SynesthesiaOsu`]
2669    pub const fn description() -> &'static str {
2670        "Colours hit objects based on the rhythm."
2671    }
2672    /// The [`GameModKind`] of [`SynesthesiaOsu`]
2673    pub const fn kind() -> GameModKind {
2674        GameModKind::Fun
2675    }
2676}
2677impl DepthOsu {
2678    /// The acronym of [`DepthOsu`]
2679    pub const fn acronym() -> Acronym {
2680        unsafe { Acronym::from_str_unchecked("DP") }
2681    }
2682    /// Iterator of [`Acronym`] for mods that are incompatible with [`DepthOsu`]
2683    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2684        unsafe {
2685            [
2686                Acronym::from_str_unchecked("HD"),
2687                Acronym::from_str_unchecked("TC"),
2688                Acronym::from_str_unchecked("TP"),
2689                Acronym::from_str_unchecked("TR"),
2690                Acronym::from_str_unchecked("WG"),
2691                Acronym::from_str_unchecked("SI"),
2692                Acronym::from_str_unchecked("GR"),
2693                Acronym::from_str_unchecked("DF"),
2694                Acronym::from_str_unchecked("MG"),
2695                Acronym::from_str_unchecked("RP"),
2696                Acronym::from_str_unchecked("FR"),
2697            ]
2698        }
2699        .into_iter()
2700    }
2701    /// The description of [`DepthOsu`]
2702    pub const fn description() -> &'static str {
2703        "3D. Almost."
2704    }
2705    /// The [`GameModKind`] of [`DepthOsu`]
2706    pub const fn kind() -> GameModKind {
2707        GameModKind::Fun
2708    }
2709}
2710impl BloomOsu {
2711    /// The acronym of [`BloomOsu`]
2712    pub const fn acronym() -> Acronym {
2713        unsafe { Acronym::from_str_unchecked("BM") }
2714    }
2715    /// Iterator of [`Acronym`] for mods that are incompatible with [`BloomOsu`]
2716    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2717        unsafe {
2718            [
2719                Acronym::from_str_unchecked("FL"),
2720                Acronym::from_str_unchecked("NS"),
2721                Acronym::from_str_unchecked("TD"),
2722            ]
2723        }
2724        .into_iter()
2725    }
2726    /// The description of [`BloomOsu`]
2727    pub const fn description() -> &'static str {
2728        "The cursor blooms into.. a larger cursor!"
2729    }
2730    /// The [`GameModKind`] of [`BloomOsu`]
2731    pub const fn kind() -> GameModKind {
2732        GameModKind::Fun
2733    }
2734}
2735impl TouchDeviceOsu {
2736    /// The acronym of [`TouchDeviceOsu`]
2737    pub const fn acronym() -> Acronym {
2738        unsafe { Acronym::from_str_unchecked("TD") }
2739    }
2740    /// Iterator of [`Acronym`] for mods that are incompatible with [`TouchDeviceOsu`]
2741    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2742        unsafe {
2743            [
2744                Acronym::from_str_unchecked("AT"),
2745                Acronym::from_str_unchecked("CN"),
2746                Acronym::from_str_unchecked("AP"),
2747                Acronym::from_str_unchecked("BM"),
2748            ]
2749        }
2750        .into_iter()
2751    }
2752    /// The description of [`TouchDeviceOsu`]
2753    pub const fn description() -> &'static str {
2754        "Automatically applied to plays on devices with a touchscreen."
2755    }
2756    /// The [`GameModKind`] of [`TouchDeviceOsu`]
2757    pub const fn kind() -> GameModKind {
2758        GameModKind::System
2759    }
2760    /// Bit value of [`TouchDeviceOsu`]
2761    ///
2762    /// See <https://github.com/ppy/osu-api/wiki#mods>
2763    pub const fn bits() -> u32 {
2764        4
2765    }
2766}
2767impl ScoreV2Osu {
2768    /// The acronym of [`ScoreV2Osu`]
2769    pub const fn acronym() -> Acronym {
2770        unsafe { Acronym::from_str_unchecked("SV2") }
2771    }
2772    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Osu`]
2773    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2774        [].into_iter()
2775    }
2776    /// The description of [`ScoreV2Osu`]
2777    pub const fn description() -> &'static str {
2778        "Score set on earlier osu! versions with the V2 scoring algorithm active."
2779    }
2780    /// The [`GameModKind`] of [`ScoreV2Osu`]
2781    pub const fn kind() -> GameModKind {
2782        GameModKind::System
2783    }
2784    /// Bit value of [`ScoreV2Osu`]
2785    ///
2786    /// See <https://github.com/ppy/osu-api/wiki#mods>
2787    pub const fn bits() -> u32 {
2788        536870912
2789    }
2790}
2791impl EasyTaiko {
2792    /// The acronym of [`EasyTaiko`]
2793    pub const fn acronym() -> Acronym {
2794        unsafe { Acronym::from_str_unchecked("EZ") }
2795    }
2796    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyTaiko`]
2797    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2798        unsafe {
2799            [
2800                Acronym::from_str_unchecked("HR"),
2801                Acronym::from_str_unchecked("DA"),
2802            ]
2803        }
2804        .into_iter()
2805    }
2806    /// The description of [`EasyTaiko`]
2807    pub const fn description() -> &'static str {
2808        "Beats move slower, and less accuracy required!"
2809    }
2810    /// The [`GameModKind`] of [`EasyTaiko`]
2811    pub const fn kind() -> GameModKind {
2812        GameModKind::DifficultyReduction
2813    }
2814    /// Bit value of [`EasyTaiko`]
2815    ///
2816    /// See <https://github.com/ppy/osu-api/wiki#mods>
2817    pub const fn bits() -> u32 {
2818        2
2819    }
2820}
2821impl NoFailTaiko {
2822    /// The acronym of [`NoFailTaiko`]
2823    pub const fn acronym() -> Acronym {
2824        unsafe { Acronym::from_str_unchecked("NF") }
2825    }
2826    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailTaiko`]
2827    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2828        unsafe {
2829            [
2830                Acronym::from_str_unchecked("SD"),
2831                Acronym::from_str_unchecked("PF"),
2832                Acronym::from_str_unchecked("AC"),
2833                Acronym::from_str_unchecked("CN"),
2834            ]
2835        }
2836        .into_iter()
2837    }
2838    /// The description of [`NoFailTaiko`]
2839    pub const fn description() -> &'static str {
2840        "You can't fail, no matter what."
2841    }
2842    /// The [`GameModKind`] of [`NoFailTaiko`]
2843    pub const fn kind() -> GameModKind {
2844        GameModKind::DifficultyReduction
2845    }
2846    /// Bit value of [`NoFailTaiko`]
2847    ///
2848    /// See <https://github.com/ppy/osu-api/wiki#mods>
2849    pub const fn bits() -> u32 {
2850        1
2851    }
2852}
2853impl HalfTimeTaiko {
2854    /// The acronym of [`HalfTimeTaiko`]
2855    pub const fn acronym() -> Acronym {
2856        unsafe { Acronym::from_str_unchecked("HT") }
2857    }
2858    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeTaiko`]
2859    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2860        unsafe {
2861            [
2862                Acronym::from_str_unchecked("DC"),
2863                Acronym::from_str_unchecked("DT"),
2864                Acronym::from_str_unchecked("NC"),
2865                Acronym::from_str_unchecked("WU"),
2866                Acronym::from_str_unchecked("WD"),
2867                Acronym::from_str_unchecked("AS"),
2868            ]
2869        }
2870        .into_iter()
2871    }
2872    /// The description of [`HalfTimeTaiko`]
2873    pub const fn description() -> &'static str {
2874        "Less zoom..."
2875    }
2876    /// The [`GameModKind`] of [`HalfTimeTaiko`]
2877    pub const fn kind() -> GameModKind {
2878        GameModKind::DifficultyReduction
2879    }
2880    /// Bit value of [`HalfTimeTaiko`]
2881    ///
2882    /// See <https://github.com/ppy/osu-api/wiki#mods>
2883    pub const fn bits() -> u32 {
2884        256
2885    }
2886}
2887impl DaycoreTaiko {
2888    /// The acronym of [`DaycoreTaiko`]
2889    pub const fn acronym() -> Acronym {
2890        unsafe { Acronym::from_str_unchecked("DC") }
2891    }
2892    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreTaiko`]
2893    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2894        unsafe {
2895            [
2896                Acronym::from_str_unchecked("HT"),
2897                Acronym::from_str_unchecked("DT"),
2898                Acronym::from_str_unchecked("NC"),
2899                Acronym::from_str_unchecked("WU"),
2900                Acronym::from_str_unchecked("WD"),
2901                Acronym::from_str_unchecked("AS"),
2902            ]
2903        }
2904        .into_iter()
2905    }
2906    /// The description of [`DaycoreTaiko`]
2907    pub const fn description() -> &'static str {
2908        "Whoaaaaa..."
2909    }
2910    /// The [`GameModKind`] of [`DaycoreTaiko`]
2911    pub const fn kind() -> GameModKind {
2912        GameModKind::DifficultyReduction
2913    }
2914}
2915impl SimplifiedRhythmTaiko {
2916    /// The acronym of [`SimplifiedRhythmTaiko`]
2917    pub const fn acronym() -> Acronym {
2918        unsafe { Acronym::from_str_unchecked("SR") }
2919    }
2920    /// Iterator of [`Acronym`] for mods that are incompatible with [`SimplifiedRhythmTaiko`]
2921    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2922        [].into_iter()
2923    }
2924    /// The description of [`SimplifiedRhythmTaiko`]
2925    pub const fn description() -> &'static str {
2926        "Simplify tricky rhythms!"
2927    }
2928    /// The [`GameModKind`] of [`SimplifiedRhythmTaiko`]
2929    pub const fn kind() -> GameModKind {
2930        GameModKind::DifficultyReduction
2931    }
2932}
2933impl HardRockTaiko {
2934    /// The acronym of [`HardRockTaiko`]
2935    pub const fn acronym() -> Acronym {
2936        unsafe { Acronym::from_str_unchecked("HR") }
2937    }
2938    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockTaiko`]
2939    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2940        unsafe {
2941            [
2942                Acronym::from_str_unchecked("EZ"),
2943                Acronym::from_str_unchecked("DA"),
2944            ]
2945        }
2946        .into_iter()
2947    }
2948    /// The description of [`HardRockTaiko`]
2949    pub const fn description() -> &'static str {
2950        "Everything just got a bit harder..."
2951    }
2952    /// The [`GameModKind`] of [`HardRockTaiko`]
2953    pub const fn kind() -> GameModKind {
2954        GameModKind::DifficultyIncrease
2955    }
2956    /// Bit value of [`HardRockTaiko`]
2957    ///
2958    /// See <https://github.com/ppy/osu-api/wiki#mods>
2959    pub const fn bits() -> u32 {
2960        16
2961    }
2962}
2963impl SuddenDeathTaiko {
2964    /// The acronym of [`SuddenDeathTaiko`]
2965    pub const fn acronym() -> Acronym {
2966        unsafe { Acronym::from_str_unchecked("SD") }
2967    }
2968    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathTaiko`]
2969    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2970        unsafe {
2971            [
2972                Acronym::from_str_unchecked("NF"),
2973                Acronym::from_str_unchecked("PF"),
2974                Acronym::from_str_unchecked("CN"),
2975            ]
2976        }
2977        .into_iter()
2978    }
2979    /// The description of [`SuddenDeathTaiko`]
2980    pub const fn description() -> &'static str {
2981        "Miss and fail."
2982    }
2983    /// The [`GameModKind`] of [`SuddenDeathTaiko`]
2984    pub const fn kind() -> GameModKind {
2985        GameModKind::DifficultyIncrease
2986    }
2987    /// Bit value of [`SuddenDeathTaiko`]
2988    ///
2989    /// See <https://github.com/ppy/osu-api/wiki#mods>
2990    pub const fn bits() -> u32 {
2991        32
2992    }
2993}
2994impl PerfectTaiko {
2995    /// The acronym of [`PerfectTaiko`]
2996    pub const fn acronym() -> Acronym {
2997        unsafe { Acronym::from_str_unchecked("PF") }
2998    }
2999    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectTaiko`]
3000    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3001        unsafe {
3002            [
3003                Acronym::from_str_unchecked("NF"),
3004                Acronym::from_str_unchecked("SD"),
3005                Acronym::from_str_unchecked("AC"),
3006                Acronym::from_str_unchecked("CN"),
3007            ]
3008        }
3009        .into_iter()
3010    }
3011    /// The description of [`PerfectTaiko`]
3012    pub const fn description() -> &'static str {
3013        "SS or quit."
3014    }
3015    /// The [`GameModKind`] of [`PerfectTaiko`]
3016    pub const fn kind() -> GameModKind {
3017        GameModKind::DifficultyIncrease
3018    }
3019    /// Bit value of [`PerfectTaiko`]
3020    ///
3021    /// See <https://github.com/ppy/osu-api/wiki#mods>
3022    pub const fn bits() -> u32 {
3023        16416
3024    }
3025}
3026impl DoubleTimeTaiko {
3027    /// The acronym of [`DoubleTimeTaiko`]
3028    pub const fn acronym() -> Acronym {
3029        unsafe { Acronym::from_str_unchecked("DT") }
3030    }
3031    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeTaiko`]
3032    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3033        unsafe {
3034            [
3035                Acronym::from_str_unchecked("HT"),
3036                Acronym::from_str_unchecked("DC"),
3037                Acronym::from_str_unchecked("NC"),
3038                Acronym::from_str_unchecked("WU"),
3039                Acronym::from_str_unchecked("WD"),
3040                Acronym::from_str_unchecked("AS"),
3041            ]
3042        }
3043        .into_iter()
3044    }
3045    /// The description of [`DoubleTimeTaiko`]
3046    pub const fn description() -> &'static str {
3047        "Zoooooooooom..."
3048    }
3049    /// The [`GameModKind`] of [`DoubleTimeTaiko`]
3050    pub const fn kind() -> GameModKind {
3051        GameModKind::DifficultyIncrease
3052    }
3053    /// Bit value of [`DoubleTimeTaiko`]
3054    ///
3055    /// See <https://github.com/ppy/osu-api/wiki#mods>
3056    pub const fn bits() -> u32 {
3057        64
3058    }
3059}
3060impl NightcoreTaiko {
3061    /// The acronym of [`NightcoreTaiko`]
3062    pub const fn acronym() -> Acronym {
3063        unsafe { Acronym::from_str_unchecked("NC") }
3064    }
3065    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreTaiko`]
3066    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3067        unsafe {
3068            [
3069                Acronym::from_str_unchecked("HT"),
3070                Acronym::from_str_unchecked("DC"),
3071                Acronym::from_str_unchecked("DT"),
3072                Acronym::from_str_unchecked("WU"),
3073                Acronym::from_str_unchecked("WD"),
3074                Acronym::from_str_unchecked("AS"),
3075            ]
3076        }
3077        .into_iter()
3078    }
3079    /// The description of [`NightcoreTaiko`]
3080    pub const fn description() -> &'static str {
3081        "Uguuuuuuuu..."
3082    }
3083    /// The [`GameModKind`] of [`NightcoreTaiko`]
3084    pub const fn kind() -> GameModKind {
3085        GameModKind::DifficultyIncrease
3086    }
3087    /// Bit value of [`NightcoreTaiko`]
3088    ///
3089    /// See <https://github.com/ppy/osu-api/wiki#mods>
3090    pub const fn bits() -> u32 {
3091        576
3092    }
3093}
3094impl HiddenTaiko {
3095    /// The acronym of [`HiddenTaiko`]
3096    pub const fn acronym() -> Acronym {
3097        unsafe { Acronym::from_str_unchecked("HD") }
3098    }
3099    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenTaiko`]
3100    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3101        [].into_iter()
3102    }
3103    /// The description of [`HiddenTaiko`]
3104    pub const fn description() -> &'static str {
3105        "Beats fade out before you hit them!"
3106    }
3107    /// The [`GameModKind`] of [`HiddenTaiko`]
3108    pub const fn kind() -> GameModKind {
3109        GameModKind::DifficultyIncrease
3110    }
3111    /// Bit value of [`HiddenTaiko`]
3112    ///
3113    /// See <https://github.com/ppy/osu-api/wiki#mods>
3114    pub const fn bits() -> u32 {
3115        8
3116    }
3117}
3118impl FlashlightTaiko {
3119    /// The acronym of [`FlashlightTaiko`]
3120    pub const fn acronym() -> Acronym {
3121        unsafe { Acronym::from_str_unchecked("FL") }
3122    }
3123    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightTaiko`]
3124    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3125        [].into_iter()
3126    }
3127    /// The description of [`FlashlightTaiko`]
3128    pub const fn description() -> &'static str {
3129        "Restricted view area."
3130    }
3131    /// The [`GameModKind`] of [`FlashlightTaiko`]
3132    pub const fn kind() -> GameModKind {
3133        GameModKind::DifficultyIncrease
3134    }
3135    /// Bit value of [`FlashlightTaiko`]
3136    ///
3137    /// See <https://github.com/ppy/osu-api/wiki#mods>
3138    pub const fn bits() -> u32 {
3139        1024
3140    }
3141}
3142impl AccuracyChallengeTaiko {
3143    /// The acronym of [`AccuracyChallengeTaiko`]
3144    pub const fn acronym() -> Acronym {
3145        unsafe { Acronym::from_str_unchecked("AC") }
3146    }
3147    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeTaiko`]
3148    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3149        unsafe {
3150            [
3151                Acronym::from_str_unchecked("NF"),
3152                Acronym::from_str_unchecked("PF"),
3153                Acronym::from_str_unchecked("CN"),
3154            ]
3155        }
3156        .into_iter()
3157    }
3158    /// The description of [`AccuracyChallengeTaiko`]
3159    pub const fn description() -> &'static str {
3160        "Fail if your accuracy drops too low!"
3161    }
3162    /// The [`GameModKind`] of [`AccuracyChallengeTaiko`]
3163    pub const fn kind() -> GameModKind {
3164        GameModKind::DifficultyIncrease
3165    }
3166}
3167impl RandomTaiko {
3168    /// The acronym of [`RandomTaiko`]
3169    pub const fn acronym() -> Acronym {
3170        unsafe { Acronym::from_str_unchecked("RD") }
3171    }
3172    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomTaiko`]
3173    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3174        unsafe { [Acronym::from_str_unchecked("SW")] }.into_iter()
3175    }
3176    /// The description of [`RandomTaiko`]
3177    pub const fn description() -> &'static str {
3178        "Shuffle around the colours!"
3179    }
3180    /// The [`GameModKind`] of [`RandomTaiko`]
3181    pub const fn kind() -> GameModKind {
3182        GameModKind::Conversion
3183    }
3184    /// Bit value of [`RandomTaiko`]
3185    ///
3186    /// See <https://github.com/ppy/osu-api/wiki#mods>
3187    pub const fn bits() -> u32 {
3188        2097152
3189    }
3190}
3191impl DifficultyAdjustTaiko {
3192    /// The acronym of [`DifficultyAdjustTaiko`]
3193    pub const fn acronym() -> Acronym {
3194        unsafe { Acronym::from_str_unchecked("DA") }
3195    }
3196    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustTaiko`]
3197    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3198        unsafe {
3199            [
3200                Acronym::from_str_unchecked("EZ"),
3201                Acronym::from_str_unchecked("HR"),
3202            ]
3203        }
3204        .into_iter()
3205    }
3206    /// The description of [`DifficultyAdjustTaiko`]
3207    pub const fn description() -> &'static str {
3208        "Override a beatmap's difficulty settings."
3209    }
3210    /// The [`GameModKind`] of [`DifficultyAdjustTaiko`]
3211    pub const fn kind() -> GameModKind {
3212        GameModKind::Conversion
3213    }
3214}
3215impl ClassicTaiko {
3216    /// The acronym of [`ClassicTaiko`]
3217    pub const fn acronym() -> Acronym {
3218        unsafe { Acronym::from_str_unchecked("CL") }
3219    }
3220    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicTaiko`]
3221    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3222        [].into_iter()
3223    }
3224    /// The description of [`ClassicTaiko`]
3225    pub const fn description() -> &'static str {
3226        "Feeling nostalgic?"
3227    }
3228    /// The [`GameModKind`] of [`ClassicTaiko`]
3229    pub const fn kind() -> GameModKind {
3230        GameModKind::Conversion
3231    }
3232}
3233impl SwapTaiko {
3234    /// The acronym of [`SwapTaiko`]
3235    pub const fn acronym() -> Acronym {
3236        unsafe { Acronym::from_str_unchecked("SW") }
3237    }
3238    /// Iterator of [`Acronym`] for mods that are incompatible with [`SwapTaiko`]
3239    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3240        unsafe { [Acronym::from_str_unchecked("RD")] }.into_iter()
3241    }
3242    /// The description of [`SwapTaiko`]
3243    pub const fn description() -> &'static str {
3244        "Dons become kats, kats become dons"
3245    }
3246    /// The [`GameModKind`] of [`SwapTaiko`]
3247    pub const fn kind() -> GameModKind {
3248        GameModKind::Conversion
3249    }
3250}
3251impl SingleTapTaiko {
3252    /// The acronym of [`SingleTapTaiko`]
3253    pub const fn acronym() -> Acronym {
3254        unsafe { Acronym::from_str_unchecked("SG") }
3255    }
3256    /// Iterator of [`Acronym`] for mods that are incompatible with [`SingleTapTaiko`]
3257    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3258        unsafe {
3259            [
3260                Acronym::from_str_unchecked("AT"),
3261                Acronym::from_str_unchecked("CN"),
3262                Acronym::from_str_unchecked("RX"),
3263            ]
3264        }
3265        .into_iter()
3266    }
3267    /// The description of [`SingleTapTaiko`]
3268    pub const fn description() -> &'static str {
3269        "One key for dons, one key for kats."
3270    }
3271    /// The [`GameModKind`] of [`SingleTapTaiko`]
3272    pub const fn kind() -> GameModKind {
3273        GameModKind::Conversion
3274    }
3275}
3276impl ConstantSpeedTaiko {
3277    /// The acronym of [`ConstantSpeedTaiko`]
3278    pub const fn acronym() -> Acronym {
3279        unsafe { Acronym::from_str_unchecked("CS") }
3280    }
3281    /// Iterator of [`Acronym`] for mods that are incompatible with [`ConstantSpeedTaiko`]
3282    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3283        [].into_iter()
3284    }
3285    /// The description of [`ConstantSpeedTaiko`]
3286    pub const fn description() -> &'static str {
3287        "No more tricky speed changes!"
3288    }
3289    /// The [`GameModKind`] of [`ConstantSpeedTaiko`]
3290    pub const fn kind() -> GameModKind {
3291        GameModKind::Conversion
3292    }
3293}
3294impl AutoplayTaiko {
3295    /// The acronym of [`AutoplayTaiko`]
3296    pub const fn acronym() -> Acronym {
3297        unsafe { Acronym::from_str_unchecked("AT") }
3298    }
3299    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayTaiko`]
3300    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3301        unsafe {
3302            [
3303                Acronym::from_str_unchecked("SG"),
3304                Acronym::from_str_unchecked("CN"),
3305                Acronym::from_str_unchecked("RX"),
3306                Acronym::from_str_unchecked("AS"),
3307            ]
3308        }
3309        .into_iter()
3310    }
3311    /// The description of [`AutoplayTaiko`]
3312    pub const fn description() -> &'static str {
3313        "Watch a perfect automated play through the song."
3314    }
3315    /// The [`GameModKind`] of [`AutoplayTaiko`]
3316    pub const fn kind() -> GameModKind {
3317        GameModKind::Automation
3318    }
3319    /// Bit value of [`AutoplayTaiko`]
3320    ///
3321    /// See <https://github.com/ppy/osu-api/wiki#mods>
3322    pub const fn bits() -> u32 {
3323        2048
3324    }
3325}
3326impl CinemaTaiko {
3327    /// The acronym of [`CinemaTaiko`]
3328    pub const fn acronym() -> Acronym {
3329        unsafe { Acronym::from_str_unchecked("CN") }
3330    }
3331    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaTaiko`]
3332    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3333        unsafe {
3334            [
3335                Acronym::from_str_unchecked("NF"),
3336                Acronym::from_str_unchecked("SD"),
3337                Acronym::from_str_unchecked("PF"),
3338                Acronym::from_str_unchecked("AC"),
3339                Acronym::from_str_unchecked("SG"),
3340                Acronym::from_str_unchecked("AT"),
3341                Acronym::from_str_unchecked("RX"),
3342                Acronym::from_str_unchecked("AS"),
3343            ]
3344        }
3345        .into_iter()
3346    }
3347    /// The description of [`CinemaTaiko`]
3348    pub const fn description() -> &'static str {
3349        "Watch the video without visual distractions."
3350    }
3351    /// The [`GameModKind`] of [`CinemaTaiko`]
3352    pub const fn kind() -> GameModKind {
3353        GameModKind::Automation
3354    }
3355    /// Bit value of [`CinemaTaiko`]
3356    ///
3357    /// See <https://github.com/ppy/osu-api/wiki#mods>
3358    pub const fn bits() -> u32 {
3359        4194304
3360    }
3361}
3362impl RelaxTaiko {
3363    /// The acronym of [`RelaxTaiko`]
3364    pub const fn acronym() -> Acronym {
3365        unsafe { Acronym::from_str_unchecked("RX") }
3366    }
3367    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxTaiko`]
3368    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3369        unsafe {
3370            [
3371                Acronym::from_str_unchecked("SG"),
3372                Acronym::from_str_unchecked("AT"),
3373                Acronym::from_str_unchecked("CN"),
3374            ]
3375        }
3376        .into_iter()
3377    }
3378    /// The description of [`RelaxTaiko`]
3379    pub const fn description() -> &'static str {
3380        "No need to remember which key is correct anymore!"
3381    }
3382    /// The [`GameModKind`] of [`RelaxTaiko`]
3383    pub const fn kind() -> GameModKind {
3384        GameModKind::Automation
3385    }
3386    /// Bit value of [`RelaxTaiko`]
3387    ///
3388    /// See <https://github.com/ppy/osu-api/wiki#mods>
3389    pub const fn bits() -> u32 {
3390        128
3391    }
3392}
3393impl WindUpTaiko {
3394    /// The acronym of [`WindUpTaiko`]
3395    pub const fn acronym() -> Acronym {
3396        unsafe { Acronym::from_str_unchecked("WU") }
3397    }
3398    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpTaiko`]
3399    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3400        unsafe {
3401            [
3402                Acronym::from_str_unchecked("HT"),
3403                Acronym::from_str_unchecked("DC"),
3404                Acronym::from_str_unchecked("DT"),
3405                Acronym::from_str_unchecked("NC"),
3406                Acronym::from_str_unchecked("WD"),
3407                Acronym::from_str_unchecked("AS"),
3408            ]
3409        }
3410        .into_iter()
3411    }
3412    /// The description of [`WindUpTaiko`]
3413    pub const fn description() -> &'static str {
3414        "Can you keep up?"
3415    }
3416    /// The [`GameModKind`] of [`WindUpTaiko`]
3417    pub const fn kind() -> GameModKind {
3418        GameModKind::Fun
3419    }
3420}
3421impl WindDownTaiko {
3422    /// The acronym of [`WindDownTaiko`]
3423    pub const fn acronym() -> Acronym {
3424        unsafe { Acronym::from_str_unchecked("WD") }
3425    }
3426    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownTaiko`]
3427    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3428        unsafe {
3429            [
3430                Acronym::from_str_unchecked("HT"),
3431                Acronym::from_str_unchecked("DC"),
3432                Acronym::from_str_unchecked("DT"),
3433                Acronym::from_str_unchecked("NC"),
3434                Acronym::from_str_unchecked("WU"),
3435                Acronym::from_str_unchecked("AS"),
3436            ]
3437        }
3438        .into_iter()
3439    }
3440    /// The description of [`WindDownTaiko`]
3441    pub const fn description() -> &'static str {
3442        "Sloooow doooown..."
3443    }
3444    /// The [`GameModKind`] of [`WindDownTaiko`]
3445    pub const fn kind() -> GameModKind {
3446        GameModKind::Fun
3447    }
3448}
3449impl MutedTaiko {
3450    /// The acronym of [`MutedTaiko`]
3451    pub const fn acronym() -> Acronym {
3452        unsafe { Acronym::from_str_unchecked("MU") }
3453    }
3454    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedTaiko`]
3455    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3456        [].into_iter()
3457    }
3458    /// The description of [`MutedTaiko`]
3459    pub const fn description() -> &'static str {
3460        "Can you still feel the rhythm without music?"
3461    }
3462    /// The [`GameModKind`] of [`MutedTaiko`]
3463    pub const fn kind() -> GameModKind {
3464        GameModKind::Fun
3465    }
3466}
3467impl AdaptiveSpeedTaiko {
3468    /// The acronym of [`AdaptiveSpeedTaiko`]
3469    pub const fn acronym() -> Acronym {
3470        unsafe { Acronym::from_str_unchecked("AS") }
3471    }
3472    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedTaiko`]
3473    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3474        unsafe {
3475            [
3476                Acronym::from_str_unchecked("HT"),
3477                Acronym::from_str_unchecked("DC"),
3478                Acronym::from_str_unchecked("DT"),
3479                Acronym::from_str_unchecked("NC"),
3480                Acronym::from_str_unchecked("AT"),
3481                Acronym::from_str_unchecked("CN"),
3482                Acronym::from_str_unchecked("WU"),
3483                Acronym::from_str_unchecked("WD"),
3484            ]
3485        }
3486        .into_iter()
3487    }
3488    /// The description of [`AdaptiveSpeedTaiko`]
3489    pub const fn description() -> &'static str {
3490        "Let track speed adapt to you."
3491    }
3492    /// The [`GameModKind`] of [`AdaptiveSpeedTaiko`]
3493    pub const fn kind() -> GameModKind {
3494        GameModKind::Fun
3495    }
3496}
3497impl ScoreV2Taiko {
3498    /// The acronym of [`ScoreV2Taiko`]
3499    pub const fn acronym() -> Acronym {
3500        unsafe { Acronym::from_str_unchecked("SV2") }
3501    }
3502    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Taiko`]
3503    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3504        [].into_iter()
3505    }
3506    /// The description of [`ScoreV2Taiko`]
3507    pub const fn description() -> &'static str {
3508        "Score set on earlier osu! versions with the V2 scoring algorithm active."
3509    }
3510    /// The [`GameModKind`] of [`ScoreV2Taiko`]
3511    pub const fn kind() -> GameModKind {
3512        GameModKind::System
3513    }
3514    /// Bit value of [`ScoreV2Taiko`]
3515    ///
3516    /// See <https://github.com/ppy/osu-api/wiki#mods>
3517    pub const fn bits() -> u32 {
3518        536870912
3519    }
3520}
3521impl EasyCatch {
3522    /// The acronym of [`EasyCatch`]
3523    pub const fn acronym() -> Acronym {
3524        unsafe { Acronym::from_str_unchecked("EZ") }
3525    }
3526    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyCatch`]
3527    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3528        unsafe {
3529            [
3530                Acronym::from_str_unchecked("HR"),
3531                Acronym::from_str_unchecked("AC"),
3532                Acronym::from_str_unchecked("DA"),
3533            ]
3534        }
3535        .into_iter()
3536    }
3537    /// The description of [`EasyCatch`]
3538    pub const fn description() -> &'static str {
3539        "Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!"
3540    }
3541    /// The [`GameModKind`] of [`EasyCatch`]
3542    pub const fn kind() -> GameModKind {
3543        GameModKind::DifficultyReduction
3544    }
3545    /// Bit value of [`EasyCatch`]
3546    ///
3547    /// See <https://github.com/ppy/osu-api/wiki#mods>
3548    pub const fn bits() -> u32 {
3549        2
3550    }
3551}
3552impl NoFailCatch {
3553    /// The acronym of [`NoFailCatch`]
3554    pub const fn acronym() -> Acronym {
3555        unsafe { Acronym::from_str_unchecked("NF") }
3556    }
3557    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailCatch`]
3558    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3559        unsafe {
3560            [
3561                Acronym::from_str_unchecked("SD"),
3562                Acronym::from_str_unchecked("PF"),
3563                Acronym::from_str_unchecked("AC"),
3564                Acronym::from_str_unchecked("CN"),
3565            ]
3566        }
3567        .into_iter()
3568    }
3569    /// The description of [`NoFailCatch`]
3570    pub const fn description() -> &'static str {
3571        "You can't fail, no matter what."
3572    }
3573    /// The [`GameModKind`] of [`NoFailCatch`]
3574    pub const fn kind() -> GameModKind {
3575        GameModKind::DifficultyReduction
3576    }
3577    /// Bit value of [`NoFailCatch`]
3578    ///
3579    /// See <https://github.com/ppy/osu-api/wiki#mods>
3580    pub const fn bits() -> u32 {
3581        1
3582    }
3583}
3584impl HalfTimeCatch {
3585    /// The acronym of [`HalfTimeCatch`]
3586    pub const fn acronym() -> Acronym {
3587        unsafe { Acronym::from_str_unchecked("HT") }
3588    }
3589    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeCatch`]
3590    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3591        unsafe {
3592            [
3593                Acronym::from_str_unchecked("DC"),
3594                Acronym::from_str_unchecked("DT"),
3595                Acronym::from_str_unchecked("NC"),
3596                Acronym::from_str_unchecked("WU"),
3597                Acronym::from_str_unchecked("WD"),
3598            ]
3599        }
3600        .into_iter()
3601    }
3602    /// The description of [`HalfTimeCatch`]
3603    pub const fn description() -> &'static str {
3604        "Less zoom..."
3605    }
3606    /// The [`GameModKind`] of [`HalfTimeCatch`]
3607    pub const fn kind() -> GameModKind {
3608        GameModKind::DifficultyReduction
3609    }
3610    /// Bit value of [`HalfTimeCatch`]
3611    ///
3612    /// See <https://github.com/ppy/osu-api/wiki#mods>
3613    pub const fn bits() -> u32 {
3614        256
3615    }
3616}
3617impl DaycoreCatch {
3618    /// The acronym of [`DaycoreCatch`]
3619    pub const fn acronym() -> Acronym {
3620        unsafe { Acronym::from_str_unchecked("DC") }
3621    }
3622    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreCatch`]
3623    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3624        unsafe {
3625            [
3626                Acronym::from_str_unchecked("HT"),
3627                Acronym::from_str_unchecked("DT"),
3628                Acronym::from_str_unchecked("NC"),
3629                Acronym::from_str_unchecked("WU"),
3630                Acronym::from_str_unchecked("WD"),
3631            ]
3632        }
3633        .into_iter()
3634    }
3635    /// The description of [`DaycoreCatch`]
3636    pub const fn description() -> &'static str {
3637        "Whoaaaaa..."
3638    }
3639    /// The [`GameModKind`] of [`DaycoreCatch`]
3640    pub const fn kind() -> GameModKind {
3641        GameModKind::DifficultyReduction
3642    }
3643}
3644impl HardRockCatch {
3645    /// The acronym of [`HardRockCatch`]
3646    pub const fn acronym() -> Acronym {
3647        unsafe { Acronym::from_str_unchecked("HR") }
3648    }
3649    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockCatch`]
3650    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3651        unsafe {
3652            [
3653                Acronym::from_str_unchecked("EZ"),
3654                Acronym::from_str_unchecked("DA"),
3655            ]
3656        }
3657        .into_iter()
3658    }
3659    /// The description of [`HardRockCatch`]
3660    pub const fn description() -> &'static str {
3661        "Everything just got a bit harder..."
3662    }
3663    /// The [`GameModKind`] of [`HardRockCatch`]
3664    pub const fn kind() -> GameModKind {
3665        GameModKind::DifficultyIncrease
3666    }
3667    /// Bit value of [`HardRockCatch`]
3668    ///
3669    /// See <https://github.com/ppy/osu-api/wiki#mods>
3670    pub const fn bits() -> u32 {
3671        16
3672    }
3673}
3674impl SuddenDeathCatch {
3675    /// The acronym of [`SuddenDeathCatch`]
3676    pub const fn acronym() -> Acronym {
3677        unsafe { Acronym::from_str_unchecked("SD") }
3678    }
3679    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathCatch`]
3680    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3681        unsafe {
3682            [
3683                Acronym::from_str_unchecked("NF"),
3684                Acronym::from_str_unchecked("PF"),
3685                Acronym::from_str_unchecked("CN"),
3686            ]
3687        }
3688        .into_iter()
3689    }
3690    /// The description of [`SuddenDeathCatch`]
3691    pub const fn description() -> &'static str {
3692        "Miss and fail."
3693    }
3694    /// The [`GameModKind`] of [`SuddenDeathCatch`]
3695    pub const fn kind() -> GameModKind {
3696        GameModKind::DifficultyIncrease
3697    }
3698    /// Bit value of [`SuddenDeathCatch`]
3699    ///
3700    /// See <https://github.com/ppy/osu-api/wiki#mods>
3701    pub const fn bits() -> u32 {
3702        32
3703    }
3704}
3705impl PerfectCatch {
3706    /// The acronym of [`PerfectCatch`]
3707    pub const fn acronym() -> Acronym {
3708        unsafe { Acronym::from_str_unchecked("PF") }
3709    }
3710    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectCatch`]
3711    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3712        unsafe {
3713            [
3714                Acronym::from_str_unchecked("NF"),
3715                Acronym::from_str_unchecked("SD"),
3716                Acronym::from_str_unchecked("AC"),
3717                Acronym::from_str_unchecked("CN"),
3718            ]
3719        }
3720        .into_iter()
3721    }
3722    /// The description of [`PerfectCatch`]
3723    pub const fn description() -> &'static str {
3724        "SS or quit."
3725    }
3726    /// The [`GameModKind`] of [`PerfectCatch`]
3727    pub const fn kind() -> GameModKind {
3728        GameModKind::DifficultyIncrease
3729    }
3730    /// Bit value of [`PerfectCatch`]
3731    ///
3732    /// See <https://github.com/ppy/osu-api/wiki#mods>
3733    pub const fn bits() -> u32 {
3734        16416
3735    }
3736}
3737impl DoubleTimeCatch {
3738    /// The acronym of [`DoubleTimeCatch`]
3739    pub const fn acronym() -> Acronym {
3740        unsafe { Acronym::from_str_unchecked("DT") }
3741    }
3742    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeCatch`]
3743    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3744        unsafe {
3745            [
3746                Acronym::from_str_unchecked("HT"),
3747                Acronym::from_str_unchecked("DC"),
3748                Acronym::from_str_unchecked("NC"),
3749                Acronym::from_str_unchecked("WU"),
3750                Acronym::from_str_unchecked("WD"),
3751            ]
3752        }
3753        .into_iter()
3754    }
3755    /// The description of [`DoubleTimeCatch`]
3756    pub const fn description() -> &'static str {
3757        "Zoooooooooom..."
3758    }
3759    /// The [`GameModKind`] of [`DoubleTimeCatch`]
3760    pub const fn kind() -> GameModKind {
3761        GameModKind::DifficultyIncrease
3762    }
3763    /// Bit value of [`DoubleTimeCatch`]
3764    ///
3765    /// See <https://github.com/ppy/osu-api/wiki#mods>
3766    pub const fn bits() -> u32 {
3767        64
3768    }
3769}
3770impl NightcoreCatch {
3771    /// The acronym of [`NightcoreCatch`]
3772    pub const fn acronym() -> Acronym {
3773        unsafe { Acronym::from_str_unchecked("NC") }
3774    }
3775    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreCatch`]
3776    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3777        unsafe {
3778            [
3779                Acronym::from_str_unchecked("HT"),
3780                Acronym::from_str_unchecked("DC"),
3781                Acronym::from_str_unchecked("DT"),
3782                Acronym::from_str_unchecked("WU"),
3783                Acronym::from_str_unchecked("WD"),
3784            ]
3785        }
3786        .into_iter()
3787    }
3788    /// The description of [`NightcoreCatch`]
3789    pub const fn description() -> &'static str {
3790        "Uguuuuuuuu..."
3791    }
3792    /// The [`GameModKind`] of [`NightcoreCatch`]
3793    pub const fn kind() -> GameModKind {
3794        GameModKind::DifficultyIncrease
3795    }
3796    /// Bit value of [`NightcoreCatch`]
3797    ///
3798    /// See <https://github.com/ppy/osu-api/wiki#mods>
3799    pub const fn bits() -> u32 {
3800        576
3801    }
3802}
3803impl HiddenCatch {
3804    /// The acronym of [`HiddenCatch`]
3805    pub const fn acronym() -> Acronym {
3806        unsafe { Acronym::from_str_unchecked("HD") }
3807    }
3808    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenCatch`]
3809    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3810        [].into_iter()
3811    }
3812    /// The description of [`HiddenCatch`]
3813    pub const fn description() -> &'static str {
3814        "Play with fading fruits."
3815    }
3816    /// The [`GameModKind`] of [`HiddenCatch`]
3817    pub const fn kind() -> GameModKind {
3818        GameModKind::DifficultyIncrease
3819    }
3820    /// Bit value of [`HiddenCatch`]
3821    ///
3822    /// See <https://github.com/ppy/osu-api/wiki#mods>
3823    pub const fn bits() -> u32 {
3824        8
3825    }
3826}
3827impl FlashlightCatch {
3828    /// The acronym of [`FlashlightCatch`]
3829    pub const fn acronym() -> Acronym {
3830        unsafe { Acronym::from_str_unchecked("FL") }
3831    }
3832    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightCatch`]
3833    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3834        [].into_iter()
3835    }
3836    /// The description of [`FlashlightCatch`]
3837    pub const fn description() -> &'static str {
3838        "Restricted view area."
3839    }
3840    /// The [`GameModKind`] of [`FlashlightCatch`]
3841    pub const fn kind() -> GameModKind {
3842        GameModKind::DifficultyIncrease
3843    }
3844    /// Bit value of [`FlashlightCatch`]
3845    ///
3846    /// See <https://github.com/ppy/osu-api/wiki#mods>
3847    pub const fn bits() -> u32 {
3848        1024
3849    }
3850}
3851impl AccuracyChallengeCatch {
3852    /// The acronym of [`AccuracyChallengeCatch`]
3853    pub const fn acronym() -> Acronym {
3854        unsafe { Acronym::from_str_unchecked("AC") }
3855    }
3856    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeCatch`]
3857    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3858        unsafe {
3859            [
3860                Acronym::from_str_unchecked("EZ"),
3861                Acronym::from_str_unchecked("NF"),
3862                Acronym::from_str_unchecked("PF"),
3863                Acronym::from_str_unchecked("CN"),
3864            ]
3865        }
3866        .into_iter()
3867    }
3868    /// The description of [`AccuracyChallengeCatch`]
3869    pub const fn description() -> &'static str {
3870        "Fail if your accuracy drops too low!"
3871    }
3872    /// The [`GameModKind`] of [`AccuracyChallengeCatch`]
3873    pub const fn kind() -> GameModKind {
3874        GameModKind::DifficultyIncrease
3875    }
3876}
3877impl DifficultyAdjustCatch {
3878    /// The acronym of [`DifficultyAdjustCatch`]
3879    pub const fn acronym() -> Acronym {
3880        unsafe { Acronym::from_str_unchecked("DA") }
3881    }
3882    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustCatch`]
3883    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3884        unsafe {
3885            [
3886                Acronym::from_str_unchecked("EZ"),
3887                Acronym::from_str_unchecked("HR"),
3888            ]
3889        }
3890        .into_iter()
3891    }
3892    /// The description of [`DifficultyAdjustCatch`]
3893    pub const fn description() -> &'static str {
3894        "Override a beatmap's difficulty settings."
3895    }
3896    /// The [`GameModKind`] of [`DifficultyAdjustCatch`]
3897    pub const fn kind() -> GameModKind {
3898        GameModKind::Conversion
3899    }
3900}
3901impl ClassicCatch {
3902    /// The acronym of [`ClassicCatch`]
3903    pub const fn acronym() -> Acronym {
3904        unsafe { Acronym::from_str_unchecked("CL") }
3905    }
3906    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicCatch`]
3907    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3908        [].into_iter()
3909    }
3910    /// The description of [`ClassicCatch`]
3911    pub const fn description() -> &'static str {
3912        "Feeling nostalgic?"
3913    }
3914    /// The [`GameModKind`] of [`ClassicCatch`]
3915    pub const fn kind() -> GameModKind {
3916        GameModKind::Conversion
3917    }
3918}
3919impl MirrorCatch {
3920    /// The acronym of [`MirrorCatch`]
3921    pub const fn acronym() -> Acronym {
3922        unsafe { Acronym::from_str_unchecked("MR") }
3923    }
3924    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorCatch`]
3925    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3926        [].into_iter()
3927    }
3928    /// The description of [`MirrorCatch`]
3929    pub const fn description() -> &'static str {
3930        "Fruits are flipped horizontally."
3931    }
3932    /// The [`GameModKind`] of [`MirrorCatch`]
3933    pub const fn kind() -> GameModKind {
3934        GameModKind::Conversion
3935    }
3936    /// Bit value of [`MirrorCatch`]
3937    ///
3938    /// See <https://github.com/ppy/osu-api/wiki#mods>
3939    pub const fn bits() -> u32 {
3940        1073741824
3941    }
3942}
3943impl AutoplayCatch {
3944    /// The acronym of [`AutoplayCatch`]
3945    pub const fn acronym() -> Acronym {
3946        unsafe { Acronym::from_str_unchecked("AT") }
3947    }
3948    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayCatch`]
3949    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3950        unsafe {
3951            [
3952                Acronym::from_str_unchecked("CN"),
3953                Acronym::from_str_unchecked("RX"),
3954                Acronym::from_str_unchecked("MF"),
3955            ]
3956        }
3957        .into_iter()
3958    }
3959    /// The description of [`AutoplayCatch`]
3960    pub const fn description() -> &'static str {
3961        "Watch a perfect automated play through the song."
3962    }
3963    /// The [`GameModKind`] of [`AutoplayCatch`]
3964    pub const fn kind() -> GameModKind {
3965        GameModKind::Automation
3966    }
3967    /// Bit value of [`AutoplayCatch`]
3968    ///
3969    /// See <https://github.com/ppy/osu-api/wiki#mods>
3970    pub const fn bits() -> u32 {
3971        2048
3972    }
3973}
3974impl CinemaCatch {
3975    /// The acronym of [`CinemaCatch`]
3976    pub const fn acronym() -> Acronym {
3977        unsafe { Acronym::from_str_unchecked("CN") }
3978    }
3979    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaCatch`]
3980    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3981        unsafe {
3982            [
3983                Acronym::from_str_unchecked("NF"),
3984                Acronym::from_str_unchecked("SD"),
3985                Acronym::from_str_unchecked("PF"),
3986                Acronym::from_str_unchecked("AC"),
3987                Acronym::from_str_unchecked("AT"),
3988                Acronym::from_str_unchecked("RX"),
3989                Acronym::from_str_unchecked("MF"),
3990            ]
3991        }
3992        .into_iter()
3993    }
3994    /// The description of [`CinemaCatch`]
3995    pub const fn description() -> &'static str {
3996        "Watch the video without visual distractions."
3997    }
3998    /// The [`GameModKind`] of [`CinemaCatch`]
3999    pub const fn kind() -> GameModKind {
4000        GameModKind::Automation
4001    }
4002    /// Bit value of [`CinemaCatch`]
4003    ///
4004    /// See <https://github.com/ppy/osu-api/wiki#mods>
4005    pub const fn bits() -> u32 {
4006        4194304
4007    }
4008}
4009impl RelaxCatch {
4010    /// The acronym of [`RelaxCatch`]
4011    pub const fn acronym() -> Acronym {
4012        unsafe { Acronym::from_str_unchecked("RX") }
4013    }
4014    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxCatch`]
4015    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4016        unsafe {
4017            [
4018                Acronym::from_str_unchecked("AT"),
4019                Acronym::from_str_unchecked("CN"),
4020                Acronym::from_str_unchecked("MF"),
4021            ]
4022        }
4023        .into_iter()
4024    }
4025    /// The description of [`RelaxCatch`]
4026    pub const fn description() -> &'static str {
4027        "Use the mouse to control the catcher."
4028    }
4029    /// The [`GameModKind`] of [`RelaxCatch`]
4030    pub const fn kind() -> GameModKind {
4031        GameModKind::Automation
4032    }
4033    /// Bit value of [`RelaxCatch`]
4034    ///
4035    /// See <https://github.com/ppy/osu-api/wiki#mods>
4036    pub const fn bits() -> u32 {
4037        128
4038    }
4039}
4040impl WindUpCatch {
4041    /// The acronym of [`WindUpCatch`]
4042    pub const fn acronym() -> Acronym {
4043        unsafe { Acronym::from_str_unchecked("WU") }
4044    }
4045    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpCatch`]
4046    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4047        unsafe {
4048            [
4049                Acronym::from_str_unchecked("HT"),
4050                Acronym::from_str_unchecked("DC"),
4051                Acronym::from_str_unchecked("DT"),
4052                Acronym::from_str_unchecked("NC"),
4053                Acronym::from_str_unchecked("WD"),
4054            ]
4055        }
4056        .into_iter()
4057    }
4058    /// The description of [`WindUpCatch`]
4059    pub const fn description() -> &'static str {
4060        "Can you keep up?"
4061    }
4062    /// The [`GameModKind`] of [`WindUpCatch`]
4063    pub const fn kind() -> GameModKind {
4064        GameModKind::Fun
4065    }
4066}
4067impl WindDownCatch {
4068    /// The acronym of [`WindDownCatch`]
4069    pub const fn acronym() -> Acronym {
4070        unsafe { Acronym::from_str_unchecked("WD") }
4071    }
4072    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownCatch`]
4073    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4074        unsafe {
4075            [
4076                Acronym::from_str_unchecked("HT"),
4077                Acronym::from_str_unchecked("DC"),
4078                Acronym::from_str_unchecked("DT"),
4079                Acronym::from_str_unchecked("NC"),
4080                Acronym::from_str_unchecked("WU"),
4081            ]
4082        }
4083        .into_iter()
4084    }
4085    /// The description of [`WindDownCatch`]
4086    pub const fn description() -> &'static str {
4087        "Sloooow doooown..."
4088    }
4089    /// The [`GameModKind`] of [`WindDownCatch`]
4090    pub const fn kind() -> GameModKind {
4091        GameModKind::Fun
4092    }
4093}
4094impl FloatingFruitsCatch {
4095    /// The acronym of [`FloatingFruitsCatch`]
4096    pub const fn acronym() -> Acronym {
4097        unsafe { Acronym::from_str_unchecked("FF") }
4098    }
4099    /// Iterator of [`Acronym`] for mods that are incompatible with [`FloatingFruitsCatch`]
4100    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4101        [].into_iter()
4102    }
4103    /// The description of [`FloatingFruitsCatch`]
4104    pub const fn description() -> &'static str {
4105        "The fruits are... floating?"
4106    }
4107    /// The [`GameModKind`] of [`FloatingFruitsCatch`]
4108    pub const fn kind() -> GameModKind {
4109        GameModKind::Fun
4110    }
4111}
4112impl MutedCatch {
4113    /// The acronym of [`MutedCatch`]
4114    pub const fn acronym() -> Acronym {
4115        unsafe { Acronym::from_str_unchecked("MU") }
4116    }
4117    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedCatch`]
4118    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4119        [].into_iter()
4120    }
4121    /// The description of [`MutedCatch`]
4122    pub const fn description() -> &'static str {
4123        "Can you still feel the rhythm without music?"
4124    }
4125    /// The [`GameModKind`] of [`MutedCatch`]
4126    pub const fn kind() -> GameModKind {
4127        GameModKind::Fun
4128    }
4129}
4130impl NoScopeCatch {
4131    /// The acronym of [`NoScopeCatch`]
4132    pub const fn acronym() -> Acronym {
4133        unsafe { Acronym::from_str_unchecked("NS") }
4134    }
4135    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoScopeCatch`]
4136    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4137        [].into_iter()
4138    }
4139    /// The description of [`NoScopeCatch`]
4140    pub const fn description() -> &'static str {
4141        "Where's the catcher?"
4142    }
4143    /// The [`GameModKind`] of [`NoScopeCatch`]
4144    pub const fn kind() -> GameModKind {
4145        GameModKind::Fun
4146    }
4147}
4148impl MovingFastCatch {
4149    /// The acronym of [`MovingFastCatch`]
4150    pub const fn acronym() -> Acronym {
4151        unsafe { Acronym::from_str_unchecked("MF") }
4152    }
4153    /// Iterator of [`Acronym`] for mods that are incompatible with [`MovingFastCatch`]
4154    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4155        unsafe {
4156            [
4157                Acronym::from_str_unchecked("AT"),
4158                Acronym::from_str_unchecked("CN"),
4159                Acronym::from_str_unchecked("RX"),
4160            ]
4161        }
4162        .into_iter()
4163    }
4164    /// The description of [`MovingFastCatch`]
4165    pub const fn description() -> &'static str {
4166        "Dashing by default, slow down!"
4167    }
4168    /// The [`GameModKind`] of [`MovingFastCatch`]
4169    pub const fn kind() -> GameModKind {
4170        GameModKind::Fun
4171    }
4172}
4173impl ScoreV2Catch {
4174    /// The acronym of [`ScoreV2Catch`]
4175    pub const fn acronym() -> Acronym {
4176        unsafe { Acronym::from_str_unchecked("SV2") }
4177    }
4178    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Catch`]
4179    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4180        [].into_iter()
4181    }
4182    /// The description of [`ScoreV2Catch`]
4183    pub const fn description() -> &'static str {
4184        "Score set on earlier osu! versions with the V2 scoring algorithm active."
4185    }
4186    /// The [`GameModKind`] of [`ScoreV2Catch`]
4187    pub const fn kind() -> GameModKind {
4188        GameModKind::System
4189    }
4190    /// Bit value of [`ScoreV2Catch`]
4191    ///
4192    /// See <https://github.com/ppy/osu-api/wiki#mods>
4193    pub const fn bits() -> u32 {
4194        536870912
4195    }
4196}
4197impl EasyMania {
4198    /// The acronym of [`EasyMania`]
4199    pub const fn acronym() -> Acronym {
4200        unsafe { Acronym::from_str_unchecked("EZ") }
4201    }
4202    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyMania`]
4203    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4204        unsafe {
4205            [
4206                Acronym::from_str_unchecked("HR"),
4207                Acronym::from_str_unchecked("AC"),
4208                Acronym::from_str_unchecked("DA"),
4209            ]
4210        }
4211        .into_iter()
4212    }
4213    /// The description of [`EasyMania`]
4214    pub const fn description() -> &'static str {
4215        "More forgiving HP drain, less accuracy required, and extra lives!"
4216    }
4217    /// The [`GameModKind`] of [`EasyMania`]
4218    pub const fn kind() -> GameModKind {
4219        GameModKind::DifficultyReduction
4220    }
4221    /// Bit value of [`EasyMania`]
4222    ///
4223    /// See <https://github.com/ppy/osu-api/wiki#mods>
4224    pub const fn bits() -> u32 {
4225        2
4226    }
4227}
4228impl NoFailMania {
4229    /// The acronym of [`NoFailMania`]
4230    pub const fn acronym() -> Acronym {
4231        unsafe { Acronym::from_str_unchecked("NF") }
4232    }
4233    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailMania`]
4234    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4235        unsafe {
4236            [
4237                Acronym::from_str_unchecked("SD"),
4238                Acronym::from_str_unchecked("PF"),
4239                Acronym::from_str_unchecked("AC"),
4240                Acronym::from_str_unchecked("CN"),
4241            ]
4242        }
4243        .into_iter()
4244    }
4245    /// The description of [`NoFailMania`]
4246    pub const fn description() -> &'static str {
4247        "You can't fail, no matter what."
4248    }
4249    /// The [`GameModKind`] of [`NoFailMania`]
4250    pub const fn kind() -> GameModKind {
4251        GameModKind::DifficultyReduction
4252    }
4253    /// Bit value of [`NoFailMania`]
4254    ///
4255    /// See <https://github.com/ppy/osu-api/wiki#mods>
4256    pub const fn bits() -> u32 {
4257        1
4258    }
4259}
4260impl HalfTimeMania {
4261    /// The acronym of [`HalfTimeMania`]
4262    pub const fn acronym() -> Acronym {
4263        unsafe { Acronym::from_str_unchecked("HT") }
4264    }
4265    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeMania`]
4266    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4267        unsafe {
4268            [
4269                Acronym::from_str_unchecked("DC"),
4270                Acronym::from_str_unchecked("DT"),
4271                Acronym::from_str_unchecked("NC"),
4272                Acronym::from_str_unchecked("WU"),
4273                Acronym::from_str_unchecked("WD"),
4274                Acronym::from_str_unchecked("AS"),
4275            ]
4276        }
4277        .into_iter()
4278    }
4279    /// The description of [`HalfTimeMania`]
4280    pub const fn description() -> &'static str {
4281        "Less zoom..."
4282    }
4283    /// The [`GameModKind`] of [`HalfTimeMania`]
4284    pub const fn kind() -> GameModKind {
4285        GameModKind::DifficultyReduction
4286    }
4287    /// Bit value of [`HalfTimeMania`]
4288    ///
4289    /// See <https://github.com/ppy/osu-api/wiki#mods>
4290    pub const fn bits() -> u32 {
4291        256
4292    }
4293}
4294impl DaycoreMania {
4295    /// The acronym of [`DaycoreMania`]
4296    pub const fn acronym() -> Acronym {
4297        unsafe { Acronym::from_str_unchecked("DC") }
4298    }
4299    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreMania`]
4300    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4301        unsafe {
4302            [
4303                Acronym::from_str_unchecked("HT"),
4304                Acronym::from_str_unchecked("DT"),
4305                Acronym::from_str_unchecked("NC"),
4306                Acronym::from_str_unchecked("WU"),
4307                Acronym::from_str_unchecked("WD"),
4308                Acronym::from_str_unchecked("AS"),
4309            ]
4310        }
4311        .into_iter()
4312    }
4313    /// The description of [`DaycoreMania`]
4314    pub const fn description() -> &'static str {
4315        "Whoaaaaa..."
4316    }
4317    /// The [`GameModKind`] of [`DaycoreMania`]
4318    pub const fn kind() -> GameModKind {
4319        GameModKind::DifficultyReduction
4320    }
4321}
4322impl NoReleaseMania {
4323    /// The acronym of [`NoReleaseMania`]
4324    pub const fn acronym() -> Acronym {
4325        unsafe { Acronym::from_str_unchecked("NR") }
4326    }
4327    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoReleaseMania`]
4328    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4329        unsafe { [Acronym::from_str_unchecked("HO")] }.into_iter()
4330    }
4331    /// The description of [`NoReleaseMania`]
4332    pub const fn description() -> &'static str {
4333        "No more timing the end of hold notes."
4334    }
4335    /// The [`GameModKind`] of [`NoReleaseMania`]
4336    pub const fn kind() -> GameModKind {
4337        GameModKind::DifficultyReduction
4338    }
4339}
4340impl HardRockMania {
4341    /// The acronym of [`HardRockMania`]
4342    pub const fn acronym() -> Acronym {
4343        unsafe { Acronym::from_str_unchecked("HR") }
4344    }
4345    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockMania`]
4346    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4347        unsafe {
4348            [
4349                Acronym::from_str_unchecked("EZ"),
4350                Acronym::from_str_unchecked("DA"),
4351            ]
4352        }
4353        .into_iter()
4354    }
4355    /// The description of [`HardRockMania`]
4356    pub const fn description() -> &'static str {
4357        "Everything just got a bit harder..."
4358    }
4359    /// The [`GameModKind`] of [`HardRockMania`]
4360    pub const fn kind() -> GameModKind {
4361        GameModKind::DifficultyIncrease
4362    }
4363    /// Bit value of [`HardRockMania`]
4364    ///
4365    /// See <https://github.com/ppy/osu-api/wiki#mods>
4366    pub const fn bits() -> u32 {
4367        16
4368    }
4369}
4370impl SuddenDeathMania {
4371    /// The acronym of [`SuddenDeathMania`]
4372    pub const fn acronym() -> Acronym {
4373        unsafe { Acronym::from_str_unchecked("SD") }
4374    }
4375    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathMania`]
4376    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4377        unsafe {
4378            [
4379                Acronym::from_str_unchecked("NF"),
4380                Acronym::from_str_unchecked("PF"),
4381                Acronym::from_str_unchecked("CN"),
4382            ]
4383        }
4384        .into_iter()
4385    }
4386    /// The description of [`SuddenDeathMania`]
4387    pub const fn description() -> &'static str {
4388        "Miss and fail."
4389    }
4390    /// The [`GameModKind`] of [`SuddenDeathMania`]
4391    pub const fn kind() -> GameModKind {
4392        GameModKind::DifficultyIncrease
4393    }
4394    /// Bit value of [`SuddenDeathMania`]
4395    ///
4396    /// See <https://github.com/ppy/osu-api/wiki#mods>
4397    pub const fn bits() -> u32 {
4398        32
4399    }
4400}
4401impl PerfectMania {
4402    /// The acronym of [`PerfectMania`]
4403    pub const fn acronym() -> Acronym {
4404        unsafe { Acronym::from_str_unchecked("PF") }
4405    }
4406    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectMania`]
4407    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4408        unsafe {
4409            [
4410                Acronym::from_str_unchecked("NF"),
4411                Acronym::from_str_unchecked("SD"),
4412                Acronym::from_str_unchecked("AC"),
4413                Acronym::from_str_unchecked("CN"),
4414            ]
4415        }
4416        .into_iter()
4417    }
4418    /// The description of [`PerfectMania`]
4419    pub const fn description() -> &'static str {
4420        "SS or quit."
4421    }
4422    /// The [`GameModKind`] of [`PerfectMania`]
4423    pub const fn kind() -> GameModKind {
4424        GameModKind::DifficultyIncrease
4425    }
4426    /// Bit value of [`PerfectMania`]
4427    ///
4428    /// See <https://github.com/ppy/osu-api/wiki#mods>
4429    pub const fn bits() -> u32 {
4430        16416
4431    }
4432}
4433impl DoubleTimeMania {
4434    /// The acronym of [`DoubleTimeMania`]
4435    pub const fn acronym() -> Acronym {
4436        unsafe { Acronym::from_str_unchecked("DT") }
4437    }
4438    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeMania`]
4439    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4440        unsafe {
4441            [
4442                Acronym::from_str_unchecked("HT"),
4443                Acronym::from_str_unchecked("DC"),
4444                Acronym::from_str_unchecked("NC"),
4445                Acronym::from_str_unchecked("WU"),
4446                Acronym::from_str_unchecked("WD"),
4447                Acronym::from_str_unchecked("AS"),
4448            ]
4449        }
4450        .into_iter()
4451    }
4452    /// The description of [`DoubleTimeMania`]
4453    pub const fn description() -> &'static str {
4454        "Zoooooooooom..."
4455    }
4456    /// The [`GameModKind`] of [`DoubleTimeMania`]
4457    pub const fn kind() -> GameModKind {
4458        GameModKind::DifficultyIncrease
4459    }
4460    /// Bit value of [`DoubleTimeMania`]
4461    ///
4462    /// See <https://github.com/ppy/osu-api/wiki#mods>
4463    pub const fn bits() -> u32 {
4464        64
4465    }
4466}
4467impl NightcoreMania {
4468    /// The acronym of [`NightcoreMania`]
4469    pub const fn acronym() -> Acronym {
4470        unsafe { Acronym::from_str_unchecked("NC") }
4471    }
4472    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreMania`]
4473    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4474        unsafe {
4475            [
4476                Acronym::from_str_unchecked("HT"),
4477                Acronym::from_str_unchecked("DC"),
4478                Acronym::from_str_unchecked("DT"),
4479                Acronym::from_str_unchecked("WU"),
4480                Acronym::from_str_unchecked("WD"),
4481                Acronym::from_str_unchecked("AS"),
4482            ]
4483        }
4484        .into_iter()
4485    }
4486    /// The description of [`NightcoreMania`]
4487    pub const fn description() -> &'static str {
4488        "Uguuuuuuuu..."
4489    }
4490    /// The [`GameModKind`] of [`NightcoreMania`]
4491    pub const fn kind() -> GameModKind {
4492        GameModKind::DifficultyIncrease
4493    }
4494    /// Bit value of [`NightcoreMania`]
4495    ///
4496    /// See <https://github.com/ppy/osu-api/wiki#mods>
4497    pub const fn bits() -> u32 {
4498        576
4499    }
4500}
4501impl FadeInMania {
4502    /// The acronym of [`FadeInMania`]
4503    pub const fn acronym() -> Acronym {
4504        unsafe { Acronym::from_str_unchecked("FI") }
4505    }
4506    /// Iterator of [`Acronym`] for mods that are incompatible with [`FadeInMania`]
4507    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4508        unsafe {
4509            [
4510                Acronym::from_str_unchecked("HD"),
4511                Acronym::from_str_unchecked("CO"),
4512                Acronym::from_str_unchecked("FL"),
4513            ]
4514        }
4515        .into_iter()
4516    }
4517    /// The description of [`FadeInMania`]
4518    pub const fn description() -> &'static str {
4519        "Keys appear out of nowhere!"
4520    }
4521    /// The [`GameModKind`] of [`FadeInMania`]
4522    pub const fn kind() -> GameModKind {
4523        GameModKind::DifficultyIncrease
4524    }
4525    /// Bit value of [`FadeInMania`]
4526    ///
4527    /// See <https://github.com/ppy/osu-api/wiki#mods>
4528    pub const fn bits() -> u32 {
4529        1048576
4530    }
4531}
4532impl HiddenMania {
4533    /// The acronym of [`HiddenMania`]
4534    pub const fn acronym() -> Acronym {
4535        unsafe { Acronym::from_str_unchecked("HD") }
4536    }
4537    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenMania`]
4538    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4539        unsafe {
4540            [
4541                Acronym::from_str_unchecked("FI"),
4542                Acronym::from_str_unchecked("CO"),
4543                Acronym::from_str_unchecked("FL"),
4544            ]
4545        }
4546        .into_iter()
4547    }
4548    /// The description of [`HiddenMania`]
4549    pub const fn description() -> &'static str {
4550        "Keys fade out before you hit them!"
4551    }
4552    /// The [`GameModKind`] of [`HiddenMania`]
4553    pub const fn kind() -> GameModKind {
4554        GameModKind::DifficultyIncrease
4555    }
4556    /// Bit value of [`HiddenMania`]
4557    ///
4558    /// See <https://github.com/ppy/osu-api/wiki#mods>
4559    pub const fn bits() -> u32 {
4560        8
4561    }
4562}
4563impl CoverMania {
4564    /// The acronym of [`CoverMania`]
4565    pub const fn acronym() -> Acronym {
4566        unsafe { Acronym::from_str_unchecked("CO") }
4567    }
4568    /// Iterator of [`Acronym`] for mods that are incompatible with [`CoverMania`]
4569    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4570        unsafe {
4571            [
4572                Acronym::from_str_unchecked("FI"),
4573                Acronym::from_str_unchecked("HD"),
4574                Acronym::from_str_unchecked("FL"),
4575            ]
4576        }
4577        .into_iter()
4578    }
4579    /// The description of [`CoverMania`]
4580    pub const fn description() -> &'static str {
4581        "Decrease the playfield's viewing area."
4582    }
4583    /// The [`GameModKind`] of [`CoverMania`]
4584    pub const fn kind() -> GameModKind {
4585        GameModKind::DifficultyIncrease
4586    }
4587}
4588impl FlashlightMania {
4589    /// The acronym of [`FlashlightMania`]
4590    pub const fn acronym() -> Acronym {
4591        unsafe { Acronym::from_str_unchecked("FL") }
4592    }
4593    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightMania`]
4594    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4595        unsafe {
4596            [
4597                Acronym::from_str_unchecked("FI"),
4598                Acronym::from_str_unchecked("HD"),
4599                Acronym::from_str_unchecked("CO"),
4600            ]
4601        }
4602        .into_iter()
4603    }
4604    /// The description of [`FlashlightMania`]
4605    pub const fn description() -> &'static str {
4606        "Restricted view area."
4607    }
4608    /// The [`GameModKind`] of [`FlashlightMania`]
4609    pub const fn kind() -> GameModKind {
4610        GameModKind::DifficultyIncrease
4611    }
4612    /// Bit value of [`FlashlightMania`]
4613    ///
4614    /// See <https://github.com/ppy/osu-api/wiki#mods>
4615    pub const fn bits() -> u32 {
4616        1024
4617    }
4618}
4619impl AccuracyChallengeMania {
4620    /// The acronym of [`AccuracyChallengeMania`]
4621    pub const fn acronym() -> Acronym {
4622        unsafe { Acronym::from_str_unchecked("AC") }
4623    }
4624    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeMania`]
4625    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4626        unsafe {
4627            [
4628                Acronym::from_str_unchecked("EZ"),
4629                Acronym::from_str_unchecked("NF"),
4630                Acronym::from_str_unchecked("PF"),
4631                Acronym::from_str_unchecked("CN"),
4632            ]
4633        }
4634        .into_iter()
4635    }
4636    /// The description of [`AccuracyChallengeMania`]
4637    pub const fn description() -> &'static str {
4638        "Fail if your accuracy drops too low!"
4639    }
4640    /// The [`GameModKind`] of [`AccuracyChallengeMania`]
4641    pub const fn kind() -> GameModKind {
4642        GameModKind::DifficultyIncrease
4643    }
4644}
4645impl RandomMania {
4646    /// The acronym of [`RandomMania`]
4647    pub const fn acronym() -> Acronym {
4648        unsafe { Acronym::from_str_unchecked("RD") }
4649    }
4650    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomMania`]
4651    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4652        [].into_iter()
4653    }
4654    /// The description of [`RandomMania`]
4655    pub const fn description() -> &'static str {
4656        "Shuffle around the keys!"
4657    }
4658    /// The [`GameModKind`] of [`RandomMania`]
4659    pub const fn kind() -> GameModKind {
4660        GameModKind::Conversion
4661    }
4662    /// Bit value of [`RandomMania`]
4663    ///
4664    /// See <https://github.com/ppy/osu-api/wiki#mods>
4665    pub const fn bits() -> u32 {
4666        2097152
4667    }
4668}
4669impl DualStagesMania {
4670    /// The acronym of [`DualStagesMania`]
4671    pub const fn acronym() -> Acronym {
4672        unsafe { Acronym::from_str_unchecked("DS") }
4673    }
4674    /// Iterator of [`Acronym`] for mods that are incompatible with [`DualStagesMania`]
4675    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4676        [].into_iter()
4677    }
4678    /// The description of [`DualStagesMania`]
4679    pub const fn description() -> &'static str {
4680        "Double the stages, double the fun!"
4681    }
4682    /// The [`GameModKind`] of [`DualStagesMania`]
4683    pub const fn kind() -> GameModKind {
4684        GameModKind::Conversion
4685    }
4686    /// Bit value of [`DualStagesMania`]
4687    ///
4688    /// See <https://github.com/ppy/osu-api/wiki#mods>
4689    pub const fn bits() -> u32 {
4690        33554432
4691    }
4692}
4693impl MirrorMania {
4694    /// The acronym of [`MirrorMania`]
4695    pub const fn acronym() -> Acronym {
4696        unsafe { Acronym::from_str_unchecked("MR") }
4697    }
4698    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorMania`]
4699    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4700        [].into_iter()
4701    }
4702    /// The description of [`MirrorMania`]
4703    pub const fn description() -> &'static str {
4704        "Notes are flipped horizontally."
4705    }
4706    /// The [`GameModKind`] of [`MirrorMania`]
4707    pub const fn kind() -> GameModKind {
4708        GameModKind::Conversion
4709    }
4710    /// Bit value of [`MirrorMania`]
4711    ///
4712    /// See <https://github.com/ppy/osu-api/wiki#mods>
4713    pub const fn bits() -> u32 {
4714        1073741824
4715    }
4716}
4717impl DifficultyAdjustMania {
4718    /// The acronym of [`DifficultyAdjustMania`]
4719    pub const fn acronym() -> Acronym {
4720        unsafe { Acronym::from_str_unchecked("DA") }
4721    }
4722    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustMania`]
4723    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4724        unsafe {
4725            [
4726                Acronym::from_str_unchecked("EZ"),
4727                Acronym::from_str_unchecked("HR"),
4728            ]
4729        }
4730        .into_iter()
4731    }
4732    /// The description of [`DifficultyAdjustMania`]
4733    pub const fn description() -> &'static str {
4734        "Override a beatmap's difficulty settings."
4735    }
4736    /// The [`GameModKind`] of [`DifficultyAdjustMania`]
4737    pub const fn kind() -> GameModKind {
4738        GameModKind::Conversion
4739    }
4740}
4741impl ClassicMania {
4742    /// The acronym of [`ClassicMania`]
4743    pub const fn acronym() -> Acronym {
4744        unsafe { Acronym::from_str_unchecked("CL") }
4745    }
4746    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicMania`]
4747    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4748        [].into_iter()
4749    }
4750    /// The description of [`ClassicMania`]
4751    pub const fn description() -> &'static str {
4752        "Feeling nostalgic?"
4753    }
4754    /// The [`GameModKind`] of [`ClassicMania`]
4755    pub const fn kind() -> GameModKind {
4756        GameModKind::Conversion
4757    }
4758}
4759impl InvertMania {
4760    /// The acronym of [`InvertMania`]
4761    pub const fn acronym() -> Acronym {
4762        unsafe { Acronym::from_str_unchecked("IN") }
4763    }
4764    /// Iterator of [`Acronym`] for mods that are incompatible with [`InvertMania`]
4765    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4766        unsafe { [Acronym::from_str_unchecked("HO")] }.into_iter()
4767    }
4768    /// The description of [`InvertMania`]
4769    pub const fn description() -> &'static str {
4770        "Hold the keys. To the beat."
4771    }
4772    /// The [`GameModKind`] of [`InvertMania`]
4773    pub const fn kind() -> GameModKind {
4774        GameModKind::Conversion
4775    }
4776}
4777impl ConstantSpeedMania {
4778    /// The acronym of [`ConstantSpeedMania`]
4779    pub const fn acronym() -> Acronym {
4780        unsafe { Acronym::from_str_unchecked("CS") }
4781    }
4782    /// Iterator of [`Acronym`] for mods that are incompatible with [`ConstantSpeedMania`]
4783    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4784        [].into_iter()
4785    }
4786    /// The description of [`ConstantSpeedMania`]
4787    pub const fn description() -> &'static str {
4788        "No more tricky speed changes!"
4789    }
4790    /// The [`GameModKind`] of [`ConstantSpeedMania`]
4791    pub const fn kind() -> GameModKind {
4792        GameModKind::Conversion
4793    }
4794}
4795impl HoldOffMania {
4796    /// The acronym of [`HoldOffMania`]
4797    pub const fn acronym() -> Acronym {
4798        unsafe { Acronym::from_str_unchecked("HO") }
4799    }
4800    /// Iterator of [`Acronym`] for mods that are incompatible with [`HoldOffMania`]
4801    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4802        unsafe {
4803            [
4804                Acronym::from_str_unchecked("NR"),
4805                Acronym::from_str_unchecked("IN"),
4806            ]
4807        }
4808        .into_iter()
4809    }
4810    /// The description of [`HoldOffMania`]
4811    pub const fn description() -> &'static str {
4812        "Replaces all hold notes with normal notes."
4813    }
4814    /// The [`GameModKind`] of [`HoldOffMania`]
4815    pub const fn kind() -> GameModKind {
4816        GameModKind::Conversion
4817    }
4818}
4819impl OneKeyMania {
4820    /// The acronym of [`OneKeyMania`]
4821    pub const fn acronym() -> Acronym {
4822        unsafe { Acronym::from_str_unchecked("1K") }
4823    }
4824    /// Iterator of [`Acronym`] for mods that are incompatible with [`OneKeyMania`]
4825    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4826        unsafe {
4827            [
4828                Acronym::from_str_unchecked("2K"),
4829                Acronym::from_str_unchecked("3K"),
4830                Acronym::from_str_unchecked("4K"),
4831                Acronym::from_str_unchecked("5K"),
4832                Acronym::from_str_unchecked("6K"),
4833                Acronym::from_str_unchecked("7K"),
4834                Acronym::from_str_unchecked("8K"),
4835                Acronym::from_str_unchecked("9K"),
4836                Acronym::from_str_unchecked("10K"),
4837            ]
4838        }
4839        .into_iter()
4840    }
4841    /// The description of [`OneKeyMania`]
4842    pub const fn description() -> &'static str {
4843        "Play with one key."
4844    }
4845    /// The [`GameModKind`] of [`OneKeyMania`]
4846    pub const fn kind() -> GameModKind {
4847        GameModKind::Conversion
4848    }
4849    /// Bit value of [`OneKeyMania`]
4850    ///
4851    /// See <https://github.com/ppy/osu-api/wiki#mods>
4852    pub const fn bits() -> u32 {
4853        67108864
4854    }
4855}
4856impl TwoKeysMania {
4857    /// The acronym of [`TwoKeysMania`]
4858    pub const fn acronym() -> Acronym {
4859        unsafe { Acronym::from_str_unchecked("2K") }
4860    }
4861    /// Iterator of [`Acronym`] for mods that are incompatible with [`TwoKeysMania`]
4862    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4863        unsafe {
4864            [
4865                Acronym::from_str_unchecked("1K"),
4866                Acronym::from_str_unchecked("3K"),
4867                Acronym::from_str_unchecked("4K"),
4868                Acronym::from_str_unchecked("5K"),
4869                Acronym::from_str_unchecked("6K"),
4870                Acronym::from_str_unchecked("7K"),
4871                Acronym::from_str_unchecked("8K"),
4872                Acronym::from_str_unchecked("9K"),
4873                Acronym::from_str_unchecked("10K"),
4874            ]
4875        }
4876        .into_iter()
4877    }
4878    /// The description of [`TwoKeysMania`]
4879    pub const fn description() -> &'static str {
4880        "Play with two keys."
4881    }
4882    /// The [`GameModKind`] of [`TwoKeysMania`]
4883    pub const fn kind() -> GameModKind {
4884        GameModKind::Conversion
4885    }
4886    /// Bit value of [`TwoKeysMania`]
4887    ///
4888    /// See <https://github.com/ppy/osu-api/wiki#mods>
4889    pub const fn bits() -> u32 {
4890        268435456
4891    }
4892}
4893impl ThreeKeysMania {
4894    /// The acronym of [`ThreeKeysMania`]
4895    pub const fn acronym() -> Acronym {
4896        unsafe { Acronym::from_str_unchecked("3K") }
4897    }
4898    /// Iterator of [`Acronym`] for mods that are incompatible with [`ThreeKeysMania`]
4899    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4900        unsafe {
4901            [
4902                Acronym::from_str_unchecked("1K"),
4903                Acronym::from_str_unchecked("2K"),
4904                Acronym::from_str_unchecked("4K"),
4905                Acronym::from_str_unchecked("5K"),
4906                Acronym::from_str_unchecked("6K"),
4907                Acronym::from_str_unchecked("7K"),
4908                Acronym::from_str_unchecked("8K"),
4909                Acronym::from_str_unchecked("9K"),
4910                Acronym::from_str_unchecked("10K"),
4911            ]
4912        }
4913        .into_iter()
4914    }
4915    /// The description of [`ThreeKeysMania`]
4916    pub const fn description() -> &'static str {
4917        "Play with three keys."
4918    }
4919    /// The [`GameModKind`] of [`ThreeKeysMania`]
4920    pub const fn kind() -> GameModKind {
4921        GameModKind::Conversion
4922    }
4923    /// Bit value of [`ThreeKeysMania`]
4924    ///
4925    /// See <https://github.com/ppy/osu-api/wiki#mods>
4926    pub const fn bits() -> u32 {
4927        134217728
4928    }
4929}
4930impl FourKeysMania {
4931    /// The acronym of [`FourKeysMania`]
4932    pub const fn acronym() -> Acronym {
4933        unsafe { Acronym::from_str_unchecked("4K") }
4934    }
4935    /// Iterator of [`Acronym`] for mods that are incompatible with [`FourKeysMania`]
4936    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4937        unsafe {
4938            [
4939                Acronym::from_str_unchecked("1K"),
4940                Acronym::from_str_unchecked("2K"),
4941                Acronym::from_str_unchecked("3K"),
4942                Acronym::from_str_unchecked("5K"),
4943                Acronym::from_str_unchecked("6K"),
4944                Acronym::from_str_unchecked("7K"),
4945                Acronym::from_str_unchecked("8K"),
4946                Acronym::from_str_unchecked("9K"),
4947                Acronym::from_str_unchecked("10K"),
4948            ]
4949        }
4950        .into_iter()
4951    }
4952    /// The description of [`FourKeysMania`]
4953    pub const fn description() -> &'static str {
4954        "Play with four keys."
4955    }
4956    /// The [`GameModKind`] of [`FourKeysMania`]
4957    pub const fn kind() -> GameModKind {
4958        GameModKind::Conversion
4959    }
4960    /// Bit value of [`FourKeysMania`]
4961    ///
4962    /// See <https://github.com/ppy/osu-api/wiki#mods>
4963    pub const fn bits() -> u32 {
4964        32768
4965    }
4966}
4967impl FiveKeysMania {
4968    /// The acronym of [`FiveKeysMania`]
4969    pub const fn acronym() -> Acronym {
4970        unsafe { Acronym::from_str_unchecked("5K") }
4971    }
4972    /// Iterator of [`Acronym`] for mods that are incompatible with [`FiveKeysMania`]
4973    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4974        unsafe {
4975            [
4976                Acronym::from_str_unchecked("1K"),
4977                Acronym::from_str_unchecked("2K"),
4978                Acronym::from_str_unchecked("3K"),
4979                Acronym::from_str_unchecked("4K"),
4980                Acronym::from_str_unchecked("6K"),
4981                Acronym::from_str_unchecked("7K"),
4982                Acronym::from_str_unchecked("8K"),
4983                Acronym::from_str_unchecked("9K"),
4984                Acronym::from_str_unchecked("10K"),
4985            ]
4986        }
4987        .into_iter()
4988    }
4989    /// The description of [`FiveKeysMania`]
4990    pub const fn description() -> &'static str {
4991        "Play with five keys."
4992    }
4993    /// The [`GameModKind`] of [`FiveKeysMania`]
4994    pub const fn kind() -> GameModKind {
4995        GameModKind::Conversion
4996    }
4997    /// Bit value of [`FiveKeysMania`]
4998    ///
4999    /// See <https://github.com/ppy/osu-api/wiki#mods>
5000    pub const fn bits() -> u32 {
5001        65536
5002    }
5003}
5004impl SixKeysMania {
5005    /// The acronym of [`SixKeysMania`]
5006    pub const fn acronym() -> Acronym {
5007        unsafe { Acronym::from_str_unchecked("6K") }
5008    }
5009    /// Iterator of [`Acronym`] for mods that are incompatible with [`SixKeysMania`]
5010    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5011        unsafe {
5012            [
5013                Acronym::from_str_unchecked("1K"),
5014                Acronym::from_str_unchecked("2K"),
5015                Acronym::from_str_unchecked("3K"),
5016                Acronym::from_str_unchecked("4K"),
5017                Acronym::from_str_unchecked("5K"),
5018                Acronym::from_str_unchecked("7K"),
5019                Acronym::from_str_unchecked("8K"),
5020                Acronym::from_str_unchecked("9K"),
5021                Acronym::from_str_unchecked("10K"),
5022            ]
5023        }
5024        .into_iter()
5025    }
5026    /// The description of [`SixKeysMania`]
5027    pub const fn description() -> &'static str {
5028        "Play with six keys."
5029    }
5030    /// The [`GameModKind`] of [`SixKeysMania`]
5031    pub const fn kind() -> GameModKind {
5032        GameModKind::Conversion
5033    }
5034    /// Bit value of [`SixKeysMania`]
5035    ///
5036    /// See <https://github.com/ppy/osu-api/wiki#mods>
5037    pub const fn bits() -> u32 {
5038        131072
5039    }
5040}
5041impl SevenKeysMania {
5042    /// The acronym of [`SevenKeysMania`]
5043    pub const fn acronym() -> Acronym {
5044        unsafe { Acronym::from_str_unchecked("7K") }
5045    }
5046    /// Iterator of [`Acronym`] for mods that are incompatible with [`SevenKeysMania`]
5047    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5048        unsafe {
5049            [
5050                Acronym::from_str_unchecked("1K"),
5051                Acronym::from_str_unchecked("2K"),
5052                Acronym::from_str_unchecked("3K"),
5053                Acronym::from_str_unchecked("4K"),
5054                Acronym::from_str_unchecked("5K"),
5055                Acronym::from_str_unchecked("6K"),
5056                Acronym::from_str_unchecked("8K"),
5057                Acronym::from_str_unchecked("9K"),
5058                Acronym::from_str_unchecked("10K"),
5059            ]
5060        }
5061        .into_iter()
5062    }
5063    /// The description of [`SevenKeysMania`]
5064    pub const fn description() -> &'static str {
5065        "Play with seven keys."
5066    }
5067    /// The [`GameModKind`] of [`SevenKeysMania`]
5068    pub const fn kind() -> GameModKind {
5069        GameModKind::Conversion
5070    }
5071    /// Bit value of [`SevenKeysMania`]
5072    ///
5073    /// See <https://github.com/ppy/osu-api/wiki#mods>
5074    pub const fn bits() -> u32 {
5075        262144
5076    }
5077}
5078impl EightKeysMania {
5079    /// The acronym of [`EightKeysMania`]
5080    pub const fn acronym() -> Acronym {
5081        unsafe { Acronym::from_str_unchecked("8K") }
5082    }
5083    /// Iterator of [`Acronym`] for mods that are incompatible with [`EightKeysMania`]
5084    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5085        unsafe {
5086            [
5087                Acronym::from_str_unchecked("1K"),
5088                Acronym::from_str_unchecked("2K"),
5089                Acronym::from_str_unchecked("3K"),
5090                Acronym::from_str_unchecked("4K"),
5091                Acronym::from_str_unchecked("5K"),
5092                Acronym::from_str_unchecked("6K"),
5093                Acronym::from_str_unchecked("7K"),
5094                Acronym::from_str_unchecked("9K"),
5095                Acronym::from_str_unchecked("10K"),
5096            ]
5097        }
5098        .into_iter()
5099    }
5100    /// The description of [`EightKeysMania`]
5101    pub const fn description() -> &'static str {
5102        "Play with eight keys."
5103    }
5104    /// The [`GameModKind`] of [`EightKeysMania`]
5105    pub const fn kind() -> GameModKind {
5106        GameModKind::Conversion
5107    }
5108    /// Bit value of [`EightKeysMania`]
5109    ///
5110    /// See <https://github.com/ppy/osu-api/wiki#mods>
5111    pub const fn bits() -> u32 {
5112        524288
5113    }
5114}
5115impl NineKeysMania {
5116    /// The acronym of [`NineKeysMania`]
5117    pub const fn acronym() -> Acronym {
5118        unsafe { Acronym::from_str_unchecked("9K") }
5119    }
5120    /// Iterator of [`Acronym`] for mods that are incompatible with [`NineKeysMania`]
5121    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5122        unsafe {
5123            [
5124                Acronym::from_str_unchecked("1K"),
5125                Acronym::from_str_unchecked("2K"),
5126                Acronym::from_str_unchecked("3K"),
5127                Acronym::from_str_unchecked("4K"),
5128                Acronym::from_str_unchecked("5K"),
5129                Acronym::from_str_unchecked("6K"),
5130                Acronym::from_str_unchecked("7K"),
5131                Acronym::from_str_unchecked("8K"),
5132                Acronym::from_str_unchecked("10K"),
5133            ]
5134        }
5135        .into_iter()
5136    }
5137    /// The description of [`NineKeysMania`]
5138    pub const fn description() -> &'static str {
5139        "Play with nine keys."
5140    }
5141    /// The [`GameModKind`] of [`NineKeysMania`]
5142    pub const fn kind() -> GameModKind {
5143        GameModKind::Conversion
5144    }
5145    /// Bit value of [`NineKeysMania`]
5146    ///
5147    /// See <https://github.com/ppy/osu-api/wiki#mods>
5148    pub const fn bits() -> u32 {
5149        16777216
5150    }
5151}
5152impl TenKeysMania {
5153    /// The acronym of [`TenKeysMania`]
5154    pub const fn acronym() -> Acronym {
5155        unsafe { Acronym::from_str_unchecked("10K") }
5156    }
5157    /// Iterator of [`Acronym`] for mods that are incompatible with [`TenKeysMania`]
5158    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5159        unsafe {
5160            [
5161                Acronym::from_str_unchecked("1K"),
5162                Acronym::from_str_unchecked("2K"),
5163                Acronym::from_str_unchecked("3K"),
5164                Acronym::from_str_unchecked("4K"),
5165                Acronym::from_str_unchecked("5K"),
5166                Acronym::from_str_unchecked("6K"),
5167                Acronym::from_str_unchecked("7K"),
5168                Acronym::from_str_unchecked("8K"),
5169                Acronym::from_str_unchecked("9K"),
5170            ]
5171        }
5172        .into_iter()
5173    }
5174    /// The description of [`TenKeysMania`]
5175    pub const fn description() -> &'static str {
5176        "Play with ten keys."
5177    }
5178    /// The [`GameModKind`] of [`TenKeysMania`]
5179    pub const fn kind() -> GameModKind {
5180        GameModKind::Conversion
5181    }
5182}
5183impl AutoplayMania {
5184    /// The acronym of [`AutoplayMania`]
5185    pub const fn acronym() -> Acronym {
5186        unsafe { Acronym::from_str_unchecked("AT") }
5187    }
5188    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayMania`]
5189    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5190        unsafe {
5191            [
5192                Acronym::from_str_unchecked("CN"),
5193                Acronym::from_str_unchecked("AS"),
5194            ]
5195        }
5196        .into_iter()
5197    }
5198    /// The description of [`AutoplayMania`]
5199    pub const fn description() -> &'static str {
5200        "Watch a perfect automated play through the song."
5201    }
5202    /// The [`GameModKind`] of [`AutoplayMania`]
5203    pub const fn kind() -> GameModKind {
5204        GameModKind::Automation
5205    }
5206    /// Bit value of [`AutoplayMania`]
5207    ///
5208    /// See <https://github.com/ppy/osu-api/wiki#mods>
5209    pub const fn bits() -> u32 {
5210        2048
5211    }
5212}
5213impl CinemaMania {
5214    /// The acronym of [`CinemaMania`]
5215    pub const fn acronym() -> Acronym {
5216        unsafe { Acronym::from_str_unchecked("CN") }
5217    }
5218    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaMania`]
5219    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5220        unsafe {
5221            [
5222                Acronym::from_str_unchecked("NF"),
5223                Acronym::from_str_unchecked("SD"),
5224                Acronym::from_str_unchecked("PF"),
5225                Acronym::from_str_unchecked("AC"),
5226                Acronym::from_str_unchecked("AT"),
5227                Acronym::from_str_unchecked("AS"),
5228            ]
5229        }
5230        .into_iter()
5231    }
5232    /// The description of [`CinemaMania`]
5233    pub const fn description() -> &'static str {
5234        "Watch the video without visual distractions."
5235    }
5236    /// The [`GameModKind`] of [`CinemaMania`]
5237    pub const fn kind() -> GameModKind {
5238        GameModKind::Automation
5239    }
5240    /// Bit value of [`CinemaMania`]
5241    ///
5242    /// See <https://github.com/ppy/osu-api/wiki#mods>
5243    pub const fn bits() -> u32 {
5244        4194304
5245    }
5246}
5247impl WindUpMania {
5248    /// The acronym of [`WindUpMania`]
5249    pub const fn acronym() -> Acronym {
5250        unsafe { Acronym::from_str_unchecked("WU") }
5251    }
5252    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpMania`]
5253    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5254        unsafe {
5255            [
5256                Acronym::from_str_unchecked("HT"),
5257                Acronym::from_str_unchecked("DC"),
5258                Acronym::from_str_unchecked("DT"),
5259                Acronym::from_str_unchecked("NC"),
5260                Acronym::from_str_unchecked("WD"),
5261                Acronym::from_str_unchecked("AS"),
5262            ]
5263        }
5264        .into_iter()
5265    }
5266    /// The description of [`WindUpMania`]
5267    pub const fn description() -> &'static str {
5268        "Can you keep up?"
5269    }
5270    /// The [`GameModKind`] of [`WindUpMania`]
5271    pub const fn kind() -> GameModKind {
5272        GameModKind::Fun
5273    }
5274}
5275impl WindDownMania {
5276    /// The acronym of [`WindDownMania`]
5277    pub const fn acronym() -> Acronym {
5278        unsafe { Acronym::from_str_unchecked("WD") }
5279    }
5280    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownMania`]
5281    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5282        unsafe {
5283            [
5284                Acronym::from_str_unchecked("HT"),
5285                Acronym::from_str_unchecked("DC"),
5286                Acronym::from_str_unchecked("DT"),
5287                Acronym::from_str_unchecked("NC"),
5288                Acronym::from_str_unchecked("WU"),
5289                Acronym::from_str_unchecked("AS"),
5290            ]
5291        }
5292        .into_iter()
5293    }
5294    /// The description of [`WindDownMania`]
5295    pub const fn description() -> &'static str {
5296        "Sloooow doooown..."
5297    }
5298    /// The [`GameModKind`] of [`WindDownMania`]
5299    pub const fn kind() -> GameModKind {
5300        GameModKind::Fun
5301    }
5302}
5303impl MutedMania {
5304    /// The acronym of [`MutedMania`]
5305    pub const fn acronym() -> Acronym {
5306        unsafe { Acronym::from_str_unchecked("MU") }
5307    }
5308    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedMania`]
5309    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5310        [].into_iter()
5311    }
5312    /// The description of [`MutedMania`]
5313    pub const fn description() -> &'static str {
5314        "Can you still feel the rhythm without music?"
5315    }
5316    /// The [`GameModKind`] of [`MutedMania`]
5317    pub const fn kind() -> GameModKind {
5318        GameModKind::Fun
5319    }
5320}
5321impl AdaptiveSpeedMania {
5322    /// The acronym of [`AdaptiveSpeedMania`]
5323    pub const fn acronym() -> Acronym {
5324        unsafe { Acronym::from_str_unchecked("AS") }
5325    }
5326    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedMania`]
5327    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5328        unsafe {
5329            [
5330                Acronym::from_str_unchecked("HT"),
5331                Acronym::from_str_unchecked("DC"),
5332                Acronym::from_str_unchecked("DT"),
5333                Acronym::from_str_unchecked("NC"),
5334                Acronym::from_str_unchecked("AT"),
5335                Acronym::from_str_unchecked("CN"),
5336                Acronym::from_str_unchecked("WU"),
5337                Acronym::from_str_unchecked("WD"),
5338            ]
5339        }
5340        .into_iter()
5341    }
5342    /// The description of [`AdaptiveSpeedMania`]
5343    pub const fn description() -> &'static str {
5344        "Let track speed adapt to you."
5345    }
5346    /// The [`GameModKind`] of [`AdaptiveSpeedMania`]
5347    pub const fn kind() -> GameModKind {
5348        GameModKind::Fun
5349    }
5350}
5351impl ScoreV2Mania {
5352    /// The acronym of [`ScoreV2Mania`]
5353    pub const fn acronym() -> Acronym {
5354        unsafe { Acronym::from_str_unchecked("SV2") }
5355    }
5356    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Mania`]
5357    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5358        [].into_iter()
5359    }
5360    /// The description of [`ScoreV2Mania`]
5361    pub const fn description() -> &'static str {
5362        "Score set on earlier osu! versions with the V2 scoring algorithm active."
5363    }
5364    /// The [`GameModKind`] of [`ScoreV2Mania`]
5365    pub const fn kind() -> GameModKind {
5366        GameModKind::System
5367    }
5368    /// Bit value of [`ScoreV2Mania`]
5369    ///
5370    /// See <https://github.com/ppy/osu-api/wiki#mods>
5371    pub const fn bits() -> u32 {
5372        536870912
5373    }
5374}
5375impl UnknownMod {
5376    /// The default [`Acronym`] for an unknown mod without specific
5377    /// acronym.
5378    pub const UNKNOWN_ACRONYM: Acronym = unsafe { Acronym::from_str_unchecked("??") };
5379    /// A custom [`Acronym`] for any unknown mod
5380    pub const fn acronym(self) -> Acronym {
5381        self.acronym
5382    }
5383    /// Returns an empty iterator
5384    pub const fn incompatible_mods() -> std::iter::Empty<Acronym> {
5385        std::iter::empty()
5386    }
5387    /// A custom description for any unknown mod
5388    pub const fn description() -> &'static str {
5389        "Some unknown mod"
5390    }
5391    /// A manually assigned [`GameModKind`] for any unknown mod
5392    pub const fn kind() -> GameModKind {
5393        GameModKind::System
5394    }
5395}
5396impl Default for UnknownMod {
5397    fn default() -> Self {
5398        Self {
5399            acronym: Self::UNKNOWN_ACRONYM,
5400        }
5401    }
5402}
5403pub(crate) mod intermode {
5404    /// A single game mod when the mode is ignored
5405    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
5406    #[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),)]
5407    #[non_exhaustive]
5408    pub enum GameModIntermode {
5409        AccuracyChallenge,
5410        AdaptiveSpeed,
5411        Alternate,
5412        ApproachDifferent,
5413        Autopilot,
5414        Autoplay,
5415        BarrelRoll,
5416        Blinds,
5417        Bloom,
5418        Bubbles,
5419        Cinema,
5420        Classic,
5421        ConstantSpeed,
5422        Cover,
5423        Daycore,
5424        Deflate,
5425        Depth,
5426        DifficultyAdjust,
5427        DoubleTime,
5428        DualStages,
5429        Easy,
5430        EightKeys,
5431        FadeIn,
5432        FiveKeys,
5433        Flashlight,
5434        FloatingFruits,
5435        FourKeys,
5436        FreezeFrame,
5437        Grow,
5438        HalfTime,
5439        HardRock,
5440        Hidden,
5441        HoldOff,
5442        Invert,
5443        Magnetised,
5444        Mirror,
5445        MovingFast,
5446        Muted,
5447        Nightcore,
5448        NineKeys,
5449        NoFail,
5450        NoRelease,
5451        NoScope,
5452        OneKey,
5453        Perfect,
5454        Random,
5455        Relax,
5456        Repel,
5457        ScoreV2,
5458        SevenKeys,
5459        SimplifiedRhythm,
5460        SingleTap,
5461        SixKeys,
5462        SpinIn,
5463        SpunOut,
5464        StrictTracking,
5465        SuddenDeath,
5466        Swap,
5467        Synesthesia,
5468        TargetPractice,
5469        TenKeys,
5470        ThreeKeys,
5471        TouchDevice,
5472        Traceable,
5473        Transform,
5474        TwoKeys,
5475        Wiggle,
5476        WindDown,
5477        WindUp,
5478        Unknown(super::UnknownMod),
5479    }
5480}
5481impl GameModIntermode {
5482    /// The [`Acronym`] of this [`GameModIntermode`]
5483    pub const fn acronym(&self) -> Acronym {
5484        unsafe {
5485            match self {
5486                Self::AccuracyChallenge => Acronym::from_str_unchecked("AC"),
5487                Self::AdaptiveSpeed => Acronym::from_str_unchecked("AS"),
5488                Self::Alternate => Acronym::from_str_unchecked("AL"),
5489                Self::ApproachDifferent => Acronym::from_str_unchecked("AD"),
5490                Self::Autopilot => Acronym::from_str_unchecked("AP"),
5491                Self::Autoplay => Acronym::from_str_unchecked("AT"),
5492                Self::BarrelRoll => Acronym::from_str_unchecked("BR"),
5493                Self::Blinds => Acronym::from_str_unchecked("BL"),
5494                Self::Bloom => Acronym::from_str_unchecked("BM"),
5495                Self::Bubbles => Acronym::from_str_unchecked("BU"),
5496                Self::Cinema => Acronym::from_str_unchecked("CN"),
5497                Self::Classic => Acronym::from_str_unchecked("CL"),
5498                Self::ConstantSpeed => Acronym::from_str_unchecked("CS"),
5499                Self::Cover => Acronym::from_str_unchecked("CO"),
5500                Self::Daycore => Acronym::from_str_unchecked("DC"),
5501                Self::Deflate => Acronym::from_str_unchecked("DF"),
5502                Self::Depth => Acronym::from_str_unchecked("DP"),
5503                Self::DifficultyAdjust => Acronym::from_str_unchecked("DA"),
5504                Self::DoubleTime => Acronym::from_str_unchecked("DT"),
5505                Self::DualStages => Acronym::from_str_unchecked("DS"),
5506                Self::Easy => Acronym::from_str_unchecked("EZ"),
5507                Self::EightKeys => Acronym::from_str_unchecked("8K"),
5508                Self::FadeIn => Acronym::from_str_unchecked("FI"),
5509                Self::FiveKeys => Acronym::from_str_unchecked("5K"),
5510                Self::Flashlight => Acronym::from_str_unchecked("FL"),
5511                Self::FloatingFruits => Acronym::from_str_unchecked("FF"),
5512                Self::FourKeys => Acronym::from_str_unchecked("4K"),
5513                Self::FreezeFrame => Acronym::from_str_unchecked("FR"),
5514                Self::Grow => Acronym::from_str_unchecked("GR"),
5515                Self::HalfTime => Acronym::from_str_unchecked("HT"),
5516                Self::HardRock => Acronym::from_str_unchecked("HR"),
5517                Self::Hidden => Acronym::from_str_unchecked("HD"),
5518                Self::HoldOff => Acronym::from_str_unchecked("HO"),
5519                Self::Invert => Acronym::from_str_unchecked("IN"),
5520                Self::Magnetised => Acronym::from_str_unchecked("MG"),
5521                Self::Mirror => Acronym::from_str_unchecked("MR"),
5522                Self::MovingFast => Acronym::from_str_unchecked("MF"),
5523                Self::Muted => Acronym::from_str_unchecked("MU"),
5524                Self::Nightcore => Acronym::from_str_unchecked("NC"),
5525                Self::NineKeys => Acronym::from_str_unchecked("9K"),
5526                Self::NoFail => Acronym::from_str_unchecked("NF"),
5527                Self::NoRelease => Acronym::from_str_unchecked("NR"),
5528                Self::NoScope => Acronym::from_str_unchecked("NS"),
5529                Self::OneKey => Acronym::from_str_unchecked("1K"),
5530                Self::Perfect => Acronym::from_str_unchecked("PF"),
5531                Self::Random => Acronym::from_str_unchecked("RD"),
5532                Self::Relax => Acronym::from_str_unchecked("RX"),
5533                Self::Repel => Acronym::from_str_unchecked("RP"),
5534                Self::ScoreV2 => Acronym::from_str_unchecked("SV2"),
5535                Self::SevenKeys => Acronym::from_str_unchecked("7K"),
5536                Self::SimplifiedRhythm => Acronym::from_str_unchecked("SR"),
5537                Self::SingleTap => Acronym::from_str_unchecked("SG"),
5538                Self::SixKeys => Acronym::from_str_unchecked("6K"),
5539                Self::SpinIn => Acronym::from_str_unchecked("SI"),
5540                Self::SpunOut => Acronym::from_str_unchecked("SO"),
5541                Self::StrictTracking => Acronym::from_str_unchecked("ST"),
5542                Self::SuddenDeath => Acronym::from_str_unchecked("SD"),
5543                Self::Swap => Acronym::from_str_unchecked("SW"),
5544                Self::Synesthesia => Acronym::from_str_unchecked("SY"),
5545                Self::TargetPractice => Acronym::from_str_unchecked("TP"),
5546                Self::TenKeys => Acronym::from_str_unchecked("10K"),
5547                Self::ThreeKeys => Acronym::from_str_unchecked("3K"),
5548                Self::TouchDevice => Acronym::from_str_unchecked("TD"),
5549                Self::Traceable => Acronym::from_str_unchecked("TC"),
5550                Self::Transform => Acronym::from_str_unchecked("TR"),
5551                Self::TwoKeys => Acronym::from_str_unchecked("2K"),
5552                Self::Wiggle => Acronym::from_str_unchecked("WG"),
5553                Self::WindDown => Acronym::from_str_unchecked("WD"),
5554                Self::WindUp => Acronym::from_str_unchecked("WU"),
5555                Self::Unknown(m) => m.acronym(),
5556            }
5557        }
5558    }
5559    /// Bit value of the [`GameModIntermode`]
5560    ///
5561    /// See <https://github.com/ppy/osu-api/wiki#mods>
5562    pub const fn bits(self) -> Option<u32> {
5563        match self {
5564            Self::AccuracyChallenge => None,
5565            Self::AdaptiveSpeed => None,
5566            Self::Alternate => None,
5567            Self::ApproachDifferent => None,
5568            Self::Autopilot => Some(8192),
5569            Self::Autoplay => Some(2048),
5570            Self::BarrelRoll => None,
5571            Self::Blinds => None,
5572            Self::Bloom => None,
5573            Self::Bubbles => None,
5574            Self::Cinema => Some(4194304),
5575            Self::Classic => None,
5576            Self::ConstantSpeed => None,
5577            Self::Cover => None,
5578            Self::Daycore => None,
5579            Self::Deflate => None,
5580            Self::Depth => None,
5581            Self::DifficultyAdjust => None,
5582            Self::DoubleTime => Some(64),
5583            Self::DualStages => Some(33554432),
5584            Self::Easy => Some(2),
5585            Self::EightKeys => Some(524288),
5586            Self::FadeIn => Some(1048576),
5587            Self::FiveKeys => Some(65536),
5588            Self::Flashlight => Some(1024),
5589            Self::FloatingFruits => None,
5590            Self::FourKeys => Some(32768),
5591            Self::FreezeFrame => None,
5592            Self::Grow => None,
5593            Self::HalfTime => Some(256),
5594            Self::HardRock => Some(16),
5595            Self::Hidden => Some(8),
5596            Self::HoldOff => None,
5597            Self::Invert => None,
5598            Self::Magnetised => None,
5599            Self::Mirror => Some(1073741824),
5600            Self::MovingFast => None,
5601            Self::Muted => None,
5602            Self::Nightcore => Some(576),
5603            Self::NineKeys => Some(16777216),
5604            Self::NoFail => Some(1),
5605            Self::NoRelease => None,
5606            Self::NoScope => None,
5607            Self::OneKey => Some(67108864),
5608            Self::Perfect => Some(16416),
5609            Self::Random => Some(2097152),
5610            Self::Relax => Some(128),
5611            Self::Repel => None,
5612            Self::ScoreV2 => Some(536870912),
5613            Self::SevenKeys => Some(262144),
5614            Self::SimplifiedRhythm => None,
5615            Self::SingleTap => None,
5616            Self::SixKeys => Some(131072),
5617            Self::SpinIn => None,
5618            Self::SpunOut => Some(4096),
5619            Self::StrictTracking => None,
5620            Self::SuddenDeath => Some(32),
5621            Self::Swap => None,
5622            Self::Synesthesia => None,
5623            Self::TargetPractice => Some(8388608),
5624            Self::TenKeys => None,
5625            Self::ThreeKeys => Some(134217728),
5626            Self::TouchDevice => Some(4),
5627            Self::Traceable => None,
5628            Self::Transform => None,
5629            Self::TwoKeys => Some(268435456),
5630            Self::Wiggle => None,
5631            Self::WindDown => None,
5632            Self::WindUp => None,
5633            Self::Unknown(_) => None,
5634        }
5635    }
5636    /// The [`GameModKind`] of this [`GameModIntermode`]
5637    pub const fn kind(&self) -> GameModKind {
5638        match self {
5639            Self::AccuracyChallenge => GameModKind::DifficultyIncrease,
5640            Self::AdaptiveSpeed => GameModKind::Fun,
5641            Self::Alternate => GameModKind::Conversion,
5642            Self::ApproachDifferent => GameModKind::Fun,
5643            Self::Autopilot => GameModKind::Automation,
5644            Self::Autoplay => GameModKind::Automation,
5645            Self::BarrelRoll => GameModKind::Fun,
5646            Self::Blinds => GameModKind::DifficultyIncrease,
5647            Self::Bloom => GameModKind::Fun,
5648            Self::Bubbles => GameModKind::Fun,
5649            Self::Cinema => GameModKind::Automation,
5650            Self::Classic => GameModKind::Conversion,
5651            Self::ConstantSpeed => GameModKind::Conversion,
5652            Self::Cover => GameModKind::DifficultyIncrease,
5653            Self::Daycore => GameModKind::DifficultyReduction,
5654            Self::Deflate => GameModKind::Fun,
5655            Self::Depth => GameModKind::Fun,
5656            Self::DifficultyAdjust => GameModKind::Conversion,
5657            Self::DoubleTime => GameModKind::DifficultyIncrease,
5658            Self::DualStages => GameModKind::Conversion,
5659            Self::Easy => GameModKind::DifficultyReduction,
5660            Self::EightKeys => GameModKind::Conversion,
5661            Self::FadeIn => GameModKind::DifficultyIncrease,
5662            Self::FiveKeys => GameModKind::Conversion,
5663            Self::Flashlight => GameModKind::DifficultyIncrease,
5664            Self::FloatingFruits => GameModKind::Fun,
5665            Self::FourKeys => GameModKind::Conversion,
5666            Self::FreezeFrame => GameModKind::Fun,
5667            Self::Grow => GameModKind::Fun,
5668            Self::HalfTime => GameModKind::DifficultyReduction,
5669            Self::HardRock => GameModKind::DifficultyIncrease,
5670            Self::Hidden => GameModKind::DifficultyIncrease,
5671            Self::HoldOff => GameModKind::Conversion,
5672            Self::Invert => GameModKind::Conversion,
5673            Self::Magnetised => GameModKind::Fun,
5674            Self::Mirror => GameModKind::Conversion,
5675            Self::MovingFast => GameModKind::Fun,
5676            Self::Muted => GameModKind::Fun,
5677            Self::Nightcore => GameModKind::DifficultyIncrease,
5678            Self::NineKeys => GameModKind::Conversion,
5679            Self::NoFail => GameModKind::DifficultyReduction,
5680            Self::NoRelease => GameModKind::DifficultyReduction,
5681            Self::NoScope => GameModKind::Fun,
5682            Self::OneKey => GameModKind::Conversion,
5683            Self::Perfect => GameModKind::DifficultyIncrease,
5684            Self::Random => GameModKind::Conversion,
5685            Self::Relax => GameModKind::Automation,
5686            Self::Repel => GameModKind::Fun,
5687            Self::ScoreV2 => GameModKind::System,
5688            Self::SevenKeys => GameModKind::Conversion,
5689            Self::SimplifiedRhythm => GameModKind::DifficultyReduction,
5690            Self::SingleTap => GameModKind::Conversion,
5691            Self::SixKeys => GameModKind::Conversion,
5692            Self::SpinIn => GameModKind::Fun,
5693            Self::SpunOut => GameModKind::Automation,
5694            Self::StrictTracking => GameModKind::DifficultyIncrease,
5695            Self::SuddenDeath => GameModKind::DifficultyIncrease,
5696            Self::Swap => GameModKind::Conversion,
5697            Self::Synesthesia => GameModKind::Fun,
5698            Self::TargetPractice => GameModKind::Conversion,
5699            Self::TenKeys => GameModKind::Conversion,
5700            Self::ThreeKeys => GameModKind::Conversion,
5701            Self::TouchDevice => GameModKind::System,
5702            Self::Traceable => GameModKind::DifficultyIncrease,
5703            Self::Transform => GameModKind::Fun,
5704            Self::TwoKeys => GameModKind::Conversion,
5705            Self::Wiggle => GameModKind::Fun,
5706            Self::WindDown => GameModKind::Fun,
5707            Self::WindUp => GameModKind::Fun,
5708            Self::Unknown(_) => GameModKind::System,
5709        }
5710    }
5711    /// Parse an [`Acronym`] into a [`GameModIntermode`]
5712    pub fn from_acronym(acronym: Acronym) -> Self {
5713        match acronym.as_str() {
5714            "AC" => Self::AccuracyChallenge,
5715            "AS" => Self::AdaptiveSpeed,
5716            "AL" => Self::Alternate,
5717            "AD" => Self::ApproachDifferent,
5718            "AP" => Self::Autopilot,
5719            "AT" => Self::Autoplay,
5720            "BR" => Self::BarrelRoll,
5721            "BL" => Self::Blinds,
5722            "BM" => Self::Bloom,
5723            "BU" => Self::Bubbles,
5724            "CN" => Self::Cinema,
5725            "CL" => Self::Classic,
5726            "CS" => Self::ConstantSpeed,
5727            "CO" => Self::Cover,
5728            "DC" => Self::Daycore,
5729            "DF" => Self::Deflate,
5730            "DP" => Self::Depth,
5731            "DA" => Self::DifficultyAdjust,
5732            "DT" => Self::DoubleTime,
5733            "DS" => Self::DualStages,
5734            "EZ" => Self::Easy,
5735            "8K" => Self::EightKeys,
5736            "FI" => Self::FadeIn,
5737            "5K" => Self::FiveKeys,
5738            "FL" => Self::Flashlight,
5739            "FF" => Self::FloatingFruits,
5740            "4K" => Self::FourKeys,
5741            "FR" => Self::FreezeFrame,
5742            "GR" => Self::Grow,
5743            "HT" => Self::HalfTime,
5744            "HR" => Self::HardRock,
5745            "HD" => Self::Hidden,
5746            "HO" => Self::HoldOff,
5747            "IN" => Self::Invert,
5748            "MG" => Self::Magnetised,
5749            "MR" => Self::Mirror,
5750            "MF" => Self::MovingFast,
5751            "MU" => Self::Muted,
5752            "NC" => Self::Nightcore,
5753            "9K" => Self::NineKeys,
5754            "NF" => Self::NoFail,
5755            "NR" => Self::NoRelease,
5756            "NS" => Self::NoScope,
5757            "1K" => Self::OneKey,
5758            "PF" => Self::Perfect,
5759            "RD" => Self::Random,
5760            "RX" => Self::Relax,
5761            "RP" => Self::Repel,
5762            "SV2" => Self::ScoreV2,
5763            "7K" => Self::SevenKeys,
5764            "SR" => Self::SimplifiedRhythm,
5765            "SG" => Self::SingleTap,
5766            "6K" => Self::SixKeys,
5767            "SI" => Self::SpinIn,
5768            "SO" => Self::SpunOut,
5769            "ST" => Self::StrictTracking,
5770            "SD" => Self::SuddenDeath,
5771            "SW" => Self::Swap,
5772            "SY" => Self::Synesthesia,
5773            "TP" => Self::TargetPractice,
5774            "10K" => Self::TenKeys,
5775            "3K" => Self::ThreeKeys,
5776            "TD" => Self::TouchDevice,
5777            "TC" => Self::Traceable,
5778            "TR" => Self::Transform,
5779            "2K" => Self::TwoKeys,
5780            "WG" => Self::Wiggle,
5781            "WD" => Self::WindDown,
5782            "WU" => Self::WindUp,
5783            _ => Self::Unknown(UnknownMod { acronym }),
5784        }
5785    }
5786    /// Try to convert bitvalues into a [`GameModIntermode`]
5787    pub const fn try_from_bits(bits: u32) -> Option<Self> {
5788        match bits {
5789            8192 => Some(Self::Autopilot),
5790            2048 => Some(Self::Autoplay),
5791            4194304 => Some(Self::Cinema),
5792            64 => Some(Self::DoubleTime),
5793            33554432 => Some(Self::DualStages),
5794            2 => Some(Self::Easy),
5795            524288 => Some(Self::EightKeys),
5796            1048576 => Some(Self::FadeIn),
5797            65536 => Some(Self::FiveKeys),
5798            1024 => Some(Self::Flashlight),
5799            32768 => Some(Self::FourKeys),
5800            256 => Some(Self::HalfTime),
5801            16 => Some(Self::HardRock),
5802            8 => Some(Self::Hidden),
5803            1073741824 => Some(Self::Mirror),
5804            576 => Some(Self::Nightcore),
5805            16777216 => Some(Self::NineKeys),
5806            1 => Some(Self::NoFail),
5807            67108864 => Some(Self::OneKey),
5808            16416 => Some(Self::Perfect),
5809            2097152 => Some(Self::Random),
5810            128 => Some(Self::Relax),
5811            536870912 => Some(Self::ScoreV2),
5812            262144 => Some(Self::SevenKeys),
5813            131072 => Some(Self::SixKeys),
5814            4096 => Some(Self::SpunOut),
5815            32 => Some(Self::SuddenDeath),
5816            8388608 => Some(Self::TargetPractice),
5817            134217728 => Some(Self::ThreeKeys),
5818            4 => Some(Self::TouchDevice),
5819            268435456 => Some(Self::TwoKeys),
5820            _ => None,
5821        }
5822    }
5823    /// Convert a [`GameModIntermode`] into [`GameModSimple`]
5824    pub fn as_simple(&self) -> GameModSimple {
5825        GameModSimple {
5826            acronym: self.acronym(),
5827            settings: HashMap::new(),
5828        }
5829    }
5830}
5831impl From<GameModIntermode> for GameModSimple {
5832    fn from(gamemod: GameModIntermode) -> Self {
5833        gamemod.as_simple()
5834    }
5835}
5836impl PartialOrd for GameModIntermode {
5837    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
5838        Some(self.cmp(other))
5839    }
5840}
5841impl Ord for GameModIntermode {
5842    fn cmp(&self, other: &Self) -> Ordering {
5843        // <https://github.com/ppy/osu/blob/91bc23e39eb1048d7b75acf669bd46e9ef9a4f9e/osu.Game/Rulesets/Mods/ModExtensions.cs#L33-L35>
5844        self.kind()
5845            .cmp(&other.kind())
5846            .then_with(|| self.acronym().as_str().cmp(&other.acronym().as_str()))
5847    }
5848}
5849impl Display for GameModIntermode {
5850    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
5851        f.write_str(self.acronym().as_str())
5852    }
5853}
5854impl From<&GameModIntermode> for GameModIntermode {
5855    fn from(gamemod: &GameModIntermode) -> Self {
5856        *gamemod
5857    }
5858}
5859impl From<GameMod> for GameModIntermode {
5860    fn from(gamemod: GameMod) -> Self {
5861        gamemod.intermode()
5862    }
5863}
5864pub(crate) mod gamemod {
5865    use super::*;
5866    /// A single game mod
5867    #[derive(Clone, Debug, PartialEq)]
5868    #[cfg_attr(
5869        feature = "rkyv",
5870        derive(::rkyv::Archive, ::rkyv::Serialize, ::rkyv::Deserialize)
5871    )]
5872    #[non_exhaustive]
5873    pub enum GameMod {
5874        EasyOsu(EasyOsu),
5875        NoFailOsu(NoFailOsu),
5876        HalfTimeOsu(HalfTimeOsu),
5877        DaycoreOsu(DaycoreOsu),
5878        HardRockOsu(HardRockOsu),
5879        SuddenDeathOsu(SuddenDeathOsu),
5880        PerfectOsu(PerfectOsu),
5881        DoubleTimeOsu(DoubleTimeOsu),
5882        NightcoreOsu(NightcoreOsu),
5883        HiddenOsu(HiddenOsu),
5884        TraceableOsu(TraceableOsu),
5885        FlashlightOsu(FlashlightOsu),
5886        BlindsOsu(BlindsOsu),
5887        StrictTrackingOsu(StrictTrackingOsu),
5888        AccuracyChallengeOsu(AccuracyChallengeOsu),
5889        TargetPracticeOsu(TargetPracticeOsu),
5890        DifficultyAdjustOsu(DifficultyAdjustOsu),
5891        ClassicOsu(ClassicOsu),
5892        RandomOsu(RandomOsu),
5893        MirrorOsu(MirrorOsu),
5894        AlternateOsu(AlternateOsu),
5895        SingleTapOsu(SingleTapOsu),
5896        AutoplayOsu(AutoplayOsu),
5897        CinemaOsu(CinemaOsu),
5898        RelaxOsu(RelaxOsu),
5899        AutopilotOsu(AutopilotOsu),
5900        SpunOutOsu(SpunOutOsu),
5901        TransformOsu(TransformOsu),
5902        WiggleOsu(WiggleOsu),
5903        SpinInOsu(SpinInOsu),
5904        GrowOsu(GrowOsu),
5905        DeflateOsu(DeflateOsu),
5906        WindUpOsu(WindUpOsu),
5907        WindDownOsu(WindDownOsu),
5908        BarrelRollOsu(BarrelRollOsu),
5909        ApproachDifferentOsu(ApproachDifferentOsu),
5910        MutedOsu(MutedOsu),
5911        NoScopeOsu(NoScopeOsu),
5912        MagnetisedOsu(MagnetisedOsu),
5913        RepelOsu(RepelOsu),
5914        AdaptiveSpeedOsu(AdaptiveSpeedOsu),
5915        FreezeFrameOsu(FreezeFrameOsu),
5916        BubblesOsu(BubblesOsu),
5917        SynesthesiaOsu(SynesthesiaOsu),
5918        DepthOsu(DepthOsu),
5919        BloomOsu(BloomOsu),
5920        TouchDeviceOsu(TouchDeviceOsu),
5921        ScoreV2Osu(ScoreV2Osu),
5922        UnknownOsu(UnknownMod),
5923        EasyTaiko(EasyTaiko),
5924        NoFailTaiko(NoFailTaiko),
5925        HalfTimeTaiko(HalfTimeTaiko),
5926        DaycoreTaiko(DaycoreTaiko),
5927        SimplifiedRhythmTaiko(SimplifiedRhythmTaiko),
5928        HardRockTaiko(HardRockTaiko),
5929        SuddenDeathTaiko(SuddenDeathTaiko),
5930        PerfectTaiko(PerfectTaiko),
5931        DoubleTimeTaiko(DoubleTimeTaiko),
5932        NightcoreTaiko(NightcoreTaiko),
5933        HiddenTaiko(HiddenTaiko),
5934        FlashlightTaiko(FlashlightTaiko),
5935        AccuracyChallengeTaiko(AccuracyChallengeTaiko),
5936        RandomTaiko(RandomTaiko),
5937        DifficultyAdjustTaiko(DifficultyAdjustTaiko),
5938        ClassicTaiko(ClassicTaiko),
5939        SwapTaiko(SwapTaiko),
5940        SingleTapTaiko(SingleTapTaiko),
5941        ConstantSpeedTaiko(ConstantSpeedTaiko),
5942        AutoplayTaiko(AutoplayTaiko),
5943        CinemaTaiko(CinemaTaiko),
5944        RelaxTaiko(RelaxTaiko),
5945        WindUpTaiko(WindUpTaiko),
5946        WindDownTaiko(WindDownTaiko),
5947        MutedTaiko(MutedTaiko),
5948        AdaptiveSpeedTaiko(AdaptiveSpeedTaiko),
5949        ScoreV2Taiko(ScoreV2Taiko),
5950        UnknownTaiko(UnknownMod),
5951        EasyCatch(EasyCatch),
5952        NoFailCatch(NoFailCatch),
5953        HalfTimeCatch(HalfTimeCatch),
5954        DaycoreCatch(DaycoreCatch),
5955        HardRockCatch(HardRockCatch),
5956        SuddenDeathCatch(SuddenDeathCatch),
5957        PerfectCatch(PerfectCatch),
5958        DoubleTimeCatch(DoubleTimeCatch),
5959        NightcoreCatch(NightcoreCatch),
5960        HiddenCatch(HiddenCatch),
5961        FlashlightCatch(FlashlightCatch),
5962        AccuracyChallengeCatch(AccuracyChallengeCatch),
5963        DifficultyAdjustCatch(DifficultyAdjustCatch),
5964        ClassicCatch(ClassicCatch),
5965        MirrorCatch(MirrorCatch),
5966        AutoplayCatch(AutoplayCatch),
5967        CinemaCatch(CinemaCatch),
5968        RelaxCatch(RelaxCatch),
5969        WindUpCatch(WindUpCatch),
5970        WindDownCatch(WindDownCatch),
5971        FloatingFruitsCatch(FloatingFruitsCatch),
5972        MutedCatch(MutedCatch),
5973        NoScopeCatch(NoScopeCatch),
5974        MovingFastCatch(MovingFastCatch),
5975        ScoreV2Catch(ScoreV2Catch),
5976        UnknownCatch(UnknownMod),
5977        EasyMania(EasyMania),
5978        NoFailMania(NoFailMania),
5979        HalfTimeMania(HalfTimeMania),
5980        DaycoreMania(DaycoreMania),
5981        NoReleaseMania(NoReleaseMania),
5982        HardRockMania(HardRockMania),
5983        SuddenDeathMania(SuddenDeathMania),
5984        PerfectMania(PerfectMania),
5985        DoubleTimeMania(DoubleTimeMania),
5986        NightcoreMania(NightcoreMania),
5987        FadeInMania(FadeInMania),
5988        HiddenMania(HiddenMania),
5989        CoverMania(CoverMania),
5990        FlashlightMania(FlashlightMania),
5991        AccuracyChallengeMania(AccuracyChallengeMania),
5992        RandomMania(RandomMania),
5993        DualStagesMania(DualStagesMania),
5994        MirrorMania(MirrorMania),
5995        DifficultyAdjustMania(DifficultyAdjustMania),
5996        ClassicMania(ClassicMania),
5997        InvertMania(InvertMania),
5998        ConstantSpeedMania(ConstantSpeedMania),
5999        HoldOffMania(HoldOffMania),
6000        OneKeyMania(OneKeyMania),
6001        TwoKeysMania(TwoKeysMania),
6002        ThreeKeysMania(ThreeKeysMania),
6003        FourKeysMania(FourKeysMania),
6004        FiveKeysMania(FiveKeysMania),
6005        SixKeysMania(SixKeysMania),
6006        SevenKeysMania(SevenKeysMania),
6007        EightKeysMania(EightKeysMania),
6008        NineKeysMania(NineKeysMania),
6009        TenKeysMania(TenKeysMania),
6010        AutoplayMania(AutoplayMania),
6011        CinemaMania(CinemaMania),
6012        WindUpMania(WindUpMania),
6013        WindDownMania(WindDownMania),
6014        MutedMania(MutedMania),
6015        AdaptiveSpeedMania(AdaptiveSpeedMania),
6016        ScoreV2Mania(ScoreV2Mania),
6017        UnknownMania(UnknownMod),
6018    }
6019}
6020impl GameMod {
6021    /// Create a new [`GameMod`]
6022    pub fn new(acronym: &str, mode: GameMode) -> Self {
6023        match (acronym, mode) {
6024            ("EZ", GameMode::Osu) => Self::EasyOsu(Default::default()),
6025            ("NF", GameMode::Osu) => Self::NoFailOsu(Default::default()),
6026            ("HT", GameMode::Osu) => Self::HalfTimeOsu(Default::default()),
6027            ("DC", GameMode::Osu) => Self::DaycoreOsu(Default::default()),
6028            ("HR", GameMode::Osu) => Self::HardRockOsu(Default::default()),
6029            ("SD", GameMode::Osu) => Self::SuddenDeathOsu(Default::default()),
6030            ("PF", GameMode::Osu) => Self::PerfectOsu(Default::default()),
6031            ("DT", GameMode::Osu) => Self::DoubleTimeOsu(Default::default()),
6032            ("NC", GameMode::Osu) => Self::NightcoreOsu(Default::default()),
6033            ("HD", GameMode::Osu) => Self::HiddenOsu(Default::default()),
6034            ("TC", GameMode::Osu) => Self::TraceableOsu(Default::default()),
6035            ("FL", GameMode::Osu) => Self::FlashlightOsu(Default::default()),
6036            ("BL", GameMode::Osu) => Self::BlindsOsu(Default::default()),
6037            ("ST", GameMode::Osu) => Self::StrictTrackingOsu(Default::default()),
6038            ("AC", GameMode::Osu) => Self::AccuracyChallengeOsu(Default::default()),
6039            ("TP", GameMode::Osu) => Self::TargetPracticeOsu(Default::default()),
6040            ("DA", GameMode::Osu) => Self::DifficultyAdjustOsu(Default::default()),
6041            ("CL", GameMode::Osu) => Self::ClassicOsu(Default::default()),
6042            ("RD", GameMode::Osu) => Self::RandomOsu(Default::default()),
6043            ("MR", GameMode::Osu) => Self::MirrorOsu(Default::default()),
6044            ("AL", GameMode::Osu) => Self::AlternateOsu(Default::default()),
6045            ("SG", GameMode::Osu) => Self::SingleTapOsu(Default::default()),
6046            ("AT", GameMode::Osu) => Self::AutoplayOsu(Default::default()),
6047            ("CN", GameMode::Osu) => Self::CinemaOsu(Default::default()),
6048            ("RX", GameMode::Osu) => Self::RelaxOsu(Default::default()),
6049            ("AP", GameMode::Osu) => Self::AutopilotOsu(Default::default()),
6050            ("SO", GameMode::Osu) => Self::SpunOutOsu(Default::default()),
6051            ("TR", GameMode::Osu) => Self::TransformOsu(Default::default()),
6052            ("WG", GameMode::Osu) => Self::WiggleOsu(Default::default()),
6053            ("SI", GameMode::Osu) => Self::SpinInOsu(Default::default()),
6054            ("GR", GameMode::Osu) => Self::GrowOsu(Default::default()),
6055            ("DF", GameMode::Osu) => Self::DeflateOsu(Default::default()),
6056            ("WU", GameMode::Osu) => Self::WindUpOsu(Default::default()),
6057            ("WD", GameMode::Osu) => Self::WindDownOsu(Default::default()),
6058            ("BR", GameMode::Osu) => Self::BarrelRollOsu(Default::default()),
6059            ("AD", GameMode::Osu) => Self::ApproachDifferentOsu(Default::default()),
6060            ("MU", GameMode::Osu) => Self::MutedOsu(Default::default()),
6061            ("NS", GameMode::Osu) => Self::NoScopeOsu(Default::default()),
6062            ("MG", GameMode::Osu) => Self::MagnetisedOsu(Default::default()),
6063            ("RP", GameMode::Osu) => Self::RepelOsu(Default::default()),
6064            ("AS", GameMode::Osu) => Self::AdaptiveSpeedOsu(Default::default()),
6065            ("FR", GameMode::Osu) => Self::FreezeFrameOsu(Default::default()),
6066            ("BU", GameMode::Osu) => Self::BubblesOsu(Default::default()),
6067            ("SY", GameMode::Osu) => Self::SynesthesiaOsu(Default::default()),
6068            ("DP", GameMode::Osu) => Self::DepthOsu(Default::default()),
6069            ("BM", GameMode::Osu) => Self::BloomOsu(Default::default()),
6070            ("TD", GameMode::Osu) => Self::TouchDeviceOsu(Default::default()),
6071            ("SV2", GameMode::Osu) => Self::ScoreV2Osu(Default::default()),
6072            ("EZ", GameMode::Taiko) => Self::EasyTaiko(Default::default()),
6073            ("NF", GameMode::Taiko) => Self::NoFailTaiko(Default::default()),
6074            ("HT", GameMode::Taiko) => Self::HalfTimeTaiko(Default::default()),
6075            ("DC", GameMode::Taiko) => Self::DaycoreTaiko(Default::default()),
6076            ("SR", GameMode::Taiko) => Self::SimplifiedRhythmTaiko(Default::default()),
6077            ("HR", GameMode::Taiko) => Self::HardRockTaiko(Default::default()),
6078            ("SD", GameMode::Taiko) => Self::SuddenDeathTaiko(Default::default()),
6079            ("PF", GameMode::Taiko) => Self::PerfectTaiko(Default::default()),
6080            ("DT", GameMode::Taiko) => Self::DoubleTimeTaiko(Default::default()),
6081            ("NC", GameMode::Taiko) => Self::NightcoreTaiko(Default::default()),
6082            ("HD", GameMode::Taiko) => Self::HiddenTaiko(Default::default()),
6083            ("FL", GameMode::Taiko) => Self::FlashlightTaiko(Default::default()),
6084            ("AC", GameMode::Taiko) => Self::AccuracyChallengeTaiko(Default::default()),
6085            ("RD", GameMode::Taiko) => Self::RandomTaiko(Default::default()),
6086            ("DA", GameMode::Taiko) => Self::DifficultyAdjustTaiko(Default::default()),
6087            ("CL", GameMode::Taiko) => Self::ClassicTaiko(Default::default()),
6088            ("SW", GameMode::Taiko) => Self::SwapTaiko(Default::default()),
6089            ("SG", GameMode::Taiko) => Self::SingleTapTaiko(Default::default()),
6090            ("CS", GameMode::Taiko) => Self::ConstantSpeedTaiko(Default::default()),
6091            ("AT", GameMode::Taiko) => Self::AutoplayTaiko(Default::default()),
6092            ("CN", GameMode::Taiko) => Self::CinemaTaiko(Default::default()),
6093            ("RX", GameMode::Taiko) => Self::RelaxTaiko(Default::default()),
6094            ("WU", GameMode::Taiko) => Self::WindUpTaiko(Default::default()),
6095            ("WD", GameMode::Taiko) => Self::WindDownTaiko(Default::default()),
6096            ("MU", GameMode::Taiko) => Self::MutedTaiko(Default::default()),
6097            ("AS", GameMode::Taiko) => Self::AdaptiveSpeedTaiko(Default::default()),
6098            ("SV2", GameMode::Taiko) => Self::ScoreV2Taiko(Default::default()),
6099            ("EZ", GameMode::Catch) => Self::EasyCatch(Default::default()),
6100            ("NF", GameMode::Catch) => Self::NoFailCatch(Default::default()),
6101            ("HT", GameMode::Catch) => Self::HalfTimeCatch(Default::default()),
6102            ("DC", GameMode::Catch) => Self::DaycoreCatch(Default::default()),
6103            ("HR", GameMode::Catch) => Self::HardRockCatch(Default::default()),
6104            ("SD", GameMode::Catch) => Self::SuddenDeathCatch(Default::default()),
6105            ("PF", GameMode::Catch) => Self::PerfectCatch(Default::default()),
6106            ("DT", GameMode::Catch) => Self::DoubleTimeCatch(Default::default()),
6107            ("NC", GameMode::Catch) => Self::NightcoreCatch(Default::default()),
6108            ("HD", GameMode::Catch) => Self::HiddenCatch(Default::default()),
6109            ("FL", GameMode::Catch) => Self::FlashlightCatch(Default::default()),
6110            ("AC", GameMode::Catch) => Self::AccuracyChallengeCatch(Default::default()),
6111            ("DA", GameMode::Catch) => Self::DifficultyAdjustCatch(Default::default()),
6112            ("CL", GameMode::Catch) => Self::ClassicCatch(Default::default()),
6113            ("MR", GameMode::Catch) => Self::MirrorCatch(Default::default()),
6114            ("AT", GameMode::Catch) => Self::AutoplayCatch(Default::default()),
6115            ("CN", GameMode::Catch) => Self::CinemaCatch(Default::default()),
6116            ("RX", GameMode::Catch) => Self::RelaxCatch(Default::default()),
6117            ("WU", GameMode::Catch) => Self::WindUpCatch(Default::default()),
6118            ("WD", GameMode::Catch) => Self::WindDownCatch(Default::default()),
6119            ("FF", GameMode::Catch) => Self::FloatingFruitsCatch(Default::default()),
6120            ("MU", GameMode::Catch) => Self::MutedCatch(Default::default()),
6121            ("NS", GameMode::Catch) => Self::NoScopeCatch(Default::default()),
6122            ("MF", GameMode::Catch) => Self::MovingFastCatch(Default::default()),
6123            ("SV2", GameMode::Catch) => Self::ScoreV2Catch(Default::default()),
6124            ("EZ", GameMode::Mania) => Self::EasyMania(Default::default()),
6125            ("NF", GameMode::Mania) => Self::NoFailMania(Default::default()),
6126            ("HT", GameMode::Mania) => Self::HalfTimeMania(Default::default()),
6127            ("DC", GameMode::Mania) => Self::DaycoreMania(Default::default()),
6128            ("NR", GameMode::Mania) => Self::NoReleaseMania(Default::default()),
6129            ("HR", GameMode::Mania) => Self::HardRockMania(Default::default()),
6130            ("SD", GameMode::Mania) => Self::SuddenDeathMania(Default::default()),
6131            ("PF", GameMode::Mania) => Self::PerfectMania(Default::default()),
6132            ("DT", GameMode::Mania) => Self::DoubleTimeMania(Default::default()),
6133            ("NC", GameMode::Mania) => Self::NightcoreMania(Default::default()),
6134            ("FI", GameMode::Mania) => Self::FadeInMania(Default::default()),
6135            ("HD", GameMode::Mania) => Self::HiddenMania(Default::default()),
6136            ("CO", GameMode::Mania) => Self::CoverMania(Default::default()),
6137            ("FL", GameMode::Mania) => Self::FlashlightMania(Default::default()),
6138            ("AC", GameMode::Mania) => Self::AccuracyChallengeMania(Default::default()),
6139            ("RD", GameMode::Mania) => Self::RandomMania(Default::default()),
6140            ("DS", GameMode::Mania) => Self::DualStagesMania(Default::default()),
6141            ("MR", GameMode::Mania) => Self::MirrorMania(Default::default()),
6142            ("DA", GameMode::Mania) => Self::DifficultyAdjustMania(Default::default()),
6143            ("CL", GameMode::Mania) => Self::ClassicMania(Default::default()),
6144            ("IN", GameMode::Mania) => Self::InvertMania(Default::default()),
6145            ("CS", GameMode::Mania) => Self::ConstantSpeedMania(Default::default()),
6146            ("HO", GameMode::Mania) => Self::HoldOffMania(Default::default()),
6147            ("1K", GameMode::Mania) => Self::OneKeyMania(Default::default()),
6148            ("2K", GameMode::Mania) => Self::TwoKeysMania(Default::default()),
6149            ("3K", GameMode::Mania) => Self::ThreeKeysMania(Default::default()),
6150            ("4K", GameMode::Mania) => Self::FourKeysMania(Default::default()),
6151            ("5K", GameMode::Mania) => Self::FiveKeysMania(Default::default()),
6152            ("6K", GameMode::Mania) => Self::SixKeysMania(Default::default()),
6153            ("7K", GameMode::Mania) => Self::SevenKeysMania(Default::default()),
6154            ("8K", GameMode::Mania) => Self::EightKeysMania(Default::default()),
6155            ("9K", GameMode::Mania) => Self::NineKeysMania(Default::default()),
6156            ("10K", GameMode::Mania) => Self::TenKeysMania(Default::default()),
6157            ("AT", GameMode::Mania) => Self::AutoplayMania(Default::default()),
6158            ("CN", GameMode::Mania) => Self::CinemaMania(Default::default()),
6159            ("WU", GameMode::Mania) => Self::WindUpMania(Default::default()),
6160            ("WD", GameMode::Mania) => Self::WindDownMania(Default::default()),
6161            ("MU", GameMode::Mania) => Self::MutedMania(Default::default()),
6162            ("AS", GameMode::Mania) => Self::AdaptiveSpeedMania(Default::default()),
6163            ("SV2", GameMode::Mania) => Self::ScoreV2Mania(Default::default()),
6164            _ => {
6165                let acronym = <Acronym as std::str::FromStr>::from_str(acronym)
6166                    .unwrap_or(UnknownMod::UNKNOWN_ACRONYM);
6167                let unknown = UnknownMod { acronym };
6168                match mode {
6169                    GameMode::Osu => GameMod::UnknownOsu(unknown),
6170                    GameMode::Taiko => GameMod::UnknownTaiko(unknown),
6171                    GameMode::Catch => GameMod::UnknownCatch(unknown),
6172                    GameMode::Mania => GameMod::UnknownMania(unknown),
6173                }
6174            }
6175        }
6176    }
6177    /// The acronym of this [`GameMod`]
6178    pub const fn acronym(&self) -> Acronym {
6179        match self {
6180            Self::EasyOsu(_) => EasyOsu::acronym(),
6181            Self::NoFailOsu(_) => NoFailOsu::acronym(),
6182            Self::HalfTimeOsu(_) => HalfTimeOsu::acronym(),
6183            Self::DaycoreOsu(_) => DaycoreOsu::acronym(),
6184            Self::HardRockOsu(_) => HardRockOsu::acronym(),
6185            Self::SuddenDeathOsu(_) => SuddenDeathOsu::acronym(),
6186            Self::PerfectOsu(_) => PerfectOsu::acronym(),
6187            Self::DoubleTimeOsu(_) => DoubleTimeOsu::acronym(),
6188            Self::NightcoreOsu(_) => NightcoreOsu::acronym(),
6189            Self::HiddenOsu(_) => HiddenOsu::acronym(),
6190            Self::TraceableOsu(_) => TraceableOsu::acronym(),
6191            Self::FlashlightOsu(_) => FlashlightOsu::acronym(),
6192            Self::BlindsOsu(_) => BlindsOsu::acronym(),
6193            Self::StrictTrackingOsu(_) => StrictTrackingOsu::acronym(),
6194            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::acronym(),
6195            Self::TargetPracticeOsu(_) => TargetPracticeOsu::acronym(),
6196            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::acronym(),
6197            Self::ClassicOsu(_) => ClassicOsu::acronym(),
6198            Self::RandomOsu(_) => RandomOsu::acronym(),
6199            Self::MirrorOsu(_) => MirrorOsu::acronym(),
6200            Self::AlternateOsu(_) => AlternateOsu::acronym(),
6201            Self::SingleTapOsu(_) => SingleTapOsu::acronym(),
6202            Self::AutoplayOsu(_) => AutoplayOsu::acronym(),
6203            Self::CinemaOsu(_) => CinemaOsu::acronym(),
6204            Self::RelaxOsu(_) => RelaxOsu::acronym(),
6205            Self::AutopilotOsu(_) => AutopilotOsu::acronym(),
6206            Self::SpunOutOsu(_) => SpunOutOsu::acronym(),
6207            Self::TransformOsu(_) => TransformOsu::acronym(),
6208            Self::WiggleOsu(_) => WiggleOsu::acronym(),
6209            Self::SpinInOsu(_) => SpinInOsu::acronym(),
6210            Self::GrowOsu(_) => GrowOsu::acronym(),
6211            Self::DeflateOsu(_) => DeflateOsu::acronym(),
6212            Self::WindUpOsu(_) => WindUpOsu::acronym(),
6213            Self::WindDownOsu(_) => WindDownOsu::acronym(),
6214            Self::BarrelRollOsu(_) => BarrelRollOsu::acronym(),
6215            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::acronym(),
6216            Self::MutedOsu(_) => MutedOsu::acronym(),
6217            Self::NoScopeOsu(_) => NoScopeOsu::acronym(),
6218            Self::MagnetisedOsu(_) => MagnetisedOsu::acronym(),
6219            Self::RepelOsu(_) => RepelOsu::acronym(),
6220            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::acronym(),
6221            Self::FreezeFrameOsu(_) => FreezeFrameOsu::acronym(),
6222            Self::BubblesOsu(_) => BubblesOsu::acronym(),
6223            Self::SynesthesiaOsu(_) => SynesthesiaOsu::acronym(),
6224            Self::DepthOsu(_) => DepthOsu::acronym(),
6225            Self::BloomOsu(_) => BloomOsu::acronym(),
6226            Self::TouchDeviceOsu(_) => TouchDeviceOsu::acronym(),
6227            Self::ScoreV2Osu(_) => ScoreV2Osu::acronym(),
6228            Self::EasyTaiko(_) => EasyTaiko::acronym(),
6229            Self::NoFailTaiko(_) => NoFailTaiko::acronym(),
6230            Self::HalfTimeTaiko(_) => HalfTimeTaiko::acronym(),
6231            Self::DaycoreTaiko(_) => DaycoreTaiko::acronym(),
6232            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::acronym(),
6233            Self::HardRockTaiko(_) => HardRockTaiko::acronym(),
6234            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::acronym(),
6235            Self::PerfectTaiko(_) => PerfectTaiko::acronym(),
6236            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::acronym(),
6237            Self::NightcoreTaiko(_) => NightcoreTaiko::acronym(),
6238            Self::HiddenTaiko(_) => HiddenTaiko::acronym(),
6239            Self::FlashlightTaiko(_) => FlashlightTaiko::acronym(),
6240            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::acronym(),
6241            Self::RandomTaiko(_) => RandomTaiko::acronym(),
6242            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::acronym(),
6243            Self::ClassicTaiko(_) => ClassicTaiko::acronym(),
6244            Self::SwapTaiko(_) => SwapTaiko::acronym(),
6245            Self::SingleTapTaiko(_) => SingleTapTaiko::acronym(),
6246            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::acronym(),
6247            Self::AutoplayTaiko(_) => AutoplayTaiko::acronym(),
6248            Self::CinemaTaiko(_) => CinemaTaiko::acronym(),
6249            Self::RelaxTaiko(_) => RelaxTaiko::acronym(),
6250            Self::WindUpTaiko(_) => WindUpTaiko::acronym(),
6251            Self::WindDownTaiko(_) => WindDownTaiko::acronym(),
6252            Self::MutedTaiko(_) => MutedTaiko::acronym(),
6253            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::acronym(),
6254            Self::ScoreV2Taiko(_) => ScoreV2Taiko::acronym(),
6255            Self::EasyCatch(_) => EasyCatch::acronym(),
6256            Self::NoFailCatch(_) => NoFailCatch::acronym(),
6257            Self::HalfTimeCatch(_) => HalfTimeCatch::acronym(),
6258            Self::DaycoreCatch(_) => DaycoreCatch::acronym(),
6259            Self::HardRockCatch(_) => HardRockCatch::acronym(),
6260            Self::SuddenDeathCatch(_) => SuddenDeathCatch::acronym(),
6261            Self::PerfectCatch(_) => PerfectCatch::acronym(),
6262            Self::DoubleTimeCatch(_) => DoubleTimeCatch::acronym(),
6263            Self::NightcoreCatch(_) => NightcoreCatch::acronym(),
6264            Self::HiddenCatch(_) => HiddenCatch::acronym(),
6265            Self::FlashlightCatch(_) => FlashlightCatch::acronym(),
6266            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::acronym(),
6267            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::acronym(),
6268            Self::ClassicCatch(_) => ClassicCatch::acronym(),
6269            Self::MirrorCatch(_) => MirrorCatch::acronym(),
6270            Self::AutoplayCatch(_) => AutoplayCatch::acronym(),
6271            Self::CinemaCatch(_) => CinemaCatch::acronym(),
6272            Self::RelaxCatch(_) => RelaxCatch::acronym(),
6273            Self::WindUpCatch(_) => WindUpCatch::acronym(),
6274            Self::WindDownCatch(_) => WindDownCatch::acronym(),
6275            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::acronym(),
6276            Self::MutedCatch(_) => MutedCatch::acronym(),
6277            Self::NoScopeCatch(_) => NoScopeCatch::acronym(),
6278            Self::MovingFastCatch(_) => MovingFastCatch::acronym(),
6279            Self::ScoreV2Catch(_) => ScoreV2Catch::acronym(),
6280            Self::EasyMania(_) => EasyMania::acronym(),
6281            Self::NoFailMania(_) => NoFailMania::acronym(),
6282            Self::HalfTimeMania(_) => HalfTimeMania::acronym(),
6283            Self::DaycoreMania(_) => DaycoreMania::acronym(),
6284            Self::NoReleaseMania(_) => NoReleaseMania::acronym(),
6285            Self::HardRockMania(_) => HardRockMania::acronym(),
6286            Self::SuddenDeathMania(_) => SuddenDeathMania::acronym(),
6287            Self::PerfectMania(_) => PerfectMania::acronym(),
6288            Self::DoubleTimeMania(_) => DoubleTimeMania::acronym(),
6289            Self::NightcoreMania(_) => NightcoreMania::acronym(),
6290            Self::FadeInMania(_) => FadeInMania::acronym(),
6291            Self::HiddenMania(_) => HiddenMania::acronym(),
6292            Self::CoverMania(_) => CoverMania::acronym(),
6293            Self::FlashlightMania(_) => FlashlightMania::acronym(),
6294            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::acronym(),
6295            Self::RandomMania(_) => RandomMania::acronym(),
6296            Self::DualStagesMania(_) => DualStagesMania::acronym(),
6297            Self::MirrorMania(_) => MirrorMania::acronym(),
6298            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::acronym(),
6299            Self::ClassicMania(_) => ClassicMania::acronym(),
6300            Self::InvertMania(_) => InvertMania::acronym(),
6301            Self::ConstantSpeedMania(_) => ConstantSpeedMania::acronym(),
6302            Self::HoldOffMania(_) => HoldOffMania::acronym(),
6303            Self::OneKeyMania(_) => OneKeyMania::acronym(),
6304            Self::TwoKeysMania(_) => TwoKeysMania::acronym(),
6305            Self::ThreeKeysMania(_) => ThreeKeysMania::acronym(),
6306            Self::FourKeysMania(_) => FourKeysMania::acronym(),
6307            Self::FiveKeysMania(_) => FiveKeysMania::acronym(),
6308            Self::SixKeysMania(_) => SixKeysMania::acronym(),
6309            Self::SevenKeysMania(_) => SevenKeysMania::acronym(),
6310            Self::EightKeysMania(_) => EightKeysMania::acronym(),
6311            Self::NineKeysMania(_) => NineKeysMania::acronym(),
6312            Self::TenKeysMania(_) => TenKeysMania::acronym(),
6313            Self::AutoplayMania(_) => AutoplayMania::acronym(),
6314            Self::CinemaMania(_) => CinemaMania::acronym(),
6315            Self::WindUpMania(_) => WindUpMania::acronym(),
6316            Self::WindDownMania(_) => WindDownMania::acronym(),
6317            Self::MutedMania(_) => MutedMania::acronym(),
6318            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::acronym(),
6319            Self::ScoreV2Mania(_) => ScoreV2Mania::acronym(),
6320            Self::UnknownOsu(m)
6321            | Self::UnknownTaiko(m)
6322            | Self::UnknownCatch(m)
6323            | Self::UnknownMania(m) => m.acronym(),
6324        }
6325    }
6326    /// List of [`Acronym`] for mods that are incompatible with this [`GameMod`]
6327    pub fn incompatible_mods(&self) -> Box<[Acronym]> {
6328        match self {
6329            Self::EasyOsu(_) => EasyOsu::incompatible_mods().collect(),
6330            Self::NoFailOsu(_) => NoFailOsu::incompatible_mods().collect(),
6331            Self::HalfTimeOsu(_) => HalfTimeOsu::incompatible_mods().collect(),
6332            Self::DaycoreOsu(_) => DaycoreOsu::incompatible_mods().collect(),
6333            Self::HardRockOsu(_) => HardRockOsu::incompatible_mods().collect(),
6334            Self::SuddenDeathOsu(_) => SuddenDeathOsu::incompatible_mods().collect(),
6335            Self::PerfectOsu(_) => PerfectOsu::incompatible_mods().collect(),
6336            Self::DoubleTimeOsu(_) => DoubleTimeOsu::incompatible_mods().collect(),
6337            Self::NightcoreOsu(_) => NightcoreOsu::incompatible_mods().collect(),
6338            Self::HiddenOsu(_) => HiddenOsu::incompatible_mods().collect(),
6339            Self::TraceableOsu(_) => TraceableOsu::incompatible_mods().collect(),
6340            Self::FlashlightOsu(_) => FlashlightOsu::incompatible_mods().collect(),
6341            Self::BlindsOsu(_) => BlindsOsu::incompatible_mods().collect(),
6342            Self::StrictTrackingOsu(_) => StrictTrackingOsu::incompatible_mods().collect(),
6343            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::incompatible_mods().collect(),
6344            Self::TargetPracticeOsu(_) => TargetPracticeOsu::incompatible_mods().collect(),
6345            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::incompatible_mods().collect(),
6346            Self::ClassicOsu(_) => ClassicOsu::incompatible_mods().collect(),
6347            Self::RandomOsu(_) => RandomOsu::incompatible_mods().collect(),
6348            Self::MirrorOsu(_) => MirrorOsu::incompatible_mods().collect(),
6349            Self::AlternateOsu(_) => AlternateOsu::incompatible_mods().collect(),
6350            Self::SingleTapOsu(_) => SingleTapOsu::incompatible_mods().collect(),
6351            Self::AutoplayOsu(_) => AutoplayOsu::incompatible_mods().collect(),
6352            Self::CinemaOsu(_) => CinemaOsu::incompatible_mods().collect(),
6353            Self::RelaxOsu(_) => RelaxOsu::incompatible_mods().collect(),
6354            Self::AutopilotOsu(_) => AutopilotOsu::incompatible_mods().collect(),
6355            Self::SpunOutOsu(_) => SpunOutOsu::incompatible_mods().collect(),
6356            Self::TransformOsu(_) => TransformOsu::incompatible_mods().collect(),
6357            Self::WiggleOsu(_) => WiggleOsu::incompatible_mods().collect(),
6358            Self::SpinInOsu(_) => SpinInOsu::incompatible_mods().collect(),
6359            Self::GrowOsu(_) => GrowOsu::incompatible_mods().collect(),
6360            Self::DeflateOsu(_) => DeflateOsu::incompatible_mods().collect(),
6361            Self::WindUpOsu(_) => WindUpOsu::incompatible_mods().collect(),
6362            Self::WindDownOsu(_) => WindDownOsu::incompatible_mods().collect(),
6363            Self::BarrelRollOsu(_) => BarrelRollOsu::incompatible_mods().collect(),
6364            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::incompatible_mods().collect(),
6365            Self::MutedOsu(_) => MutedOsu::incompatible_mods().collect(),
6366            Self::NoScopeOsu(_) => NoScopeOsu::incompatible_mods().collect(),
6367            Self::MagnetisedOsu(_) => MagnetisedOsu::incompatible_mods().collect(),
6368            Self::RepelOsu(_) => RepelOsu::incompatible_mods().collect(),
6369            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::incompatible_mods().collect(),
6370            Self::FreezeFrameOsu(_) => FreezeFrameOsu::incompatible_mods().collect(),
6371            Self::BubblesOsu(_) => BubblesOsu::incompatible_mods().collect(),
6372            Self::SynesthesiaOsu(_) => SynesthesiaOsu::incompatible_mods().collect(),
6373            Self::DepthOsu(_) => DepthOsu::incompatible_mods().collect(),
6374            Self::BloomOsu(_) => BloomOsu::incompatible_mods().collect(),
6375            Self::TouchDeviceOsu(_) => TouchDeviceOsu::incompatible_mods().collect(),
6376            Self::ScoreV2Osu(_) => ScoreV2Osu::incompatible_mods().collect(),
6377            Self::EasyTaiko(_) => EasyTaiko::incompatible_mods().collect(),
6378            Self::NoFailTaiko(_) => NoFailTaiko::incompatible_mods().collect(),
6379            Self::HalfTimeTaiko(_) => HalfTimeTaiko::incompatible_mods().collect(),
6380            Self::DaycoreTaiko(_) => DaycoreTaiko::incompatible_mods().collect(),
6381            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::incompatible_mods().collect(),
6382            Self::HardRockTaiko(_) => HardRockTaiko::incompatible_mods().collect(),
6383            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::incompatible_mods().collect(),
6384            Self::PerfectTaiko(_) => PerfectTaiko::incompatible_mods().collect(),
6385            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::incompatible_mods().collect(),
6386            Self::NightcoreTaiko(_) => NightcoreTaiko::incompatible_mods().collect(),
6387            Self::HiddenTaiko(_) => HiddenTaiko::incompatible_mods().collect(),
6388            Self::FlashlightTaiko(_) => FlashlightTaiko::incompatible_mods().collect(),
6389            Self::AccuracyChallengeTaiko(_) => {
6390                AccuracyChallengeTaiko::incompatible_mods().collect()
6391            }
6392            Self::RandomTaiko(_) => RandomTaiko::incompatible_mods().collect(),
6393            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::incompatible_mods().collect(),
6394            Self::ClassicTaiko(_) => ClassicTaiko::incompatible_mods().collect(),
6395            Self::SwapTaiko(_) => SwapTaiko::incompatible_mods().collect(),
6396            Self::SingleTapTaiko(_) => SingleTapTaiko::incompatible_mods().collect(),
6397            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::incompatible_mods().collect(),
6398            Self::AutoplayTaiko(_) => AutoplayTaiko::incompatible_mods().collect(),
6399            Self::CinemaTaiko(_) => CinemaTaiko::incompatible_mods().collect(),
6400            Self::RelaxTaiko(_) => RelaxTaiko::incompatible_mods().collect(),
6401            Self::WindUpTaiko(_) => WindUpTaiko::incompatible_mods().collect(),
6402            Self::WindDownTaiko(_) => WindDownTaiko::incompatible_mods().collect(),
6403            Self::MutedTaiko(_) => MutedTaiko::incompatible_mods().collect(),
6404            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::incompatible_mods().collect(),
6405            Self::ScoreV2Taiko(_) => ScoreV2Taiko::incompatible_mods().collect(),
6406            Self::EasyCatch(_) => EasyCatch::incompatible_mods().collect(),
6407            Self::NoFailCatch(_) => NoFailCatch::incompatible_mods().collect(),
6408            Self::HalfTimeCatch(_) => HalfTimeCatch::incompatible_mods().collect(),
6409            Self::DaycoreCatch(_) => DaycoreCatch::incompatible_mods().collect(),
6410            Self::HardRockCatch(_) => HardRockCatch::incompatible_mods().collect(),
6411            Self::SuddenDeathCatch(_) => SuddenDeathCatch::incompatible_mods().collect(),
6412            Self::PerfectCatch(_) => PerfectCatch::incompatible_mods().collect(),
6413            Self::DoubleTimeCatch(_) => DoubleTimeCatch::incompatible_mods().collect(),
6414            Self::NightcoreCatch(_) => NightcoreCatch::incompatible_mods().collect(),
6415            Self::HiddenCatch(_) => HiddenCatch::incompatible_mods().collect(),
6416            Self::FlashlightCatch(_) => FlashlightCatch::incompatible_mods().collect(),
6417            Self::AccuracyChallengeCatch(_) => {
6418                AccuracyChallengeCatch::incompatible_mods().collect()
6419            }
6420            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::incompatible_mods().collect(),
6421            Self::ClassicCatch(_) => ClassicCatch::incompatible_mods().collect(),
6422            Self::MirrorCatch(_) => MirrorCatch::incompatible_mods().collect(),
6423            Self::AutoplayCatch(_) => AutoplayCatch::incompatible_mods().collect(),
6424            Self::CinemaCatch(_) => CinemaCatch::incompatible_mods().collect(),
6425            Self::RelaxCatch(_) => RelaxCatch::incompatible_mods().collect(),
6426            Self::WindUpCatch(_) => WindUpCatch::incompatible_mods().collect(),
6427            Self::WindDownCatch(_) => WindDownCatch::incompatible_mods().collect(),
6428            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::incompatible_mods().collect(),
6429            Self::MutedCatch(_) => MutedCatch::incompatible_mods().collect(),
6430            Self::NoScopeCatch(_) => NoScopeCatch::incompatible_mods().collect(),
6431            Self::MovingFastCatch(_) => MovingFastCatch::incompatible_mods().collect(),
6432            Self::ScoreV2Catch(_) => ScoreV2Catch::incompatible_mods().collect(),
6433            Self::EasyMania(_) => EasyMania::incompatible_mods().collect(),
6434            Self::NoFailMania(_) => NoFailMania::incompatible_mods().collect(),
6435            Self::HalfTimeMania(_) => HalfTimeMania::incompatible_mods().collect(),
6436            Self::DaycoreMania(_) => DaycoreMania::incompatible_mods().collect(),
6437            Self::NoReleaseMania(_) => NoReleaseMania::incompatible_mods().collect(),
6438            Self::HardRockMania(_) => HardRockMania::incompatible_mods().collect(),
6439            Self::SuddenDeathMania(_) => SuddenDeathMania::incompatible_mods().collect(),
6440            Self::PerfectMania(_) => PerfectMania::incompatible_mods().collect(),
6441            Self::DoubleTimeMania(_) => DoubleTimeMania::incompatible_mods().collect(),
6442            Self::NightcoreMania(_) => NightcoreMania::incompatible_mods().collect(),
6443            Self::FadeInMania(_) => FadeInMania::incompatible_mods().collect(),
6444            Self::HiddenMania(_) => HiddenMania::incompatible_mods().collect(),
6445            Self::CoverMania(_) => CoverMania::incompatible_mods().collect(),
6446            Self::FlashlightMania(_) => FlashlightMania::incompatible_mods().collect(),
6447            Self::AccuracyChallengeMania(_) => {
6448                AccuracyChallengeMania::incompatible_mods().collect()
6449            }
6450            Self::RandomMania(_) => RandomMania::incompatible_mods().collect(),
6451            Self::DualStagesMania(_) => DualStagesMania::incompatible_mods().collect(),
6452            Self::MirrorMania(_) => MirrorMania::incompatible_mods().collect(),
6453            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::incompatible_mods().collect(),
6454            Self::ClassicMania(_) => ClassicMania::incompatible_mods().collect(),
6455            Self::InvertMania(_) => InvertMania::incompatible_mods().collect(),
6456            Self::ConstantSpeedMania(_) => ConstantSpeedMania::incompatible_mods().collect(),
6457            Self::HoldOffMania(_) => HoldOffMania::incompatible_mods().collect(),
6458            Self::OneKeyMania(_) => OneKeyMania::incompatible_mods().collect(),
6459            Self::TwoKeysMania(_) => TwoKeysMania::incompatible_mods().collect(),
6460            Self::ThreeKeysMania(_) => ThreeKeysMania::incompatible_mods().collect(),
6461            Self::FourKeysMania(_) => FourKeysMania::incompatible_mods().collect(),
6462            Self::FiveKeysMania(_) => FiveKeysMania::incompatible_mods().collect(),
6463            Self::SixKeysMania(_) => SixKeysMania::incompatible_mods().collect(),
6464            Self::SevenKeysMania(_) => SevenKeysMania::incompatible_mods().collect(),
6465            Self::EightKeysMania(_) => EightKeysMania::incompatible_mods().collect(),
6466            Self::NineKeysMania(_) => NineKeysMania::incompatible_mods().collect(),
6467            Self::TenKeysMania(_) => TenKeysMania::incompatible_mods().collect(),
6468            Self::AutoplayMania(_) => AutoplayMania::incompatible_mods().collect(),
6469            Self::CinemaMania(_) => CinemaMania::incompatible_mods().collect(),
6470            Self::WindUpMania(_) => WindUpMania::incompatible_mods().collect(),
6471            Self::WindDownMania(_) => WindDownMania::incompatible_mods().collect(),
6472            Self::MutedMania(_) => MutedMania::incompatible_mods().collect(),
6473            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::incompatible_mods().collect(),
6474            Self::ScoreV2Mania(_) => ScoreV2Mania::incompatible_mods().collect(),
6475            _ => UnknownMod::incompatible_mods().collect(),
6476        }
6477    }
6478    /// The description of this [`GameMod`]
6479    pub const fn description(&self) -> &'static str {
6480        match self {
6481            Self::EasyOsu(_) => EasyOsu::description(),
6482            Self::NoFailOsu(_) => NoFailOsu::description(),
6483            Self::HalfTimeOsu(_) => HalfTimeOsu::description(),
6484            Self::DaycoreOsu(_) => DaycoreOsu::description(),
6485            Self::HardRockOsu(_) => HardRockOsu::description(),
6486            Self::SuddenDeathOsu(_) => SuddenDeathOsu::description(),
6487            Self::PerfectOsu(_) => PerfectOsu::description(),
6488            Self::DoubleTimeOsu(_) => DoubleTimeOsu::description(),
6489            Self::NightcoreOsu(_) => NightcoreOsu::description(),
6490            Self::HiddenOsu(_) => HiddenOsu::description(),
6491            Self::TraceableOsu(_) => TraceableOsu::description(),
6492            Self::FlashlightOsu(_) => FlashlightOsu::description(),
6493            Self::BlindsOsu(_) => BlindsOsu::description(),
6494            Self::StrictTrackingOsu(_) => StrictTrackingOsu::description(),
6495            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::description(),
6496            Self::TargetPracticeOsu(_) => TargetPracticeOsu::description(),
6497            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::description(),
6498            Self::ClassicOsu(_) => ClassicOsu::description(),
6499            Self::RandomOsu(_) => RandomOsu::description(),
6500            Self::MirrorOsu(_) => MirrorOsu::description(),
6501            Self::AlternateOsu(_) => AlternateOsu::description(),
6502            Self::SingleTapOsu(_) => SingleTapOsu::description(),
6503            Self::AutoplayOsu(_) => AutoplayOsu::description(),
6504            Self::CinemaOsu(_) => CinemaOsu::description(),
6505            Self::RelaxOsu(_) => RelaxOsu::description(),
6506            Self::AutopilotOsu(_) => AutopilotOsu::description(),
6507            Self::SpunOutOsu(_) => SpunOutOsu::description(),
6508            Self::TransformOsu(_) => TransformOsu::description(),
6509            Self::WiggleOsu(_) => WiggleOsu::description(),
6510            Self::SpinInOsu(_) => SpinInOsu::description(),
6511            Self::GrowOsu(_) => GrowOsu::description(),
6512            Self::DeflateOsu(_) => DeflateOsu::description(),
6513            Self::WindUpOsu(_) => WindUpOsu::description(),
6514            Self::WindDownOsu(_) => WindDownOsu::description(),
6515            Self::BarrelRollOsu(_) => BarrelRollOsu::description(),
6516            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::description(),
6517            Self::MutedOsu(_) => MutedOsu::description(),
6518            Self::NoScopeOsu(_) => NoScopeOsu::description(),
6519            Self::MagnetisedOsu(_) => MagnetisedOsu::description(),
6520            Self::RepelOsu(_) => RepelOsu::description(),
6521            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::description(),
6522            Self::FreezeFrameOsu(_) => FreezeFrameOsu::description(),
6523            Self::BubblesOsu(_) => BubblesOsu::description(),
6524            Self::SynesthesiaOsu(_) => SynesthesiaOsu::description(),
6525            Self::DepthOsu(_) => DepthOsu::description(),
6526            Self::BloomOsu(_) => BloomOsu::description(),
6527            Self::TouchDeviceOsu(_) => TouchDeviceOsu::description(),
6528            Self::ScoreV2Osu(_) => ScoreV2Osu::description(),
6529            Self::EasyTaiko(_) => EasyTaiko::description(),
6530            Self::NoFailTaiko(_) => NoFailTaiko::description(),
6531            Self::HalfTimeTaiko(_) => HalfTimeTaiko::description(),
6532            Self::DaycoreTaiko(_) => DaycoreTaiko::description(),
6533            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::description(),
6534            Self::HardRockTaiko(_) => HardRockTaiko::description(),
6535            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::description(),
6536            Self::PerfectTaiko(_) => PerfectTaiko::description(),
6537            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::description(),
6538            Self::NightcoreTaiko(_) => NightcoreTaiko::description(),
6539            Self::HiddenTaiko(_) => HiddenTaiko::description(),
6540            Self::FlashlightTaiko(_) => FlashlightTaiko::description(),
6541            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::description(),
6542            Self::RandomTaiko(_) => RandomTaiko::description(),
6543            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::description(),
6544            Self::ClassicTaiko(_) => ClassicTaiko::description(),
6545            Self::SwapTaiko(_) => SwapTaiko::description(),
6546            Self::SingleTapTaiko(_) => SingleTapTaiko::description(),
6547            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::description(),
6548            Self::AutoplayTaiko(_) => AutoplayTaiko::description(),
6549            Self::CinemaTaiko(_) => CinemaTaiko::description(),
6550            Self::RelaxTaiko(_) => RelaxTaiko::description(),
6551            Self::WindUpTaiko(_) => WindUpTaiko::description(),
6552            Self::WindDownTaiko(_) => WindDownTaiko::description(),
6553            Self::MutedTaiko(_) => MutedTaiko::description(),
6554            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::description(),
6555            Self::ScoreV2Taiko(_) => ScoreV2Taiko::description(),
6556            Self::EasyCatch(_) => EasyCatch::description(),
6557            Self::NoFailCatch(_) => NoFailCatch::description(),
6558            Self::HalfTimeCatch(_) => HalfTimeCatch::description(),
6559            Self::DaycoreCatch(_) => DaycoreCatch::description(),
6560            Self::HardRockCatch(_) => HardRockCatch::description(),
6561            Self::SuddenDeathCatch(_) => SuddenDeathCatch::description(),
6562            Self::PerfectCatch(_) => PerfectCatch::description(),
6563            Self::DoubleTimeCatch(_) => DoubleTimeCatch::description(),
6564            Self::NightcoreCatch(_) => NightcoreCatch::description(),
6565            Self::HiddenCatch(_) => HiddenCatch::description(),
6566            Self::FlashlightCatch(_) => FlashlightCatch::description(),
6567            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::description(),
6568            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::description(),
6569            Self::ClassicCatch(_) => ClassicCatch::description(),
6570            Self::MirrorCatch(_) => MirrorCatch::description(),
6571            Self::AutoplayCatch(_) => AutoplayCatch::description(),
6572            Self::CinemaCatch(_) => CinemaCatch::description(),
6573            Self::RelaxCatch(_) => RelaxCatch::description(),
6574            Self::WindUpCatch(_) => WindUpCatch::description(),
6575            Self::WindDownCatch(_) => WindDownCatch::description(),
6576            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::description(),
6577            Self::MutedCatch(_) => MutedCatch::description(),
6578            Self::NoScopeCatch(_) => NoScopeCatch::description(),
6579            Self::MovingFastCatch(_) => MovingFastCatch::description(),
6580            Self::ScoreV2Catch(_) => ScoreV2Catch::description(),
6581            Self::EasyMania(_) => EasyMania::description(),
6582            Self::NoFailMania(_) => NoFailMania::description(),
6583            Self::HalfTimeMania(_) => HalfTimeMania::description(),
6584            Self::DaycoreMania(_) => DaycoreMania::description(),
6585            Self::NoReleaseMania(_) => NoReleaseMania::description(),
6586            Self::HardRockMania(_) => HardRockMania::description(),
6587            Self::SuddenDeathMania(_) => SuddenDeathMania::description(),
6588            Self::PerfectMania(_) => PerfectMania::description(),
6589            Self::DoubleTimeMania(_) => DoubleTimeMania::description(),
6590            Self::NightcoreMania(_) => NightcoreMania::description(),
6591            Self::FadeInMania(_) => FadeInMania::description(),
6592            Self::HiddenMania(_) => HiddenMania::description(),
6593            Self::CoverMania(_) => CoverMania::description(),
6594            Self::FlashlightMania(_) => FlashlightMania::description(),
6595            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::description(),
6596            Self::RandomMania(_) => RandomMania::description(),
6597            Self::DualStagesMania(_) => DualStagesMania::description(),
6598            Self::MirrorMania(_) => MirrorMania::description(),
6599            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::description(),
6600            Self::ClassicMania(_) => ClassicMania::description(),
6601            Self::InvertMania(_) => InvertMania::description(),
6602            Self::ConstantSpeedMania(_) => ConstantSpeedMania::description(),
6603            Self::HoldOffMania(_) => HoldOffMania::description(),
6604            Self::OneKeyMania(_) => OneKeyMania::description(),
6605            Self::TwoKeysMania(_) => TwoKeysMania::description(),
6606            Self::ThreeKeysMania(_) => ThreeKeysMania::description(),
6607            Self::FourKeysMania(_) => FourKeysMania::description(),
6608            Self::FiveKeysMania(_) => FiveKeysMania::description(),
6609            Self::SixKeysMania(_) => SixKeysMania::description(),
6610            Self::SevenKeysMania(_) => SevenKeysMania::description(),
6611            Self::EightKeysMania(_) => EightKeysMania::description(),
6612            Self::NineKeysMania(_) => NineKeysMania::description(),
6613            Self::TenKeysMania(_) => TenKeysMania::description(),
6614            Self::AutoplayMania(_) => AutoplayMania::description(),
6615            Self::CinemaMania(_) => CinemaMania::description(),
6616            Self::WindUpMania(_) => WindUpMania::description(),
6617            Self::WindDownMania(_) => WindDownMania::description(),
6618            Self::MutedMania(_) => MutedMania::description(),
6619            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::description(),
6620            Self::ScoreV2Mania(_) => ScoreV2Mania::description(),
6621            _ => UnknownMod::description(),
6622        }
6623    }
6624    /// The [`GameModKind`] of this [`GameMod`]
6625    pub const fn kind(&self) -> GameModKind {
6626        match self {
6627            Self::EasyOsu(_) => EasyOsu::kind(),
6628            Self::NoFailOsu(_) => NoFailOsu::kind(),
6629            Self::HalfTimeOsu(_) => HalfTimeOsu::kind(),
6630            Self::DaycoreOsu(_) => DaycoreOsu::kind(),
6631            Self::HardRockOsu(_) => HardRockOsu::kind(),
6632            Self::SuddenDeathOsu(_) => SuddenDeathOsu::kind(),
6633            Self::PerfectOsu(_) => PerfectOsu::kind(),
6634            Self::DoubleTimeOsu(_) => DoubleTimeOsu::kind(),
6635            Self::NightcoreOsu(_) => NightcoreOsu::kind(),
6636            Self::HiddenOsu(_) => HiddenOsu::kind(),
6637            Self::TraceableOsu(_) => TraceableOsu::kind(),
6638            Self::FlashlightOsu(_) => FlashlightOsu::kind(),
6639            Self::BlindsOsu(_) => BlindsOsu::kind(),
6640            Self::StrictTrackingOsu(_) => StrictTrackingOsu::kind(),
6641            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::kind(),
6642            Self::TargetPracticeOsu(_) => TargetPracticeOsu::kind(),
6643            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::kind(),
6644            Self::ClassicOsu(_) => ClassicOsu::kind(),
6645            Self::RandomOsu(_) => RandomOsu::kind(),
6646            Self::MirrorOsu(_) => MirrorOsu::kind(),
6647            Self::AlternateOsu(_) => AlternateOsu::kind(),
6648            Self::SingleTapOsu(_) => SingleTapOsu::kind(),
6649            Self::AutoplayOsu(_) => AutoplayOsu::kind(),
6650            Self::CinemaOsu(_) => CinemaOsu::kind(),
6651            Self::RelaxOsu(_) => RelaxOsu::kind(),
6652            Self::AutopilotOsu(_) => AutopilotOsu::kind(),
6653            Self::SpunOutOsu(_) => SpunOutOsu::kind(),
6654            Self::TransformOsu(_) => TransformOsu::kind(),
6655            Self::WiggleOsu(_) => WiggleOsu::kind(),
6656            Self::SpinInOsu(_) => SpinInOsu::kind(),
6657            Self::GrowOsu(_) => GrowOsu::kind(),
6658            Self::DeflateOsu(_) => DeflateOsu::kind(),
6659            Self::WindUpOsu(_) => WindUpOsu::kind(),
6660            Self::WindDownOsu(_) => WindDownOsu::kind(),
6661            Self::BarrelRollOsu(_) => BarrelRollOsu::kind(),
6662            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::kind(),
6663            Self::MutedOsu(_) => MutedOsu::kind(),
6664            Self::NoScopeOsu(_) => NoScopeOsu::kind(),
6665            Self::MagnetisedOsu(_) => MagnetisedOsu::kind(),
6666            Self::RepelOsu(_) => RepelOsu::kind(),
6667            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::kind(),
6668            Self::FreezeFrameOsu(_) => FreezeFrameOsu::kind(),
6669            Self::BubblesOsu(_) => BubblesOsu::kind(),
6670            Self::SynesthesiaOsu(_) => SynesthesiaOsu::kind(),
6671            Self::DepthOsu(_) => DepthOsu::kind(),
6672            Self::BloomOsu(_) => BloomOsu::kind(),
6673            Self::TouchDeviceOsu(_) => TouchDeviceOsu::kind(),
6674            Self::ScoreV2Osu(_) => ScoreV2Osu::kind(),
6675            Self::EasyTaiko(_) => EasyTaiko::kind(),
6676            Self::NoFailTaiko(_) => NoFailTaiko::kind(),
6677            Self::HalfTimeTaiko(_) => HalfTimeTaiko::kind(),
6678            Self::DaycoreTaiko(_) => DaycoreTaiko::kind(),
6679            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::kind(),
6680            Self::HardRockTaiko(_) => HardRockTaiko::kind(),
6681            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::kind(),
6682            Self::PerfectTaiko(_) => PerfectTaiko::kind(),
6683            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::kind(),
6684            Self::NightcoreTaiko(_) => NightcoreTaiko::kind(),
6685            Self::HiddenTaiko(_) => HiddenTaiko::kind(),
6686            Self::FlashlightTaiko(_) => FlashlightTaiko::kind(),
6687            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::kind(),
6688            Self::RandomTaiko(_) => RandomTaiko::kind(),
6689            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::kind(),
6690            Self::ClassicTaiko(_) => ClassicTaiko::kind(),
6691            Self::SwapTaiko(_) => SwapTaiko::kind(),
6692            Self::SingleTapTaiko(_) => SingleTapTaiko::kind(),
6693            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::kind(),
6694            Self::AutoplayTaiko(_) => AutoplayTaiko::kind(),
6695            Self::CinemaTaiko(_) => CinemaTaiko::kind(),
6696            Self::RelaxTaiko(_) => RelaxTaiko::kind(),
6697            Self::WindUpTaiko(_) => WindUpTaiko::kind(),
6698            Self::WindDownTaiko(_) => WindDownTaiko::kind(),
6699            Self::MutedTaiko(_) => MutedTaiko::kind(),
6700            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::kind(),
6701            Self::ScoreV2Taiko(_) => ScoreV2Taiko::kind(),
6702            Self::EasyCatch(_) => EasyCatch::kind(),
6703            Self::NoFailCatch(_) => NoFailCatch::kind(),
6704            Self::HalfTimeCatch(_) => HalfTimeCatch::kind(),
6705            Self::DaycoreCatch(_) => DaycoreCatch::kind(),
6706            Self::HardRockCatch(_) => HardRockCatch::kind(),
6707            Self::SuddenDeathCatch(_) => SuddenDeathCatch::kind(),
6708            Self::PerfectCatch(_) => PerfectCatch::kind(),
6709            Self::DoubleTimeCatch(_) => DoubleTimeCatch::kind(),
6710            Self::NightcoreCatch(_) => NightcoreCatch::kind(),
6711            Self::HiddenCatch(_) => HiddenCatch::kind(),
6712            Self::FlashlightCatch(_) => FlashlightCatch::kind(),
6713            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::kind(),
6714            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::kind(),
6715            Self::ClassicCatch(_) => ClassicCatch::kind(),
6716            Self::MirrorCatch(_) => MirrorCatch::kind(),
6717            Self::AutoplayCatch(_) => AutoplayCatch::kind(),
6718            Self::CinemaCatch(_) => CinemaCatch::kind(),
6719            Self::RelaxCatch(_) => RelaxCatch::kind(),
6720            Self::WindUpCatch(_) => WindUpCatch::kind(),
6721            Self::WindDownCatch(_) => WindDownCatch::kind(),
6722            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::kind(),
6723            Self::MutedCatch(_) => MutedCatch::kind(),
6724            Self::NoScopeCatch(_) => NoScopeCatch::kind(),
6725            Self::MovingFastCatch(_) => MovingFastCatch::kind(),
6726            Self::ScoreV2Catch(_) => ScoreV2Catch::kind(),
6727            Self::EasyMania(_) => EasyMania::kind(),
6728            Self::NoFailMania(_) => NoFailMania::kind(),
6729            Self::HalfTimeMania(_) => HalfTimeMania::kind(),
6730            Self::DaycoreMania(_) => DaycoreMania::kind(),
6731            Self::NoReleaseMania(_) => NoReleaseMania::kind(),
6732            Self::HardRockMania(_) => HardRockMania::kind(),
6733            Self::SuddenDeathMania(_) => SuddenDeathMania::kind(),
6734            Self::PerfectMania(_) => PerfectMania::kind(),
6735            Self::DoubleTimeMania(_) => DoubleTimeMania::kind(),
6736            Self::NightcoreMania(_) => NightcoreMania::kind(),
6737            Self::FadeInMania(_) => FadeInMania::kind(),
6738            Self::HiddenMania(_) => HiddenMania::kind(),
6739            Self::CoverMania(_) => CoverMania::kind(),
6740            Self::FlashlightMania(_) => FlashlightMania::kind(),
6741            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::kind(),
6742            Self::RandomMania(_) => RandomMania::kind(),
6743            Self::DualStagesMania(_) => DualStagesMania::kind(),
6744            Self::MirrorMania(_) => MirrorMania::kind(),
6745            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::kind(),
6746            Self::ClassicMania(_) => ClassicMania::kind(),
6747            Self::InvertMania(_) => InvertMania::kind(),
6748            Self::ConstantSpeedMania(_) => ConstantSpeedMania::kind(),
6749            Self::HoldOffMania(_) => HoldOffMania::kind(),
6750            Self::OneKeyMania(_) => OneKeyMania::kind(),
6751            Self::TwoKeysMania(_) => TwoKeysMania::kind(),
6752            Self::ThreeKeysMania(_) => ThreeKeysMania::kind(),
6753            Self::FourKeysMania(_) => FourKeysMania::kind(),
6754            Self::FiveKeysMania(_) => FiveKeysMania::kind(),
6755            Self::SixKeysMania(_) => SixKeysMania::kind(),
6756            Self::SevenKeysMania(_) => SevenKeysMania::kind(),
6757            Self::EightKeysMania(_) => EightKeysMania::kind(),
6758            Self::NineKeysMania(_) => NineKeysMania::kind(),
6759            Self::TenKeysMania(_) => TenKeysMania::kind(),
6760            Self::AutoplayMania(_) => AutoplayMania::kind(),
6761            Self::CinemaMania(_) => CinemaMania::kind(),
6762            Self::WindUpMania(_) => WindUpMania::kind(),
6763            Self::WindDownMania(_) => WindDownMania::kind(),
6764            Self::MutedMania(_) => MutedMania::kind(),
6765            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::kind(),
6766            Self::ScoreV2Mania(_) => ScoreV2Mania::kind(),
6767            _ => UnknownMod::kind(),
6768        }
6769    }
6770    /// Optional bit value of this [`GameMod`]
6771    ///
6772    /// See <https://github.com/ppy/osu-api/wiki#mods>
6773    pub const fn bits(&self) -> Option<u32> {
6774        match self {
6775            Self::EasyOsu(_) => Some(EasyOsu::bits()),
6776            Self::NoFailOsu(_) => Some(NoFailOsu::bits()),
6777            Self::HalfTimeOsu(_) => Some(HalfTimeOsu::bits()),
6778            Self::HardRockOsu(_) => Some(HardRockOsu::bits()),
6779            Self::SuddenDeathOsu(_) => Some(SuddenDeathOsu::bits()),
6780            Self::PerfectOsu(_) => Some(PerfectOsu::bits()),
6781            Self::DoubleTimeOsu(_) => Some(DoubleTimeOsu::bits()),
6782            Self::NightcoreOsu(_) => Some(NightcoreOsu::bits()),
6783            Self::HiddenOsu(_) => Some(HiddenOsu::bits()),
6784            Self::FlashlightOsu(_) => Some(FlashlightOsu::bits()),
6785            Self::TargetPracticeOsu(_) => Some(TargetPracticeOsu::bits()),
6786            Self::RandomOsu(_) => Some(RandomOsu::bits()),
6787            Self::MirrorOsu(_) => Some(MirrorOsu::bits()),
6788            Self::AutoplayOsu(_) => Some(AutoplayOsu::bits()),
6789            Self::CinemaOsu(_) => Some(CinemaOsu::bits()),
6790            Self::RelaxOsu(_) => Some(RelaxOsu::bits()),
6791            Self::AutopilotOsu(_) => Some(AutopilotOsu::bits()),
6792            Self::SpunOutOsu(_) => Some(SpunOutOsu::bits()),
6793            Self::TouchDeviceOsu(_) => Some(TouchDeviceOsu::bits()),
6794            Self::ScoreV2Osu(_) => Some(ScoreV2Osu::bits()),
6795            Self::EasyTaiko(_) => Some(EasyTaiko::bits()),
6796            Self::NoFailTaiko(_) => Some(NoFailTaiko::bits()),
6797            Self::HalfTimeTaiko(_) => Some(HalfTimeTaiko::bits()),
6798            Self::HardRockTaiko(_) => Some(HardRockTaiko::bits()),
6799            Self::SuddenDeathTaiko(_) => Some(SuddenDeathTaiko::bits()),
6800            Self::PerfectTaiko(_) => Some(PerfectTaiko::bits()),
6801            Self::DoubleTimeTaiko(_) => Some(DoubleTimeTaiko::bits()),
6802            Self::NightcoreTaiko(_) => Some(NightcoreTaiko::bits()),
6803            Self::HiddenTaiko(_) => Some(HiddenTaiko::bits()),
6804            Self::FlashlightTaiko(_) => Some(FlashlightTaiko::bits()),
6805            Self::RandomTaiko(_) => Some(RandomTaiko::bits()),
6806            Self::AutoplayTaiko(_) => Some(AutoplayTaiko::bits()),
6807            Self::CinemaTaiko(_) => Some(CinemaTaiko::bits()),
6808            Self::RelaxTaiko(_) => Some(RelaxTaiko::bits()),
6809            Self::ScoreV2Taiko(_) => Some(ScoreV2Taiko::bits()),
6810            Self::EasyCatch(_) => Some(EasyCatch::bits()),
6811            Self::NoFailCatch(_) => Some(NoFailCatch::bits()),
6812            Self::HalfTimeCatch(_) => Some(HalfTimeCatch::bits()),
6813            Self::HardRockCatch(_) => Some(HardRockCatch::bits()),
6814            Self::SuddenDeathCatch(_) => Some(SuddenDeathCatch::bits()),
6815            Self::PerfectCatch(_) => Some(PerfectCatch::bits()),
6816            Self::DoubleTimeCatch(_) => Some(DoubleTimeCatch::bits()),
6817            Self::NightcoreCatch(_) => Some(NightcoreCatch::bits()),
6818            Self::HiddenCatch(_) => Some(HiddenCatch::bits()),
6819            Self::FlashlightCatch(_) => Some(FlashlightCatch::bits()),
6820            Self::MirrorCatch(_) => Some(MirrorCatch::bits()),
6821            Self::AutoplayCatch(_) => Some(AutoplayCatch::bits()),
6822            Self::CinemaCatch(_) => Some(CinemaCatch::bits()),
6823            Self::RelaxCatch(_) => Some(RelaxCatch::bits()),
6824            Self::ScoreV2Catch(_) => Some(ScoreV2Catch::bits()),
6825            Self::EasyMania(_) => Some(EasyMania::bits()),
6826            Self::NoFailMania(_) => Some(NoFailMania::bits()),
6827            Self::HalfTimeMania(_) => Some(HalfTimeMania::bits()),
6828            Self::HardRockMania(_) => Some(HardRockMania::bits()),
6829            Self::SuddenDeathMania(_) => Some(SuddenDeathMania::bits()),
6830            Self::PerfectMania(_) => Some(PerfectMania::bits()),
6831            Self::DoubleTimeMania(_) => Some(DoubleTimeMania::bits()),
6832            Self::NightcoreMania(_) => Some(NightcoreMania::bits()),
6833            Self::FadeInMania(_) => Some(FadeInMania::bits()),
6834            Self::HiddenMania(_) => Some(HiddenMania::bits()),
6835            Self::FlashlightMania(_) => Some(FlashlightMania::bits()),
6836            Self::RandomMania(_) => Some(RandomMania::bits()),
6837            Self::DualStagesMania(_) => Some(DualStagesMania::bits()),
6838            Self::MirrorMania(_) => Some(MirrorMania::bits()),
6839            Self::OneKeyMania(_) => Some(OneKeyMania::bits()),
6840            Self::TwoKeysMania(_) => Some(TwoKeysMania::bits()),
6841            Self::ThreeKeysMania(_) => Some(ThreeKeysMania::bits()),
6842            Self::FourKeysMania(_) => Some(FourKeysMania::bits()),
6843            Self::FiveKeysMania(_) => Some(FiveKeysMania::bits()),
6844            Self::SixKeysMania(_) => Some(SixKeysMania::bits()),
6845            Self::SevenKeysMania(_) => Some(SevenKeysMania::bits()),
6846            Self::EightKeysMania(_) => Some(EightKeysMania::bits()),
6847            Self::NineKeysMania(_) => Some(NineKeysMania::bits()),
6848            Self::AutoplayMania(_) => Some(AutoplayMania::bits()),
6849            Self::CinemaMania(_) => Some(CinemaMania::bits()),
6850            Self::ScoreV2Mania(_) => Some(ScoreV2Mania::bits()),
6851            _ => None,
6852        }
6853    }
6854    /// The [`GameMode`] of a [`GameMod`]
6855    pub const fn mode(&self) -> GameMode {
6856        match self {
6857            Self::EasyOsu(_)
6858            | Self::NoFailOsu(_)
6859            | Self::HalfTimeOsu(_)
6860            | Self::DaycoreOsu(_)
6861            | Self::HardRockOsu(_)
6862            | Self::SuddenDeathOsu(_)
6863            | Self::PerfectOsu(_)
6864            | Self::DoubleTimeOsu(_)
6865            | Self::NightcoreOsu(_)
6866            | Self::HiddenOsu(_)
6867            | Self::TraceableOsu(_)
6868            | Self::FlashlightOsu(_)
6869            | Self::BlindsOsu(_)
6870            | Self::StrictTrackingOsu(_)
6871            | Self::AccuracyChallengeOsu(_)
6872            | Self::TargetPracticeOsu(_)
6873            | Self::DifficultyAdjustOsu(_)
6874            | Self::ClassicOsu(_)
6875            | Self::RandomOsu(_)
6876            | Self::MirrorOsu(_)
6877            | Self::AlternateOsu(_)
6878            | Self::SingleTapOsu(_)
6879            | Self::AutoplayOsu(_)
6880            | Self::CinemaOsu(_)
6881            | Self::RelaxOsu(_)
6882            | Self::AutopilotOsu(_)
6883            | Self::SpunOutOsu(_)
6884            | Self::TransformOsu(_)
6885            | Self::WiggleOsu(_)
6886            | Self::SpinInOsu(_)
6887            | Self::GrowOsu(_)
6888            | Self::DeflateOsu(_)
6889            | Self::WindUpOsu(_)
6890            | Self::WindDownOsu(_)
6891            | Self::BarrelRollOsu(_)
6892            | Self::ApproachDifferentOsu(_)
6893            | Self::MutedOsu(_)
6894            | Self::NoScopeOsu(_)
6895            | Self::MagnetisedOsu(_)
6896            | Self::RepelOsu(_)
6897            | Self::AdaptiveSpeedOsu(_)
6898            | Self::FreezeFrameOsu(_)
6899            | Self::BubblesOsu(_)
6900            | Self::SynesthesiaOsu(_)
6901            | Self::DepthOsu(_)
6902            | Self::BloomOsu(_)
6903            | Self::TouchDeviceOsu(_)
6904            | Self::ScoreV2Osu(_)
6905            | Self::UnknownOsu(_) => GameMode::Osu,
6906            Self::EasyTaiko(_)
6907            | Self::NoFailTaiko(_)
6908            | Self::HalfTimeTaiko(_)
6909            | Self::DaycoreTaiko(_)
6910            | Self::SimplifiedRhythmTaiko(_)
6911            | Self::HardRockTaiko(_)
6912            | Self::SuddenDeathTaiko(_)
6913            | Self::PerfectTaiko(_)
6914            | Self::DoubleTimeTaiko(_)
6915            | Self::NightcoreTaiko(_)
6916            | Self::HiddenTaiko(_)
6917            | Self::FlashlightTaiko(_)
6918            | Self::AccuracyChallengeTaiko(_)
6919            | Self::RandomTaiko(_)
6920            | Self::DifficultyAdjustTaiko(_)
6921            | Self::ClassicTaiko(_)
6922            | Self::SwapTaiko(_)
6923            | Self::SingleTapTaiko(_)
6924            | Self::ConstantSpeedTaiko(_)
6925            | Self::AutoplayTaiko(_)
6926            | Self::CinemaTaiko(_)
6927            | Self::RelaxTaiko(_)
6928            | Self::WindUpTaiko(_)
6929            | Self::WindDownTaiko(_)
6930            | Self::MutedTaiko(_)
6931            | Self::AdaptiveSpeedTaiko(_)
6932            | Self::ScoreV2Taiko(_)
6933            | Self::UnknownTaiko(_) => GameMode::Taiko,
6934            Self::EasyCatch(_)
6935            | Self::NoFailCatch(_)
6936            | Self::HalfTimeCatch(_)
6937            | Self::DaycoreCatch(_)
6938            | Self::HardRockCatch(_)
6939            | Self::SuddenDeathCatch(_)
6940            | Self::PerfectCatch(_)
6941            | Self::DoubleTimeCatch(_)
6942            | Self::NightcoreCatch(_)
6943            | Self::HiddenCatch(_)
6944            | Self::FlashlightCatch(_)
6945            | Self::AccuracyChallengeCatch(_)
6946            | Self::DifficultyAdjustCatch(_)
6947            | Self::ClassicCatch(_)
6948            | Self::MirrorCatch(_)
6949            | Self::AutoplayCatch(_)
6950            | Self::CinemaCatch(_)
6951            | Self::RelaxCatch(_)
6952            | Self::WindUpCatch(_)
6953            | Self::WindDownCatch(_)
6954            | Self::FloatingFruitsCatch(_)
6955            | Self::MutedCatch(_)
6956            | Self::NoScopeCatch(_)
6957            | Self::MovingFastCatch(_)
6958            | Self::ScoreV2Catch(_)
6959            | Self::UnknownCatch(_) => GameMode::Catch,
6960            Self::EasyMania(_)
6961            | Self::NoFailMania(_)
6962            | Self::HalfTimeMania(_)
6963            | Self::DaycoreMania(_)
6964            | Self::NoReleaseMania(_)
6965            | Self::HardRockMania(_)
6966            | Self::SuddenDeathMania(_)
6967            | Self::PerfectMania(_)
6968            | Self::DoubleTimeMania(_)
6969            | Self::NightcoreMania(_)
6970            | Self::FadeInMania(_)
6971            | Self::HiddenMania(_)
6972            | Self::CoverMania(_)
6973            | Self::FlashlightMania(_)
6974            | Self::AccuracyChallengeMania(_)
6975            | Self::RandomMania(_)
6976            | Self::DualStagesMania(_)
6977            | Self::MirrorMania(_)
6978            | Self::DifficultyAdjustMania(_)
6979            | Self::ClassicMania(_)
6980            | Self::InvertMania(_)
6981            | Self::ConstantSpeedMania(_)
6982            | Self::HoldOffMania(_)
6983            | Self::OneKeyMania(_)
6984            | Self::TwoKeysMania(_)
6985            | Self::ThreeKeysMania(_)
6986            | Self::FourKeysMania(_)
6987            | Self::FiveKeysMania(_)
6988            | Self::SixKeysMania(_)
6989            | Self::SevenKeysMania(_)
6990            | Self::EightKeysMania(_)
6991            | Self::NineKeysMania(_)
6992            | Self::TenKeysMania(_)
6993            | Self::AutoplayMania(_)
6994            | Self::CinemaMania(_)
6995            | Self::WindUpMania(_)
6996            | Self::WindDownMania(_)
6997            | Self::MutedMania(_)
6998            | Self::AdaptiveSpeedMania(_)
6999            | Self::ScoreV2Mania(_)
7000            | Self::UnknownMania(_) => GameMode::Mania,
7001        }
7002    }
7003    /// The kind of a [`GameMod`] when ignoring the mode
7004    pub const fn intermode(&self) -> GameModIntermode {
7005        match self {
7006            Self::EasyOsu(_) => GameModIntermode::Easy,
7007            Self::NoFailOsu(_) => GameModIntermode::NoFail,
7008            Self::HalfTimeOsu(_) => GameModIntermode::HalfTime,
7009            Self::DaycoreOsu(_) => GameModIntermode::Daycore,
7010            Self::HardRockOsu(_) => GameModIntermode::HardRock,
7011            Self::SuddenDeathOsu(_) => GameModIntermode::SuddenDeath,
7012            Self::PerfectOsu(_) => GameModIntermode::Perfect,
7013            Self::DoubleTimeOsu(_) => GameModIntermode::DoubleTime,
7014            Self::NightcoreOsu(_) => GameModIntermode::Nightcore,
7015            Self::HiddenOsu(_) => GameModIntermode::Hidden,
7016            Self::TraceableOsu(_) => GameModIntermode::Traceable,
7017            Self::FlashlightOsu(_) => GameModIntermode::Flashlight,
7018            Self::BlindsOsu(_) => GameModIntermode::Blinds,
7019            Self::StrictTrackingOsu(_) => GameModIntermode::StrictTracking,
7020            Self::AccuracyChallengeOsu(_) => GameModIntermode::AccuracyChallenge,
7021            Self::TargetPracticeOsu(_) => GameModIntermode::TargetPractice,
7022            Self::DifficultyAdjustOsu(_) => GameModIntermode::DifficultyAdjust,
7023            Self::ClassicOsu(_) => GameModIntermode::Classic,
7024            Self::RandomOsu(_) => GameModIntermode::Random,
7025            Self::MirrorOsu(_) => GameModIntermode::Mirror,
7026            Self::AlternateOsu(_) => GameModIntermode::Alternate,
7027            Self::SingleTapOsu(_) => GameModIntermode::SingleTap,
7028            Self::AutoplayOsu(_) => GameModIntermode::Autoplay,
7029            Self::CinemaOsu(_) => GameModIntermode::Cinema,
7030            Self::RelaxOsu(_) => GameModIntermode::Relax,
7031            Self::AutopilotOsu(_) => GameModIntermode::Autopilot,
7032            Self::SpunOutOsu(_) => GameModIntermode::SpunOut,
7033            Self::TransformOsu(_) => GameModIntermode::Transform,
7034            Self::WiggleOsu(_) => GameModIntermode::Wiggle,
7035            Self::SpinInOsu(_) => GameModIntermode::SpinIn,
7036            Self::GrowOsu(_) => GameModIntermode::Grow,
7037            Self::DeflateOsu(_) => GameModIntermode::Deflate,
7038            Self::WindUpOsu(_) => GameModIntermode::WindUp,
7039            Self::WindDownOsu(_) => GameModIntermode::WindDown,
7040            Self::BarrelRollOsu(_) => GameModIntermode::BarrelRoll,
7041            Self::ApproachDifferentOsu(_) => GameModIntermode::ApproachDifferent,
7042            Self::MutedOsu(_) => GameModIntermode::Muted,
7043            Self::NoScopeOsu(_) => GameModIntermode::NoScope,
7044            Self::MagnetisedOsu(_) => GameModIntermode::Magnetised,
7045            Self::RepelOsu(_) => GameModIntermode::Repel,
7046            Self::AdaptiveSpeedOsu(_) => GameModIntermode::AdaptiveSpeed,
7047            Self::FreezeFrameOsu(_) => GameModIntermode::FreezeFrame,
7048            Self::BubblesOsu(_) => GameModIntermode::Bubbles,
7049            Self::SynesthesiaOsu(_) => GameModIntermode::Synesthesia,
7050            Self::DepthOsu(_) => GameModIntermode::Depth,
7051            Self::BloomOsu(_) => GameModIntermode::Bloom,
7052            Self::TouchDeviceOsu(_) => GameModIntermode::TouchDevice,
7053            Self::ScoreV2Osu(_) => GameModIntermode::ScoreV2,
7054            Self::EasyTaiko(_) => GameModIntermode::Easy,
7055            Self::NoFailTaiko(_) => GameModIntermode::NoFail,
7056            Self::HalfTimeTaiko(_) => GameModIntermode::HalfTime,
7057            Self::DaycoreTaiko(_) => GameModIntermode::Daycore,
7058            Self::SimplifiedRhythmTaiko(_) => GameModIntermode::SimplifiedRhythm,
7059            Self::HardRockTaiko(_) => GameModIntermode::HardRock,
7060            Self::SuddenDeathTaiko(_) => GameModIntermode::SuddenDeath,
7061            Self::PerfectTaiko(_) => GameModIntermode::Perfect,
7062            Self::DoubleTimeTaiko(_) => GameModIntermode::DoubleTime,
7063            Self::NightcoreTaiko(_) => GameModIntermode::Nightcore,
7064            Self::HiddenTaiko(_) => GameModIntermode::Hidden,
7065            Self::FlashlightTaiko(_) => GameModIntermode::Flashlight,
7066            Self::AccuracyChallengeTaiko(_) => GameModIntermode::AccuracyChallenge,
7067            Self::RandomTaiko(_) => GameModIntermode::Random,
7068            Self::DifficultyAdjustTaiko(_) => GameModIntermode::DifficultyAdjust,
7069            Self::ClassicTaiko(_) => GameModIntermode::Classic,
7070            Self::SwapTaiko(_) => GameModIntermode::Swap,
7071            Self::SingleTapTaiko(_) => GameModIntermode::SingleTap,
7072            Self::ConstantSpeedTaiko(_) => GameModIntermode::ConstantSpeed,
7073            Self::AutoplayTaiko(_) => GameModIntermode::Autoplay,
7074            Self::CinemaTaiko(_) => GameModIntermode::Cinema,
7075            Self::RelaxTaiko(_) => GameModIntermode::Relax,
7076            Self::WindUpTaiko(_) => GameModIntermode::WindUp,
7077            Self::WindDownTaiko(_) => GameModIntermode::WindDown,
7078            Self::MutedTaiko(_) => GameModIntermode::Muted,
7079            Self::AdaptiveSpeedTaiko(_) => GameModIntermode::AdaptiveSpeed,
7080            Self::ScoreV2Taiko(_) => GameModIntermode::ScoreV2,
7081            Self::EasyCatch(_) => GameModIntermode::Easy,
7082            Self::NoFailCatch(_) => GameModIntermode::NoFail,
7083            Self::HalfTimeCatch(_) => GameModIntermode::HalfTime,
7084            Self::DaycoreCatch(_) => GameModIntermode::Daycore,
7085            Self::HardRockCatch(_) => GameModIntermode::HardRock,
7086            Self::SuddenDeathCatch(_) => GameModIntermode::SuddenDeath,
7087            Self::PerfectCatch(_) => GameModIntermode::Perfect,
7088            Self::DoubleTimeCatch(_) => GameModIntermode::DoubleTime,
7089            Self::NightcoreCatch(_) => GameModIntermode::Nightcore,
7090            Self::HiddenCatch(_) => GameModIntermode::Hidden,
7091            Self::FlashlightCatch(_) => GameModIntermode::Flashlight,
7092            Self::AccuracyChallengeCatch(_) => GameModIntermode::AccuracyChallenge,
7093            Self::DifficultyAdjustCatch(_) => GameModIntermode::DifficultyAdjust,
7094            Self::ClassicCatch(_) => GameModIntermode::Classic,
7095            Self::MirrorCatch(_) => GameModIntermode::Mirror,
7096            Self::AutoplayCatch(_) => GameModIntermode::Autoplay,
7097            Self::CinemaCatch(_) => GameModIntermode::Cinema,
7098            Self::RelaxCatch(_) => GameModIntermode::Relax,
7099            Self::WindUpCatch(_) => GameModIntermode::WindUp,
7100            Self::WindDownCatch(_) => GameModIntermode::WindDown,
7101            Self::FloatingFruitsCatch(_) => GameModIntermode::FloatingFruits,
7102            Self::MutedCatch(_) => GameModIntermode::Muted,
7103            Self::NoScopeCatch(_) => GameModIntermode::NoScope,
7104            Self::MovingFastCatch(_) => GameModIntermode::MovingFast,
7105            Self::ScoreV2Catch(_) => GameModIntermode::ScoreV2,
7106            Self::EasyMania(_) => GameModIntermode::Easy,
7107            Self::NoFailMania(_) => GameModIntermode::NoFail,
7108            Self::HalfTimeMania(_) => GameModIntermode::HalfTime,
7109            Self::DaycoreMania(_) => GameModIntermode::Daycore,
7110            Self::NoReleaseMania(_) => GameModIntermode::NoRelease,
7111            Self::HardRockMania(_) => GameModIntermode::HardRock,
7112            Self::SuddenDeathMania(_) => GameModIntermode::SuddenDeath,
7113            Self::PerfectMania(_) => GameModIntermode::Perfect,
7114            Self::DoubleTimeMania(_) => GameModIntermode::DoubleTime,
7115            Self::NightcoreMania(_) => GameModIntermode::Nightcore,
7116            Self::FadeInMania(_) => GameModIntermode::FadeIn,
7117            Self::HiddenMania(_) => GameModIntermode::Hidden,
7118            Self::CoverMania(_) => GameModIntermode::Cover,
7119            Self::FlashlightMania(_) => GameModIntermode::Flashlight,
7120            Self::AccuracyChallengeMania(_) => GameModIntermode::AccuracyChallenge,
7121            Self::RandomMania(_) => GameModIntermode::Random,
7122            Self::DualStagesMania(_) => GameModIntermode::DualStages,
7123            Self::MirrorMania(_) => GameModIntermode::Mirror,
7124            Self::DifficultyAdjustMania(_) => GameModIntermode::DifficultyAdjust,
7125            Self::ClassicMania(_) => GameModIntermode::Classic,
7126            Self::InvertMania(_) => GameModIntermode::Invert,
7127            Self::ConstantSpeedMania(_) => GameModIntermode::ConstantSpeed,
7128            Self::HoldOffMania(_) => GameModIntermode::HoldOff,
7129            Self::OneKeyMania(_) => GameModIntermode::OneKey,
7130            Self::TwoKeysMania(_) => GameModIntermode::TwoKeys,
7131            Self::ThreeKeysMania(_) => GameModIntermode::ThreeKeys,
7132            Self::FourKeysMania(_) => GameModIntermode::FourKeys,
7133            Self::FiveKeysMania(_) => GameModIntermode::FiveKeys,
7134            Self::SixKeysMania(_) => GameModIntermode::SixKeys,
7135            Self::SevenKeysMania(_) => GameModIntermode::SevenKeys,
7136            Self::EightKeysMania(_) => GameModIntermode::EightKeys,
7137            Self::NineKeysMania(_) => GameModIntermode::NineKeys,
7138            Self::TenKeysMania(_) => GameModIntermode::TenKeys,
7139            Self::AutoplayMania(_) => GameModIntermode::Autoplay,
7140            Self::CinemaMania(_) => GameModIntermode::Cinema,
7141            Self::WindUpMania(_) => GameModIntermode::WindUp,
7142            Self::WindDownMania(_) => GameModIntermode::WindDown,
7143            Self::MutedMania(_) => GameModIntermode::Muted,
7144            Self::AdaptiveSpeedMania(_) => GameModIntermode::AdaptiveSpeed,
7145            Self::ScoreV2Mania(_) => GameModIntermode::ScoreV2,
7146            Self::UnknownOsu(m)
7147            | Self::UnknownTaiko(m)
7148            | Self::UnknownCatch(m)
7149            | Self::UnknownMania(m) => GameModIntermode::Unknown(*m),
7150        }
7151    }
7152    /// Convert a [`GameMod`] into a [`GameModSimple`]
7153    pub fn into_simple(self) -> GameModSimple {
7154        let mut settings = HashMap::new();
7155        let acronym = match self {
7156            Self::EasyOsu(m) => {
7157                if let Some(value) = m.retries {
7158                    settings.insert(Box::from("retries"), SettingSimple::Number(value));
7159                }
7160                EasyOsu::acronym()
7161            }
7162            Self::NoFailOsu(_) => NoFailOsu::acronym(),
7163            Self::HalfTimeOsu(m) => {
7164                if let Some(value) = m.speed_change {
7165                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7166                }
7167                if let Some(value) = m.adjust_pitch {
7168                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7169                }
7170                HalfTimeOsu::acronym()
7171            }
7172            Self::DaycoreOsu(m) => {
7173                if let Some(value) = m.speed_change {
7174                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7175                }
7176                DaycoreOsu::acronym()
7177            }
7178            Self::HardRockOsu(_) => HardRockOsu::acronym(),
7179            Self::SuddenDeathOsu(m) => {
7180                if let Some(value) = m.fail_on_slider_tail {
7181                    settings.insert(Box::from("fail_on_slider_tail"), SettingSimple::Bool(value));
7182                }
7183                if let Some(value) = m.restart {
7184                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7185                }
7186                SuddenDeathOsu::acronym()
7187            }
7188            Self::PerfectOsu(m) => {
7189                if let Some(value) = m.restart {
7190                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7191                }
7192                PerfectOsu::acronym()
7193            }
7194            Self::DoubleTimeOsu(m) => {
7195                if let Some(value) = m.speed_change {
7196                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7197                }
7198                if let Some(value) = m.adjust_pitch {
7199                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7200                }
7201                DoubleTimeOsu::acronym()
7202            }
7203            Self::NightcoreOsu(m) => {
7204                if let Some(value) = m.speed_change {
7205                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7206                }
7207                NightcoreOsu::acronym()
7208            }
7209            Self::HiddenOsu(m) => {
7210                if let Some(value) = m.only_fade_approach_circles {
7211                    settings.insert(
7212                        Box::from("only_fade_approach_circles"),
7213                        SettingSimple::Bool(value),
7214                    );
7215                }
7216                HiddenOsu::acronym()
7217            }
7218            Self::TraceableOsu(_) => TraceableOsu::acronym(),
7219            Self::FlashlightOsu(m) => {
7220                if let Some(value) = m.follow_delay {
7221                    settings.insert(Box::from("follow_delay"), SettingSimple::Number(value));
7222                }
7223                if let Some(value) = m.size_multiplier {
7224                    settings.insert(Box::from("size_multiplier"), SettingSimple::Number(value));
7225                }
7226                if let Some(value) = m.combo_based_size {
7227                    settings.insert(Box::from("combo_based_size"), SettingSimple::Bool(value));
7228                }
7229                FlashlightOsu::acronym()
7230            }
7231            Self::BlindsOsu(_) => BlindsOsu::acronym(),
7232            Self::StrictTrackingOsu(_) => StrictTrackingOsu::acronym(),
7233            Self::AccuracyChallengeOsu(m) => {
7234                if let Some(value) = m.minimum_accuracy {
7235                    settings.insert(Box::from("minimum_accuracy"), SettingSimple::Number(value));
7236                }
7237                if let Some(value) = m.accuracy_judge_mode {
7238                    settings.insert(
7239                        Box::from("accuracy_judge_mode"),
7240                        SettingSimple::String(value),
7241                    );
7242                }
7243                if let Some(value) = m.restart {
7244                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7245                }
7246                AccuracyChallengeOsu::acronym()
7247            }
7248            Self::TargetPracticeOsu(m) => {
7249                if let Some(value) = m.seed {
7250                    settings.insert(Box::from("seed"), SettingSimple::Number(value));
7251                }
7252                if let Some(value) = m.metronome {
7253                    settings.insert(Box::from("metronome"), SettingSimple::Bool(value));
7254                }
7255                TargetPracticeOsu::acronym()
7256            }
7257            Self::DifficultyAdjustOsu(m) => {
7258                if let Some(value) = m.circle_size {
7259                    settings.insert(Box::from("circle_size"), SettingSimple::Number(value));
7260                }
7261                if let Some(value) = m.approach_rate {
7262                    settings.insert(Box::from("approach_rate"), SettingSimple::Number(value));
7263                }
7264                if let Some(value) = m.drain_rate {
7265                    settings.insert(Box::from("drain_rate"), SettingSimple::Number(value));
7266                }
7267                if let Some(value) = m.overall_difficulty {
7268                    settings.insert(
7269                        Box::from("overall_difficulty"),
7270                        SettingSimple::Number(value),
7271                    );
7272                }
7273                if let Some(value) = m.extended_limits {
7274                    settings.insert(Box::from("extended_limits"), SettingSimple::Bool(value));
7275                }
7276                DifficultyAdjustOsu::acronym()
7277            }
7278            Self::ClassicOsu(m) => {
7279                if let Some(value) = m.no_slider_head_accuracy {
7280                    settings.insert(
7281                        Box::from("no_slider_head_accuracy"),
7282                        SettingSimple::Bool(value),
7283                    );
7284                }
7285                if let Some(value) = m.classic_note_lock {
7286                    settings.insert(Box::from("classic_note_lock"), SettingSimple::Bool(value));
7287                }
7288                if let Some(value) = m.always_play_tail_sample {
7289                    settings.insert(
7290                        Box::from("always_play_tail_sample"),
7291                        SettingSimple::Bool(value),
7292                    );
7293                }
7294                if let Some(value) = m.fade_hit_circle_early {
7295                    settings.insert(
7296                        Box::from("fade_hit_circle_early"),
7297                        SettingSimple::Bool(value),
7298                    );
7299                }
7300                if let Some(value) = m.classic_health {
7301                    settings.insert(Box::from("classic_health"), SettingSimple::Bool(value));
7302                }
7303                ClassicOsu::acronym()
7304            }
7305            Self::RandomOsu(m) => {
7306                if let Some(value) = m.angle_sharpness {
7307                    settings.insert(Box::from("angle_sharpness"), SettingSimple::Number(value));
7308                }
7309                if let Some(value) = m.seed {
7310                    settings.insert(Box::from("seed"), SettingSimple::Number(value));
7311                }
7312                RandomOsu::acronym()
7313            }
7314            Self::MirrorOsu(m) => {
7315                if let Some(value) = m.reflection {
7316                    settings.insert(Box::from("reflection"), SettingSimple::String(value));
7317                }
7318                MirrorOsu::acronym()
7319            }
7320            Self::AlternateOsu(_) => AlternateOsu::acronym(),
7321            Self::SingleTapOsu(_) => SingleTapOsu::acronym(),
7322            Self::AutoplayOsu(_) => AutoplayOsu::acronym(),
7323            Self::CinemaOsu(_) => CinemaOsu::acronym(),
7324            Self::RelaxOsu(_) => RelaxOsu::acronym(),
7325            Self::AutopilotOsu(_) => AutopilotOsu::acronym(),
7326            Self::SpunOutOsu(_) => SpunOutOsu::acronym(),
7327            Self::TransformOsu(_) => TransformOsu::acronym(),
7328            Self::WiggleOsu(m) => {
7329                if let Some(value) = m.strength {
7330                    settings.insert(Box::from("strength"), SettingSimple::Number(value));
7331                }
7332                WiggleOsu::acronym()
7333            }
7334            Self::SpinInOsu(_) => SpinInOsu::acronym(),
7335            Self::GrowOsu(m) => {
7336                if let Some(value) = m.start_scale {
7337                    settings.insert(Box::from("start_scale"), SettingSimple::Number(value));
7338                }
7339                GrowOsu::acronym()
7340            }
7341            Self::DeflateOsu(m) => {
7342                if let Some(value) = m.start_scale {
7343                    settings.insert(Box::from("start_scale"), SettingSimple::Number(value));
7344                }
7345                DeflateOsu::acronym()
7346            }
7347            Self::WindUpOsu(m) => {
7348                if let Some(value) = m.initial_rate {
7349                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7350                }
7351                if let Some(value) = m.final_rate {
7352                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7353                }
7354                if let Some(value) = m.adjust_pitch {
7355                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7356                }
7357                WindUpOsu::acronym()
7358            }
7359            Self::WindDownOsu(m) => {
7360                if let Some(value) = m.initial_rate {
7361                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7362                }
7363                if let Some(value) = m.final_rate {
7364                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7365                }
7366                if let Some(value) = m.adjust_pitch {
7367                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7368                }
7369                WindDownOsu::acronym()
7370            }
7371            Self::BarrelRollOsu(m) => {
7372                if let Some(value) = m.spin_speed {
7373                    settings.insert(Box::from("spin_speed"), SettingSimple::Number(value));
7374                }
7375                if let Some(value) = m.direction {
7376                    settings.insert(Box::from("direction"), SettingSimple::String(value));
7377                }
7378                BarrelRollOsu::acronym()
7379            }
7380            Self::ApproachDifferentOsu(m) => {
7381                if let Some(value) = m.scale {
7382                    settings.insert(Box::from("scale"), SettingSimple::Number(value));
7383                }
7384                if let Some(value) = m.style {
7385                    settings.insert(Box::from("style"), SettingSimple::String(value));
7386                }
7387                ApproachDifferentOsu::acronym()
7388            }
7389            Self::MutedOsu(m) => {
7390                if let Some(value) = m.inverse_muting {
7391                    settings.insert(Box::from("inverse_muting"), SettingSimple::Bool(value));
7392                }
7393                if let Some(value) = m.enable_metronome {
7394                    settings.insert(Box::from("enable_metronome"), SettingSimple::Bool(value));
7395                }
7396                if let Some(value) = m.mute_combo_count {
7397                    settings.insert(Box::from("mute_combo_count"), SettingSimple::Number(value));
7398                }
7399                if let Some(value) = m.affects_hit_sounds {
7400                    settings.insert(Box::from("affects_hit_sounds"), SettingSimple::Bool(value));
7401                }
7402                MutedOsu::acronym()
7403            }
7404            Self::NoScopeOsu(m) => {
7405                if let Some(value) = m.hidden_combo_count {
7406                    settings.insert(
7407                        Box::from("hidden_combo_count"),
7408                        SettingSimple::Number(value),
7409                    );
7410                }
7411                NoScopeOsu::acronym()
7412            }
7413            Self::MagnetisedOsu(m) => {
7414                if let Some(value) = m.attraction_strength {
7415                    settings.insert(
7416                        Box::from("attraction_strength"),
7417                        SettingSimple::Number(value),
7418                    );
7419                }
7420                MagnetisedOsu::acronym()
7421            }
7422            Self::RepelOsu(m) => {
7423                if let Some(value) = m.repulsion_strength {
7424                    settings.insert(
7425                        Box::from("repulsion_strength"),
7426                        SettingSimple::Number(value),
7427                    );
7428                }
7429                RepelOsu::acronym()
7430            }
7431            Self::AdaptiveSpeedOsu(m) => {
7432                if let Some(value) = m.initial_rate {
7433                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7434                }
7435                if let Some(value) = m.adjust_pitch {
7436                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7437                }
7438                AdaptiveSpeedOsu::acronym()
7439            }
7440            Self::FreezeFrameOsu(_) => FreezeFrameOsu::acronym(),
7441            Self::BubblesOsu(_) => BubblesOsu::acronym(),
7442            Self::SynesthesiaOsu(_) => SynesthesiaOsu::acronym(),
7443            Self::DepthOsu(m) => {
7444                if let Some(value) = m.max_depth {
7445                    settings.insert(Box::from("max_depth"), SettingSimple::Number(value));
7446                }
7447                if let Some(value) = m.show_approach_circles {
7448                    settings.insert(
7449                        Box::from("show_approach_circles"),
7450                        SettingSimple::Bool(value),
7451                    );
7452                }
7453                DepthOsu::acronym()
7454            }
7455            Self::BloomOsu(m) => {
7456                if let Some(value) = m.max_size_combo_count {
7457                    settings.insert(
7458                        Box::from("max_size_combo_count"),
7459                        SettingSimple::Number(value),
7460                    );
7461                }
7462                if let Some(value) = m.max_cursor_size {
7463                    settings.insert(Box::from("max_cursor_size"), SettingSimple::Number(value));
7464                }
7465                BloomOsu::acronym()
7466            }
7467            Self::TouchDeviceOsu(_) => TouchDeviceOsu::acronym(),
7468            Self::ScoreV2Osu(_) => ScoreV2Osu::acronym(),
7469            Self::EasyTaiko(_) => EasyTaiko::acronym(),
7470            Self::NoFailTaiko(_) => NoFailTaiko::acronym(),
7471            Self::HalfTimeTaiko(m) => {
7472                if let Some(value) = m.speed_change {
7473                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7474                }
7475                if let Some(value) = m.adjust_pitch {
7476                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7477                }
7478                HalfTimeTaiko::acronym()
7479            }
7480            Self::DaycoreTaiko(m) => {
7481                if let Some(value) = m.speed_change {
7482                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7483                }
7484                DaycoreTaiko::acronym()
7485            }
7486            Self::SimplifiedRhythmTaiko(m) => {
7487                if let Some(value) = m.one_third_conversion {
7488                    settings.insert(
7489                        Box::from("one_third_conversion"),
7490                        SettingSimple::Bool(value),
7491                    );
7492                }
7493                if let Some(value) = m.one_sixth_conversion {
7494                    settings.insert(
7495                        Box::from("one_sixth_conversion"),
7496                        SettingSimple::Bool(value),
7497                    );
7498                }
7499                if let Some(value) = m.one_eighth_conversion {
7500                    settings.insert(
7501                        Box::from("one_eighth_conversion"),
7502                        SettingSimple::Bool(value),
7503                    );
7504                }
7505                SimplifiedRhythmTaiko::acronym()
7506            }
7507            Self::HardRockTaiko(_) => HardRockTaiko::acronym(),
7508            Self::SuddenDeathTaiko(m) => {
7509                if let Some(value) = m.restart {
7510                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7511                }
7512                SuddenDeathTaiko::acronym()
7513            }
7514            Self::PerfectTaiko(m) => {
7515                if let Some(value) = m.restart {
7516                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7517                }
7518                PerfectTaiko::acronym()
7519            }
7520            Self::DoubleTimeTaiko(m) => {
7521                if let Some(value) = m.speed_change {
7522                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7523                }
7524                if let Some(value) = m.adjust_pitch {
7525                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7526                }
7527                DoubleTimeTaiko::acronym()
7528            }
7529            Self::NightcoreTaiko(m) => {
7530                if let Some(value) = m.speed_change {
7531                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7532                }
7533                NightcoreTaiko::acronym()
7534            }
7535            Self::HiddenTaiko(_) => HiddenTaiko::acronym(),
7536            Self::FlashlightTaiko(m) => {
7537                if let Some(value) = m.size_multiplier {
7538                    settings.insert(Box::from("size_multiplier"), SettingSimple::Number(value));
7539                }
7540                if let Some(value) = m.combo_based_size {
7541                    settings.insert(Box::from("combo_based_size"), SettingSimple::Bool(value));
7542                }
7543                FlashlightTaiko::acronym()
7544            }
7545            Self::AccuracyChallengeTaiko(m) => {
7546                if let Some(value) = m.minimum_accuracy {
7547                    settings.insert(Box::from("minimum_accuracy"), SettingSimple::Number(value));
7548                }
7549                if let Some(value) = m.accuracy_judge_mode {
7550                    settings.insert(
7551                        Box::from("accuracy_judge_mode"),
7552                        SettingSimple::String(value),
7553                    );
7554                }
7555                if let Some(value) = m.restart {
7556                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7557                }
7558                AccuracyChallengeTaiko::acronym()
7559            }
7560            Self::RandomTaiko(m) => {
7561                if let Some(value) = m.seed {
7562                    settings.insert(Box::from("seed"), SettingSimple::Number(value));
7563                }
7564                RandomTaiko::acronym()
7565            }
7566            Self::DifficultyAdjustTaiko(m) => {
7567                if let Some(value) = m.scroll_speed {
7568                    settings.insert(Box::from("scroll_speed"), SettingSimple::Number(value));
7569                }
7570                if let Some(value) = m.drain_rate {
7571                    settings.insert(Box::from("drain_rate"), SettingSimple::Number(value));
7572                }
7573                if let Some(value) = m.overall_difficulty {
7574                    settings.insert(
7575                        Box::from("overall_difficulty"),
7576                        SettingSimple::Number(value),
7577                    );
7578                }
7579                if let Some(value) = m.extended_limits {
7580                    settings.insert(Box::from("extended_limits"), SettingSimple::Bool(value));
7581                }
7582                DifficultyAdjustTaiko::acronym()
7583            }
7584            Self::ClassicTaiko(_) => ClassicTaiko::acronym(),
7585            Self::SwapTaiko(_) => SwapTaiko::acronym(),
7586            Self::SingleTapTaiko(_) => SingleTapTaiko::acronym(),
7587            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::acronym(),
7588            Self::AutoplayTaiko(_) => AutoplayTaiko::acronym(),
7589            Self::CinemaTaiko(_) => CinemaTaiko::acronym(),
7590            Self::RelaxTaiko(_) => RelaxTaiko::acronym(),
7591            Self::WindUpTaiko(m) => {
7592                if let Some(value) = m.initial_rate {
7593                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7594                }
7595                if let Some(value) = m.final_rate {
7596                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7597                }
7598                if let Some(value) = m.adjust_pitch {
7599                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7600                }
7601                WindUpTaiko::acronym()
7602            }
7603            Self::WindDownTaiko(m) => {
7604                if let Some(value) = m.initial_rate {
7605                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7606                }
7607                if let Some(value) = m.final_rate {
7608                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7609                }
7610                if let Some(value) = m.adjust_pitch {
7611                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7612                }
7613                WindDownTaiko::acronym()
7614            }
7615            Self::MutedTaiko(m) => {
7616                if let Some(value) = m.inverse_muting {
7617                    settings.insert(Box::from("inverse_muting"), SettingSimple::Bool(value));
7618                }
7619                if let Some(value) = m.enable_metronome {
7620                    settings.insert(Box::from("enable_metronome"), SettingSimple::Bool(value));
7621                }
7622                if let Some(value) = m.mute_combo_count {
7623                    settings.insert(Box::from("mute_combo_count"), SettingSimple::Number(value));
7624                }
7625                if let Some(value) = m.affects_hit_sounds {
7626                    settings.insert(Box::from("affects_hit_sounds"), SettingSimple::Bool(value));
7627                }
7628                MutedTaiko::acronym()
7629            }
7630            Self::AdaptiveSpeedTaiko(m) => {
7631                if let Some(value) = m.initial_rate {
7632                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7633                }
7634                if let Some(value) = m.adjust_pitch {
7635                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7636                }
7637                AdaptiveSpeedTaiko::acronym()
7638            }
7639            Self::ScoreV2Taiko(_) => ScoreV2Taiko::acronym(),
7640            Self::EasyCatch(m) => {
7641                if let Some(value) = m.retries {
7642                    settings.insert(Box::from("retries"), SettingSimple::Number(value));
7643                }
7644                EasyCatch::acronym()
7645            }
7646            Self::NoFailCatch(_) => NoFailCatch::acronym(),
7647            Self::HalfTimeCatch(m) => {
7648                if let Some(value) = m.speed_change {
7649                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7650                }
7651                if let Some(value) = m.adjust_pitch {
7652                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7653                }
7654                HalfTimeCatch::acronym()
7655            }
7656            Self::DaycoreCatch(m) => {
7657                if let Some(value) = m.speed_change {
7658                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7659                }
7660                DaycoreCatch::acronym()
7661            }
7662            Self::HardRockCatch(_) => HardRockCatch::acronym(),
7663            Self::SuddenDeathCatch(m) => {
7664                if let Some(value) = m.restart {
7665                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7666                }
7667                SuddenDeathCatch::acronym()
7668            }
7669            Self::PerfectCatch(m) => {
7670                if let Some(value) = m.restart {
7671                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7672                }
7673                PerfectCatch::acronym()
7674            }
7675            Self::DoubleTimeCatch(m) => {
7676                if let Some(value) = m.speed_change {
7677                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7678                }
7679                if let Some(value) = m.adjust_pitch {
7680                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7681                }
7682                DoubleTimeCatch::acronym()
7683            }
7684            Self::NightcoreCatch(m) => {
7685                if let Some(value) = m.speed_change {
7686                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7687                }
7688                NightcoreCatch::acronym()
7689            }
7690            Self::HiddenCatch(_) => HiddenCatch::acronym(),
7691            Self::FlashlightCatch(m) => {
7692                if let Some(value) = m.size_multiplier {
7693                    settings.insert(Box::from("size_multiplier"), SettingSimple::Number(value));
7694                }
7695                if let Some(value) = m.combo_based_size {
7696                    settings.insert(Box::from("combo_based_size"), SettingSimple::Bool(value));
7697                }
7698                FlashlightCatch::acronym()
7699            }
7700            Self::AccuracyChallengeCatch(m) => {
7701                if let Some(value) = m.minimum_accuracy {
7702                    settings.insert(Box::from("minimum_accuracy"), SettingSimple::Number(value));
7703                }
7704                if let Some(value) = m.accuracy_judge_mode {
7705                    settings.insert(
7706                        Box::from("accuracy_judge_mode"),
7707                        SettingSimple::String(value),
7708                    );
7709                }
7710                if let Some(value) = m.restart {
7711                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7712                }
7713                AccuracyChallengeCatch::acronym()
7714            }
7715            Self::DifficultyAdjustCatch(m) => {
7716                if let Some(value) = m.circle_size {
7717                    settings.insert(Box::from("circle_size"), SettingSimple::Number(value));
7718                }
7719                if let Some(value) = m.approach_rate {
7720                    settings.insert(Box::from("approach_rate"), SettingSimple::Number(value));
7721                }
7722                if let Some(value) = m.hard_rock_offsets {
7723                    settings.insert(Box::from("hard_rock_offsets"), SettingSimple::Bool(value));
7724                }
7725                if let Some(value) = m.drain_rate {
7726                    settings.insert(Box::from("drain_rate"), SettingSimple::Number(value));
7727                }
7728                if let Some(value) = m.overall_difficulty {
7729                    settings.insert(
7730                        Box::from("overall_difficulty"),
7731                        SettingSimple::Number(value),
7732                    );
7733                }
7734                if let Some(value) = m.extended_limits {
7735                    settings.insert(Box::from("extended_limits"), SettingSimple::Bool(value));
7736                }
7737                DifficultyAdjustCatch::acronym()
7738            }
7739            Self::ClassicCatch(_) => ClassicCatch::acronym(),
7740            Self::MirrorCatch(_) => MirrorCatch::acronym(),
7741            Self::AutoplayCatch(_) => AutoplayCatch::acronym(),
7742            Self::CinemaCatch(_) => CinemaCatch::acronym(),
7743            Self::RelaxCatch(_) => RelaxCatch::acronym(),
7744            Self::WindUpCatch(m) => {
7745                if let Some(value) = m.initial_rate {
7746                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7747                }
7748                if let Some(value) = m.final_rate {
7749                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7750                }
7751                if let Some(value) = m.adjust_pitch {
7752                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7753                }
7754                WindUpCatch::acronym()
7755            }
7756            Self::WindDownCatch(m) => {
7757                if let Some(value) = m.initial_rate {
7758                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7759                }
7760                if let Some(value) = m.final_rate {
7761                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7762                }
7763                if let Some(value) = m.adjust_pitch {
7764                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7765                }
7766                WindDownCatch::acronym()
7767            }
7768            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::acronym(),
7769            Self::MutedCatch(m) => {
7770                if let Some(value) = m.inverse_muting {
7771                    settings.insert(Box::from("inverse_muting"), SettingSimple::Bool(value));
7772                }
7773                if let Some(value) = m.enable_metronome {
7774                    settings.insert(Box::from("enable_metronome"), SettingSimple::Bool(value));
7775                }
7776                if let Some(value) = m.mute_combo_count {
7777                    settings.insert(Box::from("mute_combo_count"), SettingSimple::Number(value));
7778                }
7779                if let Some(value) = m.affects_hit_sounds {
7780                    settings.insert(Box::from("affects_hit_sounds"), SettingSimple::Bool(value));
7781                }
7782                MutedCatch::acronym()
7783            }
7784            Self::NoScopeCatch(m) => {
7785                if let Some(value) = m.hidden_combo_count {
7786                    settings.insert(
7787                        Box::from("hidden_combo_count"),
7788                        SettingSimple::Number(value),
7789                    );
7790                }
7791                NoScopeCatch::acronym()
7792            }
7793            Self::MovingFastCatch(_) => MovingFastCatch::acronym(),
7794            Self::ScoreV2Catch(_) => ScoreV2Catch::acronym(),
7795            Self::EasyMania(m) => {
7796                if let Some(value) = m.retries {
7797                    settings.insert(Box::from("retries"), SettingSimple::Number(value));
7798                }
7799                EasyMania::acronym()
7800            }
7801            Self::NoFailMania(_) => NoFailMania::acronym(),
7802            Self::HalfTimeMania(m) => {
7803                if let Some(value) = m.speed_change {
7804                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7805                }
7806                if let Some(value) = m.adjust_pitch {
7807                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7808                }
7809                HalfTimeMania::acronym()
7810            }
7811            Self::DaycoreMania(m) => {
7812                if let Some(value) = m.speed_change {
7813                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7814                }
7815                DaycoreMania::acronym()
7816            }
7817            Self::NoReleaseMania(_) => NoReleaseMania::acronym(),
7818            Self::HardRockMania(_) => HardRockMania::acronym(),
7819            Self::SuddenDeathMania(m) => {
7820                if let Some(value) = m.restart {
7821                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7822                }
7823                SuddenDeathMania::acronym()
7824            }
7825            Self::PerfectMania(m) => {
7826                if let Some(value) = m.require_perfect_hits {
7827                    settings.insert(
7828                        Box::from("require_perfect_hits"),
7829                        SettingSimple::Bool(value),
7830                    );
7831                }
7832                if let Some(value) = m.restart {
7833                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7834                }
7835                PerfectMania::acronym()
7836            }
7837            Self::DoubleTimeMania(m) => {
7838                if let Some(value) = m.speed_change {
7839                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7840                }
7841                if let Some(value) = m.adjust_pitch {
7842                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7843                }
7844                DoubleTimeMania::acronym()
7845            }
7846            Self::NightcoreMania(m) => {
7847                if let Some(value) = m.speed_change {
7848                    settings.insert(Box::from("speed_change"), SettingSimple::Number(value));
7849                }
7850                NightcoreMania::acronym()
7851            }
7852            Self::FadeInMania(_) => FadeInMania::acronym(),
7853            Self::HiddenMania(_) => HiddenMania::acronym(),
7854            Self::CoverMania(m) => {
7855                if let Some(value) = m.coverage {
7856                    settings.insert(Box::from("coverage"), SettingSimple::Number(value));
7857                }
7858                if let Some(value) = m.direction {
7859                    settings.insert(Box::from("direction"), SettingSimple::String(value));
7860                }
7861                CoverMania::acronym()
7862            }
7863            Self::FlashlightMania(m) => {
7864                if let Some(value) = m.size_multiplier {
7865                    settings.insert(Box::from("size_multiplier"), SettingSimple::Number(value));
7866                }
7867                if let Some(value) = m.combo_based_size {
7868                    settings.insert(Box::from("combo_based_size"), SettingSimple::Bool(value));
7869                }
7870                FlashlightMania::acronym()
7871            }
7872            Self::AccuracyChallengeMania(m) => {
7873                if let Some(value) = m.minimum_accuracy {
7874                    settings.insert(Box::from("minimum_accuracy"), SettingSimple::Number(value));
7875                }
7876                if let Some(value) = m.accuracy_judge_mode {
7877                    settings.insert(
7878                        Box::from("accuracy_judge_mode"),
7879                        SettingSimple::String(value),
7880                    );
7881                }
7882                if let Some(value) = m.restart {
7883                    settings.insert(Box::from("restart"), SettingSimple::Bool(value));
7884                }
7885                AccuracyChallengeMania::acronym()
7886            }
7887            Self::RandomMania(m) => {
7888                if let Some(value) = m.seed {
7889                    settings.insert(Box::from("seed"), SettingSimple::Number(value));
7890                }
7891                RandomMania::acronym()
7892            }
7893            Self::DualStagesMania(_) => DualStagesMania::acronym(),
7894            Self::MirrorMania(_) => MirrorMania::acronym(),
7895            Self::DifficultyAdjustMania(m) => {
7896                if let Some(value) = m.overall_difficulty {
7897                    settings.insert(
7898                        Box::from("overall_difficulty"),
7899                        SettingSimple::Number(value),
7900                    );
7901                }
7902                if let Some(value) = m.drain_rate {
7903                    settings.insert(Box::from("drain_rate"), SettingSimple::Number(value));
7904                }
7905                if let Some(value) = m.extended_limits {
7906                    settings.insert(Box::from("extended_limits"), SettingSimple::Bool(value));
7907                }
7908                DifficultyAdjustMania::acronym()
7909            }
7910            Self::ClassicMania(_) => ClassicMania::acronym(),
7911            Self::InvertMania(_) => InvertMania::acronym(),
7912            Self::ConstantSpeedMania(_) => ConstantSpeedMania::acronym(),
7913            Self::HoldOffMania(_) => HoldOffMania::acronym(),
7914            Self::OneKeyMania(_) => OneKeyMania::acronym(),
7915            Self::TwoKeysMania(_) => TwoKeysMania::acronym(),
7916            Self::ThreeKeysMania(_) => ThreeKeysMania::acronym(),
7917            Self::FourKeysMania(_) => FourKeysMania::acronym(),
7918            Self::FiveKeysMania(_) => FiveKeysMania::acronym(),
7919            Self::SixKeysMania(_) => SixKeysMania::acronym(),
7920            Self::SevenKeysMania(_) => SevenKeysMania::acronym(),
7921            Self::EightKeysMania(_) => EightKeysMania::acronym(),
7922            Self::NineKeysMania(_) => NineKeysMania::acronym(),
7923            Self::TenKeysMania(_) => TenKeysMania::acronym(),
7924            Self::AutoplayMania(_) => AutoplayMania::acronym(),
7925            Self::CinemaMania(_) => CinemaMania::acronym(),
7926            Self::WindUpMania(m) => {
7927                if let Some(value) = m.initial_rate {
7928                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7929                }
7930                if let Some(value) = m.final_rate {
7931                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7932                }
7933                if let Some(value) = m.adjust_pitch {
7934                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7935                }
7936                WindUpMania::acronym()
7937            }
7938            Self::WindDownMania(m) => {
7939                if let Some(value) = m.initial_rate {
7940                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7941                }
7942                if let Some(value) = m.final_rate {
7943                    settings.insert(Box::from("final_rate"), SettingSimple::Number(value));
7944                }
7945                if let Some(value) = m.adjust_pitch {
7946                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7947                }
7948                WindDownMania::acronym()
7949            }
7950            Self::MutedMania(m) => {
7951                if let Some(value) = m.inverse_muting {
7952                    settings.insert(Box::from("inverse_muting"), SettingSimple::Bool(value));
7953                }
7954                if let Some(value) = m.enable_metronome {
7955                    settings.insert(Box::from("enable_metronome"), SettingSimple::Bool(value));
7956                }
7957                if let Some(value) = m.mute_combo_count {
7958                    settings.insert(Box::from("mute_combo_count"), SettingSimple::Number(value));
7959                }
7960                if let Some(value) = m.affects_hit_sounds {
7961                    settings.insert(Box::from("affects_hit_sounds"), SettingSimple::Bool(value));
7962                }
7963                MutedMania::acronym()
7964            }
7965            Self::AdaptiveSpeedMania(m) => {
7966                if let Some(value) = m.initial_rate {
7967                    settings.insert(Box::from("initial_rate"), SettingSimple::Number(value));
7968                }
7969                if let Some(value) = m.adjust_pitch {
7970                    settings.insert(Box::from("adjust_pitch"), SettingSimple::Bool(value));
7971                }
7972                AdaptiveSpeedMania::acronym()
7973            }
7974            Self::ScoreV2Mania(_) => ScoreV2Mania::acronym(),
7975            Self::UnknownOsu(m) => m.acronym(),
7976            Self::UnknownTaiko(m) => m.acronym(),
7977            Self::UnknownCatch(m) => m.acronym(),
7978            Self::UnknownMania(m) => m.acronym(),
7979        };
7980        GameModSimple { acronym, settings }
7981    }
7982}
7983impl From<GameMod> for GameModSimple {
7984    fn from(gamemod: GameMod) -> Self {
7985        gamemod.into_simple()
7986    }
7987}
7988impl PartialOrd for GameMod {
7989    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
7990        self.bits()
7991            .zip(other.bits())
7992            .map(|(self_bits, other_bits)| self_bits.cmp(&other_bits))
7993    }
7994}
7995#[cfg(feature = "serde")]
7996#[cfg_attr(all(docsrs, not(doctest)), doc(cfg(feature = "serde")))]
7997const _: () = {
7998    use serde::{
7999        de::{
8000            value::MapAccessDeserializer, DeserializeSeed, Deserializer, Error as DeError,
8001            IgnoredAny, MapAccess, Visitor,
8002        },
8003        ser::{Serialize, SerializeMap, Serializer},
8004        Deserialize,
8005    };
8006
8007    use crate::serde::{
8008        DeserializedGameMod, GameModRaw, GameModRawSeed, GameModSettings, GameModSettingsSeed,
8009        GameModVisitor, MaybeOwnedStr,
8010    };
8011
8012    impl<'de> Visitor<'de> for GameModVisitor<EasyOsu> {
8013        type Value = DeserializedGameMod<'de, EasyOsu>;
8014        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8015            f.write_str("EasyOsu")
8016        }
8017        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8018            const FIELDS: &'static [&'static str] = &["retries"];
8019            let mut unknown_key__ = None;
8020            let mut retries = None;
8021            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8022                match key.as_str() {
8023                    "retries" => retries = Some(map.next_value()?),
8024                    _ => {
8025                        unknown_key__ = Some(key);
8026                        let _: IgnoredAny = map.next_value()?;
8027                    }
8028                }
8029            }
8030            let gamemod = EasyOsu {
8031                retries: retries.unwrap_or_default(),
8032            };
8033            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8034        }
8035    }
8036    impl Serialize for EasyOsu {
8037        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8038            let field_count = self.retries.is_some() as usize;
8039            let mut map = s.serialize_map(Some(field_count))?;
8040            if let Some(ref x) = self.retries {
8041                map.serialize_entry("retries", x)?;
8042            }
8043            map.end()
8044        }
8045    }
8046    impl<'de> Visitor<'de> for GameModVisitor<NoFailOsu> {
8047        type Value = DeserializedGameMod<'de, NoFailOsu>;
8048        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8049            f.write_str("NoFailOsu")
8050        }
8051        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8052            const FIELDS: &'static [&'static str] = &[];
8053            let mut unknown_key__ = None;
8054            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8055                match key.as_str() {
8056                    _ => {
8057                        unknown_key__ = Some(key);
8058                        let _: IgnoredAny = map.next_value()?;
8059                    }
8060                }
8061            }
8062            let gamemod = NoFailOsu {};
8063            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8064        }
8065    }
8066    impl Serialize for NoFailOsu {
8067        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8068            let field_count = 0;
8069            let map = s.serialize_map(Some(field_count))?;
8070            map.end()
8071        }
8072    }
8073    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeOsu> {
8074        type Value = DeserializedGameMod<'de, HalfTimeOsu>;
8075        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8076            f.write_str("HalfTimeOsu")
8077        }
8078        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8079            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
8080            let mut unknown_key__ = None;
8081            let mut speed_change = None;
8082            let mut adjust_pitch = None;
8083            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8084                match key.as_str() {
8085                    "speed_change" => speed_change = Some(map.next_value()?),
8086                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8087                    _ => {
8088                        unknown_key__ = Some(key);
8089                        let _: IgnoredAny = map.next_value()?;
8090                    }
8091                }
8092            }
8093            let gamemod = HalfTimeOsu {
8094                speed_change: speed_change.unwrap_or_default(),
8095                adjust_pitch: adjust_pitch.unwrap_or_default(),
8096            };
8097            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8098        }
8099    }
8100    impl Serialize for HalfTimeOsu {
8101        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8102            let field_count =
8103                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
8104            let mut map = s.serialize_map(Some(field_count))?;
8105            if let Some(ref x) = self.speed_change {
8106                map.serialize_entry("speed_change", x)?;
8107            }
8108            if let Some(ref x) = self.adjust_pitch {
8109                map.serialize_entry("adjust_pitch", x)?;
8110            }
8111            map.end()
8112        }
8113    }
8114    impl<'de> Visitor<'de> for GameModVisitor<DaycoreOsu> {
8115        type Value = DeserializedGameMod<'de, DaycoreOsu>;
8116        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8117            f.write_str("DaycoreOsu")
8118        }
8119        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8120            const FIELDS: &'static [&'static str] = &["speed_change"];
8121            let mut unknown_key__ = None;
8122            let mut speed_change = None;
8123            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8124                match key.as_str() {
8125                    "speed_change" => speed_change = Some(map.next_value()?),
8126                    _ => {
8127                        unknown_key__ = Some(key);
8128                        let _: IgnoredAny = map.next_value()?;
8129                    }
8130                }
8131            }
8132            let gamemod = DaycoreOsu {
8133                speed_change: speed_change.unwrap_or_default(),
8134            };
8135            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8136        }
8137    }
8138    impl Serialize for DaycoreOsu {
8139        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8140            let field_count = self.speed_change.is_some() as usize;
8141            let mut map = s.serialize_map(Some(field_count))?;
8142            if let Some(ref x) = self.speed_change {
8143                map.serialize_entry("speed_change", x)?;
8144            }
8145            map.end()
8146        }
8147    }
8148    impl<'de> Visitor<'de> for GameModVisitor<HardRockOsu> {
8149        type Value = DeserializedGameMod<'de, HardRockOsu>;
8150        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8151            f.write_str("HardRockOsu")
8152        }
8153        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8154            const FIELDS: &'static [&'static str] = &[];
8155            let mut unknown_key__ = None;
8156            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8157                match key.as_str() {
8158                    _ => {
8159                        unknown_key__ = Some(key);
8160                        let _: IgnoredAny = map.next_value()?;
8161                    }
8162                }
8163            }
8164            let gamemod = HardRockOsu {};
8165            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8166        }
8167    }
8168    impl Serialize for HardRockOsu {
8169        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8170            let field_count = 0;
8171            let map = s.serialize_map(Some(field_count))?;
8172            map.end()
8173        }
8174    }
8175    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathOsu> {
8176        type Value = DeserializedGameMod<'de, SuddenDeathOsu>;
8177        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8178            f.write_str("SuddenDeathOsu")
8179        }
8180        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8181            const FIELDS: &'static [&'static str] = &["fail_on_slider_tail", "restart"];
8182            let mut unknown_key__ = None;
8183            let mut fail_on_slider_tail = None;
8184            let mut restart = None;
8185            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8186                match key.as_str() {
8187                    "fail_on_slider_tail" => fail_on_slider_tail = Some(map.next_value()?),
8188                    "restart" => restart = Some(map.next_value()?),
8189                    _ => {
8190                        unknown_key__ = Some(key);
8191                        let _: IgnoredAny = map.next_value()?;
8192                    }
8193                }
8194            }
8195            let gamemod = SuddenDeathOsu {
8196                fail_on_slider_tail: fail_on_slider_tail.unwrap_or_default(),
8197                restart: restart.unwrap_or_default(),
8198            };
8199            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8200        }
8201    }
8202    impl Serialize for SuddenDeathOsu {
8203        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8204            let field_count =
8205                self.fail_on_slider_tail.is_some() as usize + self.restart.is_some() as usize;
8206            let mut map = s.serialize_map(Some(field_count))?;
8207            if let Some(ref x) = self.fail_on_slider_tail {
8208                map.serialize_entry("fail_on_slider_tail", x)?;
8209            }
8210            if let Some(ref x) = self.restart {
8211                map.serialize_entry("restart", x)?;
8212            }
8213            map.end()
8214        }
8215    }
8216    impl<'de> Visitor<'de> for GameModVisitor<PerfectOsu> {
8217        type Value = DeserializedGameMod<'de, PerfectOsu>;
8218        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8219            f.write_str("PerfectOsu")
8220        }
8221        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8222            const FIELDS: &'static [&'static str] = &["restart"];
8223            let mut unknown_key__ = None;
8224            let mut restart = None;
8225            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8226                match key.as_str() {
8227                    "restart" => restart = Some(map.next_value()?),
8228                    _ => {
8229                        unknown_key__ = Some(key);
8230                        let _: IgnoredAny = map.next_value()?;
8231                    }
8232                }
8233            }
8234            let gamemod = PerfectOsu {
8235                restart: restart.unwrap_or_default(),
8236            };
8237            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8238        }
8239    }
8240    impl Serialize for PerfectOsu {
8241        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8242            let field_count = self.restart.is_some() as usize;
8243            let mut map = s.serialize_map(Some(field_count))?;
8244            if let Some(ref x) = self.restart {
8245                map.serialize_entry("restart", x)?;
8246            }
8247            map.end()
8248        }
8249    }
8250    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeOsu> {
8251        type Value = DeserializedGameMod<'de, DoubleTimeOsu>;
8252        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8253            f.write_str("DoubleTimeOsu")
8254        }
8255        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8256            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
8257            let mut unknown_key__ = None;
8258            let mut speed_change = None;
8259            let mut adjust_pitch = None;
8260            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8261                match key.as_str() {
8262                    "speed_change" => speed_change = Some(map.next_value()?),
8263                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8264                    _ => {
8265                        unknown_key__ = Some(key);
8266                        let _: IgnoredAny = map.next_value()?;
8267                    }
8268                }
8269            }
8270            let gamemod = DoubleTimeOsu {
8271                speed_change: speed_change.unwrap_or_default(),
8272                adjust_pitch: adjust_pitch.unwrap_or_default(),
8273            };
8274            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8275        }
8276    }
8277    impl Serialize for DoubleTimeOsu {
8278        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8279            let field_count =
8280                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
8281            let mut map = s.serialize_map(Some(field_count))?;
8282            if let Some(ref x) = self.speed_change {
8283                map.serialize_entry("speed_change", x)?;
8284            }
8285            if let Some(ref x) = self.adjust_pitch {
8286                map.serialize_entry("adjust_pitch", x)?;
8287            }
8288            map.end()
8289        }
8290    }
8291    impl<'de> Visitor<'de> for GameModVisitor<NightcoreOsu> {
8292        type Value = DeserializedGameMod<'de, NightcoreOsu>;
8293        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8294            f.write_str("NightcoreOsu")
8295        }
8296        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8297            const FIELDS: &'static [&'static str] = &["speed_change"];
8298            let mut unknown_key__ = None;
8299            let mut speed_change = None;
8300            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8301                match key.as_str() {
8302                    "speed_change" => speed_change = Some(map.next_value()?),
8303                    _ => {
8304                        unknown_key__ = Some(key);
8305                        let _: IgnoredAny = map.next_value()?;
8306                    }
8307                }
8308            }
8309            let gamemod = NightcoreOsu {
8310                speed_change: speed_change.unwrap_or_default(),
8311            };
8312            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8313        }
8314    }
8315    impl Serialize for NightcoreOsu {
8316        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8317            let field_count = self.speed_change.is_some() as usize;
8318            let mut map = s.serialize_map(Some(field_count))?;
8319            if let Some(ref x) = self.speed_change {
8320                map.serialize_entry("speed_change", x)?;
8321            }
8322            map.end()
8323        }
8324    }
8325    impl<'de> Visitor<'de> for GameModVisitor<HiddenOsu> {
8326        type Value = DeserializedGameMod<'de, HiddenOsu>;
8327        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8328            f.write_str("HiddenOsu")
8329        }
8330        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8331            const FIELDS: &'static [&'static str] = &["only_fade_approach_circles"];
8332            let mut unknown_key__ = None;
8333            let mut only_fade_approach_circles = None;
8334            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8335                match key.as_str() {
8336                    "only_fade_approach_circles" => {
8337                        only_fade_approach_circles = Some(map.next_value()?)
8338                    }
8339                    _ => {
8340                        unknown_key__ = Some(key);
8341                        let _: IgnoredAny = map.next_value()?;
8342                    }
8343                }
8344            }
8345            let gamemod = HiddenOsu {
8346                only_fade_approach_circles: only_fade_approach_circles.unwrap_or_default(),
8347            };
8348            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8349        }
8350    }
8351    impl Serialize for HiddenOsu {
8352        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8353            let field_count = self.only_fade_approach_circles.is_some() as usize;
8354            let mut map = s.serialize_map(Some(field_count))?;
8355            if let Some(ref x) = self.only_fade_approach_circles {
8356                map.serialize_entry("only_fade_approach_circles", x)?;
8357            }
8358            map.end()
8359        }
8360    }
8361    impl<'de> Visitor<'de> for GameModVisitor<TraceableOsu> {
8362        type Value = DeserializedGameMod<'de, TraceableOsu>;
8363        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8364            f.write_str("TraceableOsu")
8365        }
8366        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8367            const FIELDS: &'static [&'static str] = &[];
8368            let mut unknown_key__ = None;
8369            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8370                match key.as_str() {
8371                    _ => {
8372                        unknown_key__ = Some(key);
8373                        let _: IgnoredAny = map.next_value()?;
8374                    }
8375                }
8376            }
8377            let gamemod = TraceableOsu {};
8378            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8379        }
8380    }
8381    impl Serialize for TraceableOsu {
8382        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8383            let field_count = 0;
8384            let map = s.serialize_map(Some(field_count))?;
8385            map.end()
8386        }
8387    }
8388    impl<'de> Visitor<'de> for GameModVisitor<FlashlightOsu> {
8389        type Value = DeserializedGameMod<'de, FlashlightOsu>;
8390        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8391            f.write_str("FlashlightOsu")
8392        }
8393        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8394            const FIELDS: &'static [&'static str] =
8395                &["follow_delay", "size_multiplier", "combo_based_size"];
8396            let mut unknown_key__ = None;
8397            let mut follow_delay = None;
8398            let mut size_multiplier = None;
8399            let mut combo_based_size = None;
8400            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8401                match key.as_str() {
8402                    "follow_delay" => follow_delay = Some(map.next_value()?),
8403                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
8404                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
8405                    _ => {
8406                        unknown_key__ = Some(key);
8407                        let _: IgnoredAny = map.next_value()?;
8408                    }
8409                }
8410            }
8411            let gamemod = FlashlightOsu {
8412                follow_delay: follow_delay.unwrap_or_default(),
8413                size_multiplier: size_multiplier.unwrap_or_default(),
8414                combo_based_size: combo_based_size.unwrap_or_default(),
8415            };
8416            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8417        }
8418    }
8419    impl Serialize for FlashlightOsu {
8420        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8421            let field_count = self.follow_delay.is_some() as usize
8422                + self.size_multiplier.is_some() as usize
8423                + self.combo_based_size.is_some() as usize;
8424            let mut map = s.serialize_map(Some(field_count))?;
8425            if let Some(ref x) = self.follow_delay {
8426                map.serialize_entry("follow_delay", x)?;
8427            }
8428            if let Some(ref x) = self.size_multiplier {
8429                map.serialize_entry("size_multiplier", x)?;
8430            }
8431            if let Some(ref x) = self.combo_based_size {
8432                map.serialize_entry("combo_based_size", x)?;
8433            }
8434            map.end()
8435        }
8436    }
8437    impl<'de> Visitor<'de> for GameModVisitor<BlindsOsu> {
8438        type Value = DeserializedGameMod<'de, BlindsOsu>;
8439        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8440            f.write_str("BlindsOsu")
8441        }
8442        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8443            const FIELDS: &'static [&'static str] = &[];
8444            let mut unknown_key__ = None;
8445            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8446                match key.as_str() {
8447                    _ => {
8448                        unknown_key__ = Some(key);
8449                        let _: IgnoredAny = map.next_value()?;
8450                    }
8451                }
8452            }
8453            let gamemod = BlindsOsu {};
8454            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8455        }
8456    }
8457    impl Serialize for BlindsOsu {
8458        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8459            let field_count = 0;
8460            let map = s.serialize_map(Some(field_count))?;
8461            map.end()
8462        }
8463    }
8464    impl<'de> Visitor<'de> for GameModVisitor<StrictTrackingOsu> {
8465        type Value = DeserializedGameMod<'de, StrictTrackingOsu>;
8466        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8467            f.write_str("StrictTrackingOsu")
8468        }
8469        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8470            const FIELDS: &'static [&'static str] = &[];
8471            let mut unknown_key__ = None;
8472            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8473                match key.as_str() {
8474                    _ => {
8475                        unknown_key__ = Some(key);
8476                        let _: IgnoredAny = map.next_value()?;
8477                    }
8478                }
8479            }
8480            let gamemod = StrictTrackingOsu {};
8481            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8482        }
8483    }
8484    impl Serialize for StrictTrackingOsu {
8485        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8486            let field_count = 0;
8487            let map = s.serialize_map(Some(field_count))?;
8488            map.end()
8489        }
8490    }
8491    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeOsu> {
8492        type Value = DeserializedGameMod<'de, AccuracyChallengeOsu>;
8493        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8494            f.write_str("AccuracyChallengeOsu")
8495        }
8496        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8497            const FIELDS: &'static [&'static str] =
8498                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
8499            let mut unknown_key__ = None;
8500            let mut minimum_accuracy = None;
8501            let mut accuracy_judge_mode = None;
8502            let mut restart = None;
8503            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8504                match key.as_str() {
8505                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
8506                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
8507                    "restart" => restart = Some(map.next_value()?),
8508                    _ => {
8509                        unknown_key__ = Some(key);
8510                        let _: IgnoredAny = map.next_value()?;
8511                    }
8512                }
8513            }
8514            let gamemod = AccuracyChallengeOsu {
8515                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
8516                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
8517                restart: restart.unwrap_or_default(),
8518            };
8519            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8520        }
8521    }
8522    impl Serialize for AccuracyChallengeOsu {
8523        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8524            let field_count = self.minimum_accuracy.is_some() as usize
8525                + self.accuracy_judge_mode.is_some() as usize
8526                + self.restart.is_some() as usize;
8527            let mut map = s.serialize_map(Some(field_count))?;
8528            if let Some(ref x) = self.minimum_accuracy {
8529                map.serialize_entry("minimum_accuracy", x)?;
8530            }
8531            if let Some(ref x) = self.accuracy_judge_mode {
8532                map.serialize_entry("accuracy_judge_mode", x)?;
8533            }
8534            if let Some(ref x) = self.restart {
8535                map.serialize_entry("restart", x)?;
8536            }
8537            map.end()
8538        }
8539    }
8540    impl<'de> Visitor<'de> for GameModVisitor<TargetPracticeOsu> {
8541        type Value = DeserializedGameMod<'de, TargetPracticeOsu>;
8542        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8543            f.write_str("TargetPracticeOsu")
8544        }
8545        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8546            const FIELDS: &'static [&'static str] = &["seed", "metronome"];
8547            let mut unknown_key__ = None;
8548            let mut seed = None;
8549            let mut metronome = None;
8550            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8551                match key.as_str() {
8552                    "seed" => seed = Some(map.next_value()?),
8553                    "metronome" => metronome = Some(map.next_value()?),
8554                    _ => {
8555                        unknown_key__ = Some(key);
8556                        let _: IgnoredAny = map.next_value()?;
8557                    }
8558                }
8559            }
8560            let gamemod = TargetPracticeOsu {
8561                seed: seed.unwrap_or_default(),
8562                metronome: metronome.unwrap_or_default(),
8563            };
8564            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8565        }
8566    }
8567    impl Serialize for TargetPracticeOsu {
8568        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8569            let field_count = self.seed.is_some() as usize + self.metronome.is_some() as usize;
8570            let mut map = s.serialize_map(Some(field_count))?;
8571            if let Some(ref x) = self.seed {
8572                map.serialize_entry("seed", x)?;
8573            }
8574            if let Some(ref x) = self.metronome {
8575                map.serialize_entry("metronome", x)?;
8576            }
8577            map.end()
8578        }
8579    }
8580    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustOsu> {
8581        type Value = DeserializedGameMod<'de, DifficultyAdjustOsu>;
8582        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8583            f.write_str("DifficultyAdjustOsu")
8584        }
8585        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8586            const FIELDS: &'static [&'static str] = &[
8587                "circle_size",
8588                "approach_rate",
8589                "drain_rate",
8590                "overall_difficulty",
8591                "extended_limits",
8592            ];
8593            let mut unknown_key__ = None;
8594            let mut circle_size = None;
8595            let mut approach_rate = None;
8596            let mut drain_rate = None;
8597            let mut overall_difficulty = None;
8598            let mut extended_limits = None;
8599            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8600                match key.as_str() {
8601                    "circle_size" => circle_size = Some(map.next_value()?),
8602                    "approach_rate" => approach_rate = Some(map.next_value()?),
8603                    "drain_rate" => drain_rate = Some(map.next_value()?),
8604                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
8605                    "extended_limits" => extended_limits = Some(map.next_value()?),
8606                    _ => {
8607                        unknown_key__ = Some(key);
8608                        let _: IgnoredAny = map.next_value()?;
8609                    }
8610                }
8611            }
8612            let gamemod = DifficultyAdjustOsu {
8613                circle_size: circle_size.unwrap_or_default(),
8614                approach_rate: approach_rate.unwrap_or_default(),
8615                drain_rate: drain_rate.unwrap_or_default(),
8616                overall_difficulty: overall_difficulty.unwrap_or_default(),
8617                extended_limits: extended_limits.unwrap_or_default(),
8618            };
8619            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8620        }
8621    }
8622    impl Serialize for DifficultyAdjustOsu {
8623        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8624            let field_count = self.circle_size.is_some() as usize
8625                + self.approach_rate.is_some() as usize
8626                + self.drain_rate.is_some() as usize
8627                + self.overall_difficulty.is_some() as usize
8628                + self.extended_limits.is_some() as usize;
8629            let mut map = s.serialize_map(Some(field_count))?;
8630            if let Some(ref x) = self.circle_size {
8631                map.serialize_entry("circle_size", x)?;
8632            }
8633            if let Some(ref x) = self.approach_rate {
8634                map.serialize_entry("approach_rate", x)?;
8635            }
8636            if let Some(ref x) = self.drain_rate {
8637                map.serialize_entry("drain_rate", x)?;
8638            }
8639            if let Some(ref x) = self.overall_difficulty {
8640                map.serialize_entry("overall_difficulty", x)?;
8641            }
8642            if let Some(ref x) = self.extended_limits {
8643                map.serialize_entry("extended_limits", x)?;
8644            }
8645            map.end()
8646        }
8647    }
8648    impl<'de> Visitor<'de> for GameModVisitor<ClassicOsu> {
8649        type Value = DeserializedGameMod<'de, ClassicOsu>;
8650        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8651            f.write_str("ClassicOsu")
8652        }
8653        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8654            const FIELDS: &'static [&'static str] = &[
8655                "no_slider_head_accuracy",
8656                "classic_note_lock",
8657                "always_play_tail_sample",
8658                "fade_hit_circle_early",
8659                "classic_health",
8660            ];
8661            let mut unknown_key__ = None;
8662            let mut no_slider_head_accuracy = None;
8663            let mut classic_note_lock = None;
8664            let mut always_play_tail_sample = None;
8665            let mut fade_hit_circle_early = None;
8666            let mut classic_health = None;
8667            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8668                match key.as_str() {
8669                    "no_slider_head_accuracy" => no_slider_head_accuracy = Some(map.next_value()?),
8670                    "classic_note_lock" => classic_note_lock = Some(map.next_value()?),
8671                    "always_play_tail_sample" => always_play_tail_sample = Some(map.next_value()?),
8672                    "fade_hit_circle_early" => fade_hit_circle_early = Some(map.next_value()?),
8673                    "classic_health" => classic_health = Some(map.next_value()?),
8674                    _ => {
8675                        unknown_key__ = Some(key);
8676                        let _: IgnoredAny = map.next_value()?;
8677                    }
8678                }
8679            }
8680            let gamemod = ClassicOsu {
8681                no_slider_head_accuracy: no_slider_head_accuracy.unwrap_or_default(),
8682                classic_note_lock: classic_note_lock.unwrap_or_default(),
8683                always_play_tail_sample: always_play_tail_sample.unwrap_or_default(),
8684                fade_hit_circle_early: fade_hit_circle_early.unwrap_or_default(),
8685                classic_health: classic_health.unwrap_or_default(),
8686            };
8687            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8688        }
8689    }
8690    impl Serialize for ClassicOsu {
8691        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8692            let field_count = self.no_slider_head_accuracy.is_some() as usize
8693                + self.classic_note_lock.is_some() as usize
8694                + self.always_play_tail_sample.is_some() as usize
8695                + self.fade_hit_circle_early.is_some() as usize
8696                + self.classic_health.is_some() as usize;
8697            let mut map = s.serialize_map(Some(field_count))?;
8698            if let Some(ref x) = self.no_slider_head_accuracy {
8699                map.serialize_entry("no_slider_head_accuracy", x)?;
8700            }
8701            if let Some(ref x) = self.classic_note_lock {
8702                map.serialize_entry("classic_note_lock", x)?;
8703            }
8704            if let Some(ref x) = self.always_play_tail_sample {
8705                map.serialize_entry("always_play_tail_sample", x)?;
8706            }
8707            if let Some(ref x) = self.fade_hit_circle_early {
8708                map.serialize_entry("fade_hit_circle_early", x)?;
8709            }
8710            if let Some(ref x) = self.classic_health {
8711                map.serialize_entry("classic_health", x)?;
8712            }
8713            map.end()
8714        }
8715    }
8716    impl<'de> Visitor<'de> for GameModVisitor<RandomOsu> {
8717        type Value = DeserializedGameMod<'de, RandomOsu>;
8718        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8719            f.write_str("RandomOsu")
8720        }
8721        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8722            const FIELDS: &'static [&'static str] = &["angle_sharpness", "seed"];
8723            let mut unknown_key__ = None;
8724            let mut angle_sharpness = None;
8725            let mut seed = None;
8726            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8727                match key.as_str() {
8728                    "angle_sharpness" => angle_sharpness = Some(map.next_value()?),
8729                    "seed" => seed = Some(map.next_value()?),
8730                    _ => {
8731                        unknown_key__ = Some(key);
8732                        let _: IgnoredAny = map.next_value()?;
8733                    }
8734                }
8735            }
8736            let gamemod = RandomOsu {
8737                angle_sharpness: angle_sharpness.unwrap_or_default(),
8738                seed: seed.unwrap_or_default(),
8739            };
8740            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8741        }
8742    }
8743    impl Serialize for RandomOsu {
8744        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8745            let field_count =
8746                self.angle_sharpness.is_some() as usize + self.seed.is_some() as usize;
8747            let mut map = s.serialize_map(Some(field_count))?;
8748            if let Some(ref x) = self.angle_sharpness {
8749                map.serialize_entry("angle_sharpness", x)?;
8750            }
8751            if let Some(ref x) = self.seed {
8752                map.serialize_entry("seed", x)?;
8753            }
8754            map.end()
8755        }
8756    }
8757    impl<'de> Visitor<'de> for GameModVisitor<MirrorOsu> {
8758        type Value = DeserializedGameMod<'de, MirrorOsu>;
8759        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8760            f.write_str("MirrorOsu")
8761        }
8762        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8763            const FIELDS: &'static [&'static str] = &["reflection"];
8764            let mut unknown_key__ = None;
8765            let mut reflection = None;
8766            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8767                match key.as_str() {
8768                    "reflection" => reflection = Some(map.next_value()?),
8769                    _ => {
8770                        unknown_key__ = Some(key);
8771                        let _: IgnoredAny = map.next_value()?;
8772                    }
8773                }
8774            }
8775            let gamemod = MirrorOsu {
8776                reflection: reflection.unwrap_or_default(),
8777            };
8778            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8779        }
8780    }
8781    impl Serialize for MirrorOsu {
8782        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8783            let field_count = self.reflection.is_some() as usize;
8784            let mut map = s.serialize_map(Some(field_count))?;
8785            if let Some(ref x) = self.reflection {
8786                map.serialize_entry("reflection", x)?;
8787            }
8788            map.end()
8789        }
8790    }
8791    impl<'de> Visitor<'de> for GameModVisitor<AlternateOsu> {
8792        type Value = DeserializedGameMod<'de, AlternateOsu>;
8793        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8794            f.write_str("AlternateOsu")
8795        }
8796        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8797            const FIELDS: &'static [&'static str] = &[];
8798            let mut unknown_key__ = None;
8799            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8800                match key.as_str() {
8801                    _ => {
8802                        unknown_key__ = Some(key);
8803                        let _: IgnoredAny = map.next_value()?;
8804                    }
8805                }
8806            }
8807            let gamemod = AlternateOsu {};
8808            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8809        }
8810    }
8811    impl Serialize for AlternateOsu {
8812        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8813            let field_count = 0;
8814            let map = s.serialize_map(Some(field_count))?;
8815            map.end()
8816        }
8817    }
8818    impl<'de> Visitor<'de> for GameModVisitor<SingleTapOsu> {
8819        type Value = DeserializedGameMod<'de, SingleTapOsu>;
8820        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8821            f.write_str("SingleTapOsu")
8822        }
8823        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8824            const FIELDS: &'static [&'static str] = &[];
8825            let mut unknown_key__ = None;
8826            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8827                match key.as_str() {
8828                    _ => {
8829                        unknown_key__ = Some(key);
8830                        let _: IgnoredAny = map.next_value()?;
8831                    }
8832                }
8833            }
8834            let gamemod = SingleTapOsu {};
8835            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8836        }
8837    }
8838    impl Serialize for SingleTapOsu {
8839        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8840            let field_count = 0;
8841            let map = s.serialize_map(Some(field_count))?;
8842            map.end()
8843        }
8844    }
8845    impl<'de> Visitor<'de> for GameModVisitor<AutoplayOsu> {
8846        type Value = DeserializedGameMod<'de, AutoplayOsu>;
8847        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8848            f.write_str("AutoplayOsu")
8849        }
8850        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8851            const FIELDS: &'static [&'static str] = &[];
8852            let mut unknown_key__ = None;
8853            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8854                match key.as_str() {
8855                    _ => {
8856                        unknown_key__ = Some(key);
8857                        let _: IgnoredAny = map.next_value()?;
8858                    }
8859                }
8860            }
8861            let gamemod = AutoplayOsu {};
8862            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8863        }
8864    }
8865    impl Serialize for AutoplayOsu {
8866        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8867            let field_count = 0;
8868            let map = s.serialize_map(Some(field_count))?;
8869            map.end()
8870        }
8871    }
8872    impl<'de> Visitor<'de> for GameModVisitor<CinemaOsu> {
8873        type Value = DeserializedGameMod<'de, CinemaOsu>;
8874        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8875            f.write_str("CinemaOsu")
8876        }
8877        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8878            const FIELDS: &'static [&'static str] = &[];
8879            let mut unknown_key__ = None;
8880            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8881                match key.as_str() {
8882                    _ => {
8883                        unknown_key__ = Some(key);
8884                        let _: IgnoredAny = map.next_value()?;
8885                    }
8886                }
8887            }
8888            let gamemod = CinemaOsu {};
8889            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8890        }
8891    }
8892    impl Serialize for CinemaOsu {
8893        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8894            let field_count = 0;
8895            let map = s.serialize_map(Some(field_count))?;
8896            map.end()
8897        }
8898    }
8899    impl<'de> Visitor<'de> for GameModVisitor<RelaxOsu> {
8900        type Value = DeserializedGameMod<'de, RelaxOsu>;
8901        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8902            f.write_str("RelaxOsu")
8903        }
8904        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8905            const FIELDS: &'static [&'static str] = &[];
8906            let mut unknown_key__ = None;
8907            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8908                match key.as_str() {
8909                    _ => {
8910                        unknown_key__ = Some(key);
8911                        let _: IgnoredAny = map.next_value()?;
8912                    }
8913                }
8914            }
8915            let gamemod = RelaxOsu {};
8916            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8917        }
8918    }
8919    impl Serialize for RelaxOsu {
8920        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8921            let field_count = 0;
8922            let map = s.serialize_map(Some(field_count))?;
8923            map.end()
8924        }
8925    }
8926    impl<'de> Visitor<'de> for GameModVisitor<AutopilotOsu> {
8927        type Value = DeserializedGameMod<'de, AutopilotOsu>;
8928        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8929            f.write_str("AutopilotOsu")
8930        }
8931        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8932            const FIELDS: &'static [&'static str] = &[];
8933            let mut unknown_key__ = None;
8934            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8935                match key.as_str() {
8936                    _ => {
8937                        unknown_key__ = Some(key);
8938                        let _: IgnoredAny = map.next_value()?;
8939                    }
8940                }
8941            }
8942            let gamemod = AutopilotOsu {};
8943            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8944        }
8945    }
8946    impl Serialize for AutopilotOsu {
8947        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8948            let field_count = 0;
8949            let map = s.serialize_map(Some(field_count))?;
8950            map.end()
8951        }
8952    }
8953    impl<'de> Visitor<'de> for GameModVisitor<SpunOutOsu> {
8954        type Value = DeserializedGameMod<'de, SpunOutOsu>;
8955        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8956            f.write_str("SpunOutOsu")
8957        }
8958        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8959            const FIELDS: &'static [&'static str] = &[];
8960            let mut unknown_key__ = None;
8961            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8962                match key.as_str() {
8963                    _ => {
8964                        unknown_key__ = Some(key);
8965                        let _: IgnoredAny = map.next_value()?;
8966                    }
8967                }
8968            }
8969            let gamemod = SpunOutOsu {};
8970            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8971        }
8972    }
8973    impl Serialize for SpunOutOsu {
8974        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8975            let field_count = 0;
8976            let map = s.serialize_map(Some(field_count))?;
8977            map.end()
8978        }
8979    }
8980    impl<'de> Visitor<'de> for GameModVisitor<TransformOsu> {
8981        type Value = DeserializedGameMod<'de, TransformOsu>;
8982        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8983            f.write_str("TransformOsu")
8984        }
8985        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8986            const FIELDS: &'static [&'static str] = &[];
8987            let mut unknown_key__ = None;
8988            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8989                match key.as_str() {
8990                    _ => {
8991                        unknown_key__ = Some(key);
8992                        let _: IgnoredAny = map.next_value()?;
8993                    }
8994                }
8995            }
8996            let gamemod = TransformOsu {};
8997            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8998        }
8999    }
9000    impl Serialize for TransformOsu {
9001        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9002            let field_count = 0;
9003            let map = s.serialize_map(Some(field_count))?;
9004            map.end()
9005        }
9006    }
9007    impl<'de> Visitor<'de> for GameModVisitor<WiggleOsu> {
9008        type Value = DeserializedGameMod<'de, WiggleOsu>;
9009        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9010            f.write_str("WiggleOsu")
9011        }
9012        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9013            const FIELDS: &'static [&'static str] = &["strength"];
9014            let mut unknown_key__ = None;
9015            let mut strength = None;
9016            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9017                match key.as_str() {
9018                    "strength" => strength = Some(map.next_value()?),
9019                    _ => {
9020                        unknown_key__ = Some(key);
9021                        let _: IgnoredAny = map.next_value()?;
9022                    }
9023                }
9024            }
9025            let gamemod = WiggleOsu {
9026                strength: strength.unwrap_or_default(),
9027            };
9028            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9029        }
9030    }
9031    impl Serialize for WiggleOsu {
9032        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9033            let field_count = self.strength.is_some() as usize;
9034            let mut map = s.serialize_map(Some(field_count))?;
9035            if let Some(ref x) = self.strength {
9036                map.serialize_entry("strength", x)?;
9037            }
9038            map.end()
9039        }
9040    }
9041    impl<'de> Visitor<'de> for GameModVisitor<SpinInOsu> {
9042        type Value = DeserializedGameMod<'de, SpinInOsu>;
9043        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9044            f.write_str("SpinInOsu")
9045        }
9046        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9047            const FIELDS: &'static [&'static str] = &[];
9048            let mut unknown_key__ = None;
9049            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9050                match key.as_str() {
9051                    _ => {
9052                        unknown_key__ = Some(key);
9053                        let _: IgnoredAny = map.next_value()?;
9054                    }
9055                }
9056            }
9057            let gamemod = SpinInOsu {};
9058            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9059        }
9060    }
9061    impl Serialize for SpinInOsu {
9062        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9063            let field_count = 0;
9064            let map = s.serialize_map(Some(field_count))?;
9065            map.end()
9066        }
9067    }
9068    impl<'de> Visitor<'de> for GameModVisitor<GrowOsu> {
9069        type Value = DeserializedGameMod<'de, GrowOsu>;
9070        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9071            f.write_str("GrowOsu")
9072        }
9073        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9074            const FIELDS: &'static [&'static str] = &["start_scale"];
9075            let mut unknown_key__ = None;
9076            let mut start_scale = None;
9077            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9078                match key.as_str() {
9079                    "start_scale" => start_scale = Some(map.next_value()?),
9080                    _ => {
9081                        unknown_key__ = Some(key);
9082                        let _: IgnoredAny = map.next_value()?;
9083                    }
9084                }
9085            }
9086            let gamemod = GrowOsu {
9087                start_scale: start_scale.unwrap_or_default(),
9088            };
9089            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9090        }
9091    }
9092    impl Serialize for GrowOsu {
9093        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9094            let field_count = self.start_scale.is_some() as usize;
9095            let mut map = s.serialize_map(Some(field_count))?;
9096            if let Some(ref x) = self.start_scale {
9097                map.serialize_entry("start_scale", x)?;
9098            }
9099            map.end()
9100        }
9101    }
9102    impl<'de> Visitor<'de> for GameModVisitor<DeflateOsu> {
9103        type Value = DeserializedGameMod<'de, DeflateOsu>;
9104        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9105            f.write_str("DeflateOsu")
9106        }
9107        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9108            const FIELDS: &'static [&'static str] = &["start_scale"];
9109            let mut unknown_key__ = None;
9110            let mut start_scale = None;
9111            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9112                match key.as_str() {
9113                    "start_scale" => start_scale = Some(map.next_value()?),
9114                    _ => {
9115                        unknown_key__ = Some(key);
9116                        let _: IgnoredAny = map.next_value()?;
9117                    }
9118                }
9119            }
9120            let gamemod = DeflateOsu {
9121                start_scale: start_scale.unwrap_or_default(),
9122            };
9123            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9124        }
9125    }
9126    impl Serialize for DeflateOsu {
9127        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9128            let field_count = self.start_scale.is_some() as usize;
9129            let mut map = s.serialize_map(Some(field_count))?;
9130            if let Some(ref x) = self.start_scale {
9131                map.serialize_entry("start_scale", x)?;
9132            }
9133            map.end()
9134        }
9135    }
9136    impl<'de> Visitor<'de> for GameModVisitor<WindUpOsu> {
9137        type Value = DeserializedGameMod<'de, WindUpOsu>;
9138        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9139            f.write_str("WindUpOsu")
9140        }
9141        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9142            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
9143            let mut unknown_key__ = None;
9144            let mut initial_rate = None;
9145            let mut final_rate = None;
9146            let mut adjust_pitch = None;
9147            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9148                match key.as_str() {
9149                    "initial_rate" => initial_rate = Some(map.next_value()?),
9150                    "final_rate" => final_rate = Some(map.next_value()?),
9151                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9152                    _ => {
9153                        unknown_key__ = Some(key);
9154                        let _: IgnoredAny = map.next_value()?;
9155                    }
9156                }
9157            }
9158            let gamemod = WindUpOsu {
9159                initial_rate: initial_rate.unwrap_or_default(),
9160                final_rate: final_rate.unwrap_or_default(),
9161                adjust_pitch: adjust_pitch.unwrap_or_default(),
9162            };
9163            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9164        }
9165    }
9166    impl Serialize for WindUpOsu {
9167        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9168            let field_count = self.initial_rate.is_some() as usize
9169                + self.final_rate.is_some() as usize
9170                + self.adjust_pitch.is_some() as usize;
9171            let mut map = s.serialize_map(Some(field_count))?;
9172            if let Some(ref x) = self.initial_rate {
9173                map.serialize_entry("initial_rate", x)?;
9174            }
9175            if let Some(ref x) = self.final_rate {
9176                map.serialize_entry("final_rate", x)?;
9177            }
9178            if let Some(ref x) = self.adjust_pitch {
9179                map.serialize_entry("adjust_pitch", x)?;
9180            }
9181            map.end()
9182        }
9183    }
9184    impl<'de> Visitor<'de> for GameModVisitor<WindDownOsu> {
9185        type Value = DeserializedGameMod<'de, WindDownOsu>;
9186        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9187            f.write_str("WindDownOsu")
9188        }
9189        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9190            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
9191            let mut unknown_key__ = None;
9192            let mut initial_rate = None;
9193            let mut final_rate = None;
9194            let mut adjust_pitch = None;
9195            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9196                match key.as_str() {
9197                    "initial_rate" => initial_rate = Some(map.next_value()?),
9198                    "final_rate" => final_rate = Some(map.next_value()?),
9199                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9200                    _ => {
9201                        unknown_key__ = Some(key);
9202                        let _: IgnoredAny = map.next_value()?;
9203                    }
9204                }
9205            }
9206            let gamemod = WindDownOsu {
9207                initial_rate: initial_rate.unwrap_or_default(),
9208                final_rate: final_rate.unwrap_or_default(),
9209                adjust_pitch: adjust_pitch.unwrap_or_default(),
9210            };
9211            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9212        }
9213    }
9214    impl Serialize for WindDownOsu {
9215        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9216            let field_count = self.initial_rate.is_some() as usize
9217                + self.final_rate.is_some() as usize
9218                + self.adjust_pitch.is_some() as usize;
9219            let mut map = s.serialize_map(Some(field_count))?;
9220            if let Some(ref x) = self.initial_rate {
9221                map.serialize_entry("initial_rate", x)?;
9222            }
9223            if let Some(ref x) = self.final_rate {
9224                map.serialize_entry("final_rate", x)?;
9225            }
9226            if let Some(ref x) = self.adjust_pitch {
9227                map.serialize_entry("adjust_pitch", x)?;
9228            }
9229            map.end()
9230        }
9231    }
9232    impl<'de> Visitor<'de> for GameModVisitor<BarrelRollOsu> {
9233        type Value = DeserializedGameMod<'de, BarrelRollOsu>;
9234        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9235            f.write_str("BarrelRollOsu")
9236        }
9237        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9238            const FIELDS: &'static [&'static str] = &["spin_speed", "direction"];
9239            let mut unknown_key__ = None;
9240            let mut spin_speed = None;
9241            let mut direction = None;
9242            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9243                match key.as_str() {
9244                    "spin_speed" => spin_speed = Some(map.next_value()?),
9245                    "direction" => direction = Some(map.next_value()?),
9246                    _ => {
9247                        unknown_key__ = Some(key);
9248                        let _: IgnoredAny = map.next_value()?;
9249                    }
9250                }
9251            }
9252            let gamemod = BarrelRollOsu {
9253                spin_speed: spin_speed.unwrap_or_default(),
9254                direction: direction.unwrap_or_default(),
9255            };
9256            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9257        }
9258    }
9259    impl Serialize for BarrelRollOsu {
9260        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9261            let field_count =
9262                self.spin_speed.is_some() as usize + self.direction.is_some() as usize;
9263            let mut map = s.serialize_map(Some(field_count))?;
9264            if let Some(ref x) = self.spin_speed {
9265                map.serialize_entry("spin_speed", x)?;
9266            }
9267            if let Some(ref x) = self.direction {
9268                map.serialize_entry("direction", x)?;
9269            }
9270            map.end()
9271        }
9272    }
9273    impl<'de> Visitor<'de> for GameModVisitor<ApproachDifferentOsu> {
9274        type Value = DeserializedGameMod<'de, ApproachDifferentOsu>;
9275        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9276            f.write_str("ApproachDifferentOsu")
9277        }
9278        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9279            const FIELDS: &'static [&'static str] = &["scale", "style"];
9280            let mut unknown_key__ = None;
9281            let mut scale = None;
9282            let mut style = None;
9283            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9284                match key.as_str() {
9285                    "scale" => scale = Some(map.next_value()?),
9286                    "style" => style = Some(map.next_value()?),
9287                    _ => {
9288                        unknown_key__ = Some(key);
9289                        let _: IgnoredAny = map.next_value()?;
9290                    }
9291                }
9292            }
9293            let gamemod = ApproachDifferentOsu {
9294                scale: scale.unwrap_or_default(),
9295                style: style.unwrap_or_default(),
9296            };
9297            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9298        }
9299    }
9300    impl Serialize for ApproachDifferentOsu {
9301        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9302            let field_count = self.scale.is_some() as usize + self.style.is_some() as usize;
9303            let mut map = s.serialize_map(Some(field_count))?;
9304            if let Some(ref x) = self.scale {
9305                map.serialize_entry("scale", x)?;
9306            }
9307            if let Some(ref x) = self.style {
9308                map.serialize_entry("style", x)?;
9309            }
9310            map.end()
9311        }
9312    }
9313    impl<'de> Visitor<'de> for GameModVisitor<MutedOsu> {
9314        type Value = DeserializedGameMod<'de, MutedOsu>;
9315        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9316            f.write_str("MutedOsu")
9317        }
9318        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9319            const FIELDS: &'static [&'static str] = &[
9320                "inverse_muting",
9321                "enable_metronome",
9322                "mute_combo_count",
9323                "affects_hit_sounds",
9324            ];
9325            let mut unknown_key__ = None;
9326            let mut inverse_muting = None;
9327            let mut enable_metronome = None;
9328            let mut mute_combo_count = None;
9329            let mut affects_hit_sounds = None;
9330            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9331                match key.as_str() {
9332                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
9333                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
9334                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
9335                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
9336                    _ => {
9337                        unknown_key__ = Some(key);
9338                        let _: IgnoredAny = map.next_value()?;
9339                    }
9340                }
9341            }
9342            let gamemod = MutedOsu {
9343                inverse_muting: inverse_muting.unwrap_or_default(),
9344                enable_metronome: enable_metronome.unwrap_or_default(),
9345                mute_combo_count: mute_combo_count.unwrap_or_default(),
9346                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
9347            };
9348            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9349        }
9350    }
9351    impl Serialize for MutedOsu {
9352        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9353            let field_count = self.inverse_muting.is_some() as usize
9354                + self.enable_metronome.is_some() as usize
9355                + self.mute_combo_count.is_some() as usize
9356                + self.affects_hit_sounds.is_some() as usize;
9357            let mut map = s.serialize_map(Some(field_count))?;
9358            if let Some(ref x) = self.inverse_muting {
9359                map.serialize_entry("inverse_muting", x)?;
9360            }
9361            if let Some(ref x) = self.enable_metronome {
9362                map.serialize_entry("enable_metronome", x)?;
9363            }
9364            if let Some(ref x) = self.mute_combo_count {
9365                map.serialize_entry("mute_combo_count", x)?;
9366            }
9367            if let Some(ref x) = self.affects_hit_sounds {
9368                map.serialize_entry("affects_hit_sounds", x)?;
9369            }
9370            map.end()
9371        }
9372    }
9373    impl<'de> Visitor<'de> for GameModVisitor<NoScopeOsu> {
9374        type Value = DeserializedGameMod<'de, NoScopeOsu>;
9375        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9376            f.write_str("NoScopeOsu")
9377        }
9378        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9379            const FIELDS: &'static [&'static str] = &["hidden_combo_count"];
9380            let mut unknown_key__ = None;
9381            let mut hidden_combo_count = None;
9382            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9383                match key.as_str() {
9384                    "hidden_combo_count" => hidden_combo_count = Some(map.next_value()?),
9385                    _ => {
9386                        unknown_key__ = Some(key);
9387                        let _: IgnoredAny = map.next_value()?;
9388                    }
9389                }
9390            }
9391            let gamemod = NoScopeOsu {
9392                hidden_combo_count: hidden_combo_count.unwrap_or_default(),
9393            };
9394            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9395        }
9396    }
9397    impl Serialize for NoScopeOsu {
9398        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9399            let field_count = self.hidden_combo_count.is_some() as usize;
9400            let mut map = s.serialize_map(Some(field_count))?;
9401            if let Some(ref x) = self.hidden_combo_count {
9402                map.serialize_entry("hidden_combo_count", x)?;
9403            }
9404            map.end()
9405        }
9406    }
9407    impl<'de> Visitor<'de> for GameModVisitor<MagnetisedOsu> {
9408        type Value = DeserializedGameMod<'de, MagnetisedOsu>;
9409        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9410            f.write_str("MagnetisedOsu")
9411        }
9412        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9413            const FIELDS: &'static [&'static str] = &["attraction_strength"];
9414            let mut unknown_key__ = None;
9415            let mut attraction_strength = None;
9416            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9417                match key.as_str() {
9418                    "attraction_strength" => attraction_strength = Some(map.next_value()?),
9419                    _ => {
9420                        unknown_key__ = Some(key);
9421                        let _: IgnoredAny = map.next_value()?;
9422                    }
9423                }
9424            }
9425            let gamemod = MagnetisedOsu {
9426                attraction_strength: attraction_strength.unwrap_or_default(),
9427            };
9428            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9429        }
9430    }
9431    impl Serialize for MagnetisedOsu {
9432        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9433            let field_count = self.attraction_strength.is_some() as usize;
9434            let mut map = s.serialize_map(Some(field_count))?;
9435            if let Some(ref x) = self.attraction_strength {
9436                map.serialize_entry("attraction_strength", x)?;
9437            }
9438            map.end()
9439        }
9440    }
9441    impl<'de> Visitor<'de> for GameModVisitor<RepelOsu> {
9442        type Value = DeserializedGameMod<'de, RepelOsu>;
9443        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9444            f.write_str("RepelOsu")
9445        }
9446        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9447            const FIELDS: &'static [&'static str] = &["repulsion_strength"];
9448            let mut unknown_key__ = None;
9449            let mut repulsion_strength = None;
9450            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9451                match key.as_str() {
9452                    "repulsion_strength" => repulsion_strength = Some(map.next_value()?),
9453                    _ => {
9454                        unknown_key__ = Some(key);
9455                        let _: IgnoredAny = map.next_value()?;
9456                    }
9457                }
9458            }
9459            let gamemod = RepelOsu {
9460                repulsion_strength: repulsion_strength.unwrap_or_default(),
9461            };
9462            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9463        }
9464    }
9465    impl Serialize for RepelOsu {
9466        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9467            let field_count = self.repulsion_strength.is_some() as usize;
9468            let mut map = s.serialize_map(Some(field_count))?;
9469            if let Some(ref x) = self.repulsion_strength {
9470                map.serialize_entry("repulsion_strength", x)?;
9471            }
9472            map.end()
9473        }
9474    }
9475    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedOsu> {
9476        type Value = DeserializedGameMod<'de, AdaptiveSpeedOsu>;
9477        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9478            f.write_str("AdaptiveSpeedOsu")
9479        }
9480        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9481            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
9482            let mut unknown_key__ = None;
9483            let mut initial_rate = None;
9484            let mut adjust_pitch = None;
9485            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9486                match key.as_str() {
9487                    "initial_rate" => initial_rate = Some(map.next_value()?),
9488                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9489                    _ => {
9490                        unknown_key__ = Some(key);
9491                        let _: IgnoredAny = map.next_value()?;
9492                    }
9493                }
9494            }
9495            let gamemod = AdaptiveSpeedOsu {
9496                initial_rate: initial_rate.unwrap_or_default(),
9497                adjust_pitch: adjust_pitch.unwrap_or_default(),
9498            };
9499            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9500        }
9501    }
9502    impl Serialize for AdaptiveSpeedOsu {
9503        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9504            let field_count =
9505                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
9506            let mut map = s.serialize_map(Some(field_count))?;
9507            if let Some(ref x) = self.initial_rate {
9508                map.serialize_entry("initial_rate", x)?;
9509            }
9510            if let Some(ref x) = self.adjust_pitch {
9511                map.serialize_entry("adjust_pitch", x)?;
9512            }
9513            map.end()
9514        }
9515    }
9516    impl<'de> Visitor<'de> for GameModVisitor<FreezeFrameOsu> {
9517        type Value = DeserializedGameMod<'de, FreezeFrameOsu>;
9518        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9519            f.write_str("FreezeFrameOsu")
9520        }
9521        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9522            const FIELDS: &'static [&'static str] = &[];
9523            let mut unknown_key__ = None;
9524            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9525                match key.as_str() {
9526                    _ => {
9527                        unknown_key__ = Some(key);
9528                        let _: IgnoredAny = map.next_value()?;
9529                    }
9530                }
9531            }
9532            let gamemod = FreezeFrameOsu {};
9533            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9534        }
9535    }
9536    impl Serialize for FreezeFrameOsu {
9537        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9538            let field_count = 0;
9539            let map = s.serialize_map(Some(field_count))?;
9540            map.end()
9541        }
9542    }
9543    impl<'de> Visitor<'de> for GameModVisitor<BubblesOsu> {
9544        type Value = DeserializedGameMod<'de, BubblesOsu>;
9545        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9546            f.write_str("BubblesOsu")
9547        }
9548        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9549            const FIELDS: &'static [&'static str] = &[];
9550            let mut unknown_key__ = None;
9551            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9552                match key.as_str() {
9553                    _ => {
9554                        unknown_key__ = Some(key);
9555                        let _: IgnoredAny = map.next_value()?;
9556                    }
9557                }
9558            }
9559            let gamemod = BubblesOsu {};
9560            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9561        }
9562    }
9563    impl Serialize for BubblesOsu {
9564        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9565            let field_count = 0;
9566            let map = s.serialize_map(Some(field_count))?;
9567            map.end()
9568        }
9569    }
9570    impl<'de> Visitor<'de> for GameModVisitor<SynesthesiaOsu> {
9571        type Value = DeserializedGameMod<'de, SynesthesiaOsu>;
9572        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9573            f.write_str("SynesthesiaOsu")
9574        }
9575        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9576            const FIELDS: &'static [&'static str] = &[];
9577            let mut unknown_key__ = None;
9578            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9579                match key.as_str() {
9580                    _ => {
9581                        unknown_key__ = Some(key);
9582                        let _: IgnoredAny = map.next_value()?;
9583                    }
9584                }
9585            }
9586            let gamemod = SynesthesiaOsu {};
9587            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9588        }
9589    }
9590    impl Serialize for SynesthesiaOsu {
9591        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9592            let field_count = 0;
9593            let map = s.serialize_map(Some(field_count))?;
9594            map.end()
9595        }
9596    }
9597    impl<'de> Visitor<'de> for GameModVisitor<DepthOsu> {
9598        type Value = DeserializedGameMod<'de, DepthOsu>;
9599        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9600            f.write_str("DepthOsu")
9601        }
9602        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9603            const FIELDS: &'static [&'static str] = &["max_depth", "show_approach_circles"];
9604            let mut unknown_key__ = None;
9605            let mut max_depth = None;
9606            let mut show_approach_circles = None;
9607            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9608                match key.as_str() {
9609                    "max_depth" => max_depth = Some(map.next_value()?),
9610                    "show_approach_circles" => show_approach_circles = Some(map.next_value()?),
9611                    _ => {
9612                        unknown_key__ = Some(key);
9613                        let _: IgnoredAny = map.next_value()?;
9614                    }
9615                }
9616            }
9617            let gamemod = DepthOsu {
9618                max_depth: max_depth.unwrap_or_default(),
9619                show_approach_circles: show_approach_circles.unwrap_or_default(),
9620            };
9621            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9622        }
9623    }
9624    impl Serialize for DepthOsu {
9625        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9626            let field_count =
9627                self.max_depth.is_some() as usize + self.show_approach_circles.is_some() as usize;
9628            let mut map = s.serialize_map(Some(field_count))?;
9629            if let Some(ref x) = self.max_depth {
9630                map.serialize_entry("max_depth", x)?;
9631            }
9632            if let Some(ref x) = self.show_approach_circles {
9633                map.serialize_entry("show_approach_circles", x)?;
9634            }
9635            map.end()
9636        }
9637    }
9638    impl<'de> Visitor<'de> for GameModVisitor<BloomOsu> {
9639        type Value = DeserializedGameMod<'de, BloomOsu>;
9640        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9641            f.write_str("BloomOsu")
9642        }
9643        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9644            const FIELDS: &'static [&'static str] = &["max_size_combo_count", "max_cursor_size"];
9645            let mut unknown_key__ = None;
9646            let mut max_size_combo_count = None;
9647            let mut max_cursor_size = None;
9648            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9649                match key.as_str() {
9650                    "max_size_combo_count" => max_size_combo_count = Some(map.next_value()?),
9651                    "max_cursor_size" => max_cursor_size = Some(map.next_value()?),
9652                    _ => {
9653                        unknown_key__ = Some(key);
9654                        let _: IgnoredAny = map.next_value()?;
9655                    }
9656                }
9657            }
9658            let gamemod = BloomOsu {
9659                max_size_combo_count: max_size_combo_count.unwrap_or_default(),
9660                max_cursor_size: max_cursor_size.unwrap_or_default(),
9661            };
9662            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9663        }
9664    }
9665    impl Serialize for BloomOsu {
9666        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9667            let field_count = self.max_size_combo_count.is_some() as usize
9668                + self.max_cursor_size.is_some() as usize;
9669            let mut map = s.serialize_map(Some(field_count))?;
9670            if let Some(ref x) = self.max_size_combo_count {
9671                map.serialize_entry("max_size_combo_count", x)?;
9672            }
9673            if let Some(ref x) = self.max_cursor_size {
9674                map.serialize_entry("max_cursor_size", x)?;
9675            }
9676            map.end()
9677        }
9678    }
9679    impl<'de> Visitor<'de> for GameModVisitor<TouchDeviceOsu> {
9680        type Value = DeserializedGameMod<'de, TouchDeviceOsu>;
9681        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9682            f.write_str("TouchDeviceOsu")
9683        }
9684        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9685            const FIELDS: &'static [&'static str] = &[];
9686            let mut unknown_key__ = None;
9687            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9688                match key.as_str() {
9689                    _ => {
9690                        unknown_key__ = Some(key);
9691                        let _: IgnoredAny = map.next_value()?;
9692                    }
9693                }
9694            }
9695            let gamemod = TouchDeviceOsu {};
9696            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9697        }
9698    }
9699    impl Serialize for TouchDeviceOsu {
9700        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9701            let field_count = 0;
9702            let map = s.serialize_map(Some(field_count))?;
9703            map.end()
9704        }
9705    }
9706    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Osu> {
9707        type Value = DeserializedGameMod<'de, ScoreV2Osu>;
9708        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9709            f.write_str("ScoreV2Osu")
9710        }
9711        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9712            const FIELDS: &'static [&'static str] = &[];
9713            let mut unknown_key__ = None;
9714            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9715                match key.as_str() {
9716                    _ => {
9717                        unknown_key__ = Some(key);
9718                        let _: IgnoredAny = map.next_value()?;
9719                    }
9720                }
9721            }
9722            let gamemod = ScoreV2Osu {};
9723            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9724        }
9725    }
9726    impl Serialize for ScoreV2Osu {
9727        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9728            let field_count = 0;
9729            let map = s.serialize_map(Some(field_count))?;
9730            map.end()
9731        }
9732    }
9733    impl<'de> Visitor<'de> for GameModVisitor<EasyTaiko> {
9734        type Value = DeserializedGameMod<'de, EasyTaiko>;
9735        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9736            f.write_str("EasyTaiko")
9737        }
9738        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9739            const FIELDS: &'static [&'static str] = &[];
9740            let mut unknown_key__ = None;
9741            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9742                match key.as_str() {
9743                    _ => {
9744                        unknown_key__ = Some(key);
9745                        let _: IgnoredAny = map.next_value()?;
9746                    }
9747                }
9748            }
9749            let gamemod = EasyTaiko {};
9750            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9751        }
9752    }
9753    impl Serialize for EasyTaiko {
9754        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9755            let field_count = 0;
9756            let map = s.serialize_map(Some(field_count))?;
9757            map.end()
9758        }
9759    }
9760    impl<'de> Visitor<'de> for GameModVisitor<NoFailTaiko> {
9761        type Value = DeserializedGameMod<'de, NoFailTaiko>;
9762        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9763            f.write_str("NoFailTaiko")
9764        }
9765        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9766            const FIELDS: &'static [&'static str] = &[];
9767            let mut unknown_key__ = None;
9768            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9769                match key.as_str() {
9770                    _ => {
9771                        unknown_key__ = Some(key);
9772                        let _: IgnoredAny = map.next_value()?;
9773                    }
9774                }
9775            }
9776            let gamemod = NoFailTaiko {};
9777            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9778        }
9779    }
9780    impl Serialize for NoFailTaiko {
9781        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9782            let field_count = 0;
9783            let map = s.serialize_map(Some(field_count))?;
9784            map.end()
9785        }
9786    }
9787    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeTaiko> {
9788        type Value = DeserializedGameMod<'de, HalfTimeTaiko>;
9789        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9790            f.write_str("HalfTimeTaiko")
9791        }
9792        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9793            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
9794            let mut unknown_key__ = None;
9795            let mut speed_change = None;
9796            let mut adjust_pitch = None;
9797            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9798                match key.as_str() {
9799                    "speed_change" => speed_change = Some(map.next_value()?),
9800                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9801                    _ => {
9802                        unknown_key__ = Some(key);
9803                        let _: IgnoredAny = map.next_value()?;
9804                    }
9805                }
9806            }
9807            let gamemod = HalfTimeTaiko {
9808                speed_change: speed_change.unwrap_or_default(),
9809                adjust_pitch: adjust_pitch.unwrap_or_default(),
9810            };
9811            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9812        }
9813    }
9814    impl Serialize for HalfTimeTaiko {
9815        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9816            let field_count =
9817                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
9818            let mut map = s.serialize_map(Some(field_count))?;
9819            if let Some(ref x) = self.speed_change {
9820                map.serialize_entry("speed_change", x)?;
9821            }
9822            if let Some(ref x) = self.adjust_pitch {
9823                map.serialize_entry("adjust_pitch", x)?;
9824            }
9825            map.end()
9826        }
9827    }
9828    impl<'de> Visitor<'de> for GameModVisitor<DaycoreTaiko> {
9829        type Value = DeserializedGameMod<'de, DaycoreTaiko>;
9830        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9831            f.write_str("DaycoreTaiko")
9832        }
9833        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9834            const FIELDS: &'static [&'static str] = &["speed_change"];
9835            let mut unknown_key__ = None;
9836            let mut speed_change = None;
9837            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9838                match key.as_str() {
9839                    "speed_change" => speed_change = Some(map.next_value()?),
9840                    _ => {
9841                        unknown_key__ = Some(key);
9842                        let _: IgnoredAny = map.next_value()?;
9843                    }
9844                }
9845            }
9846            let gamemod = DaycoreTaiko {
9847                speed_change: speed_change.unwrap_or_default(),
9848            };
9849            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9850        }
9851    }
9852    impl Serialize for DaycoreTaiko {
9853        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9854            let field_count = self.speed_change.is_some() as usize;
9855            let mut map = s.serialize_map(Some(field_count))?;
9856            if let Some(ref x) = self.speed_change {
9857                map.serialize_entry("speed_change", x)?;
9858            }
9859            map.end()
9860        }
9861    }
9862    impl<'de> Visitor<'de> for GameModVisitor<SimplifiedRhythmTaiko> {
9863        type Value = DeserializedGameMod<'de, SimplifiedRhythmTaiko>;
9864        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9865            f.write_str("SimplifiedRhythmTaiko")
9866        }
9867        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9868            const FIELDS: &'static [&'static str] = &[
9869                "one_third_conversion",
9870                "one_sixth_conversion",
9871                "one_eighth_conversion",
9872            ];
9873            let mut unknown_key__ = None;
9874            let mut one_third_conversion = None;
9875            let mut one_sixth_conversion = None;
9876            let mut one_eighth_conversion = None;
9877            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9878                match key.as_str() {
9879                    "one_third_conversion" => one_third_conversion = Some(map.next_value()?),
9880                    "one_sixth_conversion" => one_sixth_conversion = Some(map.next_value()?),
9881                    "one_eighth_conversion" => one_eighth_conversion = Some(map.next_value()?),
9882                    _ => {
9883                        unknown_key__ = Some(key);
9884                        let _: IgnoredAny = map.next_value()?;
9885                    }
9886                }
9887            }
9888            let gamemod = SimplifiedRhythmTaiko {
9889                one_third_conversion: one_third_conversion.unwrap_or_default(),
9890                one_sixth_conversion: one_sixth_conversion.unwrap_or_default(),
9891                one_eighth_conversion: one_eighth_conversion.unwrap_or_default(),
9892            };
9893            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9894        }
9895    }
9896    impl Serialize for SimplifiedRhythmTaiko {
9897        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9898            let field_count = self.one_third_conversion.is_some() as usize
9899                + self.one_sixth_conversion.is_some() as usize
9900                + self.one_eighth_conversion.is_some() as usize;
9901            let mut map = s.serialize_map(Some(field_count))?;
9902            if let Some(ref x) = self.one_third_conversion {
9903                map.serialize_entry("one_third_conversion", x)?;
9904            }
9905            if let Some(ref x) = self.one_sixth_conversion {
9906                map.serialize_entry("one_sixth_conversion", x)?;
9907            }
9908            if let Some(ref x) = self.one_eighth_conversion {
9909                map.serialize_entry("one_eighth_conversion", x)?;
9910            }
9911            map.end()
9912        }
9913    }
9914    impl<'de> Visitor<'de> for GameModVisitor<HardRockTaiko> {
9915        type Value = DeserializedGameMod<'de, HardRockTaiko>;
9916        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9917            f.write_str("HardRockTaiko")
9918        }
9919        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9920            const FIELDS: &'static [&'static str] = &[];
9921            let mut unknown_key__ = None;
9922            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9923                match key.as_str() {
9924                    _ => {
9925                        unknown_key__ = Some(key);
9926                        let _: IgnoredAny = map.next_value()?;
9927                    }
9928                }
9929            }
9930            let gamemod = HardRockTaiko {};
9931            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9932        }
9933    }
9934    impl Serialize for HardRockTaiko {
9935        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9936            let field_count = 0;
9937            let map = s.serialize_map(Some(field_count))?;
9938            map.end()
9939        }
9940    }
9941    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathTaiko> {
9942        type Value = DeserializedGameMod<'de, SuddenDeathTaiko>;
9943        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9944            f.write_str("SuddenDeathTaiko")
9945        }
9946        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9947            const FIELDS: &'static [&'static str] = &["restart"];
9948            let mut unknown_key__ = None;
9949            let mut restart = None;
9950            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9951                match key.as_str() {
9952                    "restart" => restart = Some(map.next_value()?),
9953                    _ => {
9954                        unknown_key__ = Some(key);
9955                        let _: IgnoredAny = map.next_value()?;
9956                    }
9957                }
9958            }
9959            let gamemod = SuddenDeathTaiko {
9960                restart: restart.unwrap_or_default(),
9961            };
9962            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9963        }
9964    }
9965    impl Serialize for SuddenDeathTaiko {
9966        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9967            let field_count = self.restart.is_some() as usize;
9968            let mut map = s.serialize_map(Some(field_count))?;
9969            if let Some(ref x) = self.restart {
9970                map.serialize_entry("restart", x)?;
9971            }
9972            map.end()
9973        }
9974    }
9975    impl<'de> Visitor<'de> for GameModVisitor<PerfectTaiko> {
9976        type Value = DeserializedGameMod<'de, PerfectTaiko>;
9977        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9978            f.write_str("PerfectTaiko")
9979        }
9980        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9981            const FIELDS: &'static [&'static str] = &["restart"];
9982            let mut unknown_key__ = None;
9983            let mut restart = None;
9984            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9985                match key.as_str() {
9986                    "restart" => restart = Some(map.next_value()?),
9987                    _ => {
9988                        unknown_key__ = Some(key);
9989                        let _: IgnoredAny = map.next_value()?;
9990                    }
9991                }
9992            }
9993            let gamemod = PerfectTaiko {
9994                restart: restart.unwrap_or_default(),
9995            };
9996            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9997        }
9998    }
9999    impl Serialize for PerfectTaiko {
10000        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10001            let field_count = self.restart.is_some() as usize;
10002            let mut map = s.serialize_map(Some(field_count))?;
10003            if let Some(ref x) = self.restart {
10004                map.serialize_entry("restart", x)?;
10005            }
10006            map.end()
10007        }
10008    }
10009    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeTaiko> {
10010        type Value = DeserializedGameMod<'de, DoubleTimeTaiko>;
10011        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10012            f.write_str("DoubleTimeTaiko")
10013        }
10014        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10015            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
10016            let mut unknown_key__ = None;
10017            let mut speed_change = None;
10018            let mut adjust_pitch = None;
10019            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10020                match key.as_str() {
10021                    "speed_change" => speed_change = Some(map.next_value()?),
10022                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10023                    _ => {
10024                        unknown_key__ = Some(key);
10025                        let _: IgnoredAny = map.next_value()?;
10026                    }
10027                }
10028            }
10029            let gamemod = DoubleTimeTaiko {
10030                speed_change: speed_change.unwrap_or_default(),
10031                adjust_pitch: adjust_pitch.unwrap_or_default(),
10032            };
10033            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10034        }
10035    }
10036    impl Serialize for DoubleTimeTaiko {
10037        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10038            let field_count =
10039                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
10040            let mut map = s.serialize_map(Some(field_count))?;
10041            if let Some(ref x) = self.speed_change {
10042                map.serialize_entry("speed_change", x)?;
10043            }
10044            if let Some(ref x) = self.adjust_pitch {
10045                map.serialize_entry("adjust_pitch", x)?;
10046            }
10047            map.end()
10048        }
10049    }
10050    impl<'de> Visitor<'de> for GameModVisitor<NightcoreTaiko> {
10051        type Value = DeserializedGameMod<'de, NightcoreTaiko>;
10052        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10053            f.write_str("NightcoreTaiko")
10054        }
10055        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10056            const FIELDS: &'static [&'static str] = &["speed_change"];
10057            let mut unknown_key__ = None;
10058            let mut speed_change = None;
10059            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10060                match key.as_str() {
10061                    "speed_change" => speed_change = Some(map.next_value()?),
10062                    _ => {
10063                        unknown_key__ = Some(key);
10064                        let _: IgnoredAny = map.next_value()?;
10065                    }
10066                }
10067            }
10068            let gamemod = NightcoreTaiko {
10069                speed_change: speed_change.unwrap_or_default(),
10070            };
10071            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10072        }
10073    }
10074    impl Serialize for NightcoreTaiko {
10075        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10076            let field_count = self.speed_change.is_some() as usize;
10077            let mut map = s.serialize_map(Some(field_count))?;
10078            if let Some(ref x) = self.speed_change {
10079                map.serialize_entry("speed_change", x)?;
10080            }
10081            map.end()
10082        }
10083    }
10084    impl<'de> Visitor<'de> for GameModVisitor<HiddenTaiko> {
10085        type Value = DeserializedGameMod<'de, HiddenTaiko>;
10086        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10087            f.write_str("HiddenTaiko")
10088        }
10089        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10090            const FIELDS: &'static [&'static str] = &[];
10091            let mut unknown_key__ = None;
10092            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10093                match key.as_str() {
10094                    _ => {
10095                        unknown_key__ = Some(key);
10096                        let _: IgnoredAny = map.next_value()?;
10097                    }
10098                }
10099            }
10100            let gamemod = HiddenTaiko {};
10101            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10102        }
10103    }
10104    impl Serialize for HiddenTaiko {
10105        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10106            let field_count = 0;
10107            let map = s.serialize_map(Some(field_count))?;
10108            map.end()
10109        }
10110    }
10111    impl<'de> Visitor<'de> for GameModVisitor<FlashlightTaiko> {
10112        type Value = DeserializedGameMod<'de, FlashlightTaiko>;
10113        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10114            f.write_str("FlashlightTaiko")
10115        }
10116        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10117            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
10118            let mut unknown_key__ = None;
10119            let mut size_multiplier = None;
10120            let mut combo_based_size = None;
10121            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10122                match key.as_str() {
10123                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
10124                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
10125                    _ => {
10126                        unknown_key__ = Some(key);
10127                        let _: IgnoredAny = map.next_value()?;
10128                    }
10129                }
10130            }
10131            let gamemod = FlashlightTaiko {
10132                size_multiplier: size_multiplier.unwrap_or_default(),
10133                combo_based_size: combo_based_size.unwrap_or_default(),
10134            };
10135            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10136        }
10137    }
10138    impl Serialize for FlashlightTaiko {
10139        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10140            let field_count =
10141                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
10142            let mut map = s.serialize_map(Some(field_count))?;
10143            if let Some(ref x) = self.size_multiplier {
10144                map.serialize_entry("size_multiplier", x)?;
10145            }
10146            if let Some(ref x) = self.combo_based_size {
10147                map.serialize_entry("combo_based_size", x)?;
10148            }
10149            map.end()
10150        }
10151    }
10152    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeTaiko> {
10153        type Value = DeserializedGameMod<'de, AccuracyChallengeTaiko>;
10154        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10155            f.write_str("AccuracyChallengeTaiko")
10156        }
10157        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10158            const FIELDS: &'static [&'static str] =
10159                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
10160            let mut unknown_key__ = None;
10161            let mut minimum_accuracy = None;
10162            let mut accuracy_judge_mode = None;
10163            let mut restart = None;
10164            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10165                match key.as_str() {
10166                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
10167                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
10168                    "restart" => restart = Some(map.next_value()?),
10169                    _ => {
10170                        unknown_key__ = Some(key);
10171                        let _: IgnoredAny = map.next_value()?;
10172                    }
10173                }
10174            }
10175            let gamemod = AccuracyChallengeTaiko {
10176                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
10177                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
10178                restart: restart.unwrap_or_default(),
10179            };
10180            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10181        }
10182    }
10183    impl Serialize for AccuracyChallengeTaiko {
10184        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10185            let field_count = self.minimum_accuracy.is_some() as usize
10186                + self.accuracy_judge_mode.is_some() as usize
10187                + self.restart.is_some() as usize;
10188            let mut map = s.serialize_map(Some(field_count))?;
10189            if let Some(ref x) = self.minimum_accuracy {
10190                map.serialize_entry("minimum_accuracy", x)?;
10191            }
10192            if let Some(ref x) = self.accuracy_judge_mode {
10193                map.serialize_entry("accuracy_judge_mode", x)?;
10194            }
10195            if let Some(ref x) = self.restart {
10196                map.serialize_entry("restart", x)?;
10197            }
10198            map.end()
10199        }
10200    }
10201    impl<'de> Visitor<'de> for GameModVisitor<RandomTaiko> {
10202        type Value = DeserializedGameMod<'de, RandomTaiko>;
10203        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10204            f.write_str("RandomTaiko")
10205        }
10206        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10207            const FIELDS: &'static [&'static str] = &["seed"];
10208            let mut unknown_key__ = None;
10209            let mut seed = None;
10210            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10211                match key.as_str() {
10212                    "seed" => seed = Some(map.next_value()?),
10213                    _ => {
10214                        unknown_key__ = Some(key);
10215                        let _: IgnoredAny = map.next_value()?;
10216                    }
10217                }
10218            }
10219            let gamemod = RandomTaiko {
10220                seed: seed.unwrap_or_default(),
10221            };
10222            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10223        }
10224    }
10225    impl Serialize for RandomTaiko {
10226        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10227            let field_count = self.seed.is_some() as usize;
10228            let mut map = s.serialize_map(Some(field_count))?;
10229            if let Some(ref x) = self.seed {
10230                map.serialize_entry("seed", x)?;
10231            }
10232            map.end()
10233        }
10234    }
10235    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustTaiko> {
10236        type Value = DeserializedGameMod<'de, DifficultyAdjustTaiko>;
10237        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10238            f.write_str("DifficultyAdjustTaiko")
10239        }
10240        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10241            const FIELDS: &'static [&'static str] = &[
10242                "scroll_speed",
10243                "drain_rate",
10244                "overall_difficulty",
10245                "extended_limits",
10246            ];
10247            let mut unknown_key__ = None;
10248            let mut scroll_speed = None;
10249            let mut drain_rate = None;
10250            let mut overall_difficulty = None;
10251            let mut extended_limits = None;
10252            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10253                match key.as_str() {
10254                    "scroll_speed" => scroll_speed = Some(map.next_value()?),
10255                    "drain_rate" => drain_rate = Some(map.next_value()?),
10256                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
10257                    "extended_limits" => extended_limits = Some(map.next_value()?),
10258                    _ => {
10259                        unknown_key__ = Some(key);
10260                        let _: IgnoredAny = map.next_value()?;
10261                    }
10262                }
10263            }
10264            let gamemod = DifficultyAdjustTaiko {
10265                scroll_speed: scroll_speed.unwrap_or_default(),
10266                drain_rate: drain_rate.unwrap_or_default(),
10267                overall_difficulty: overall_difficulty.unwrap_or_default(),
10268                extended_limits: extended_limits.unwrap_or_default(),
10269            };
10270            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10271        }
10272    }
10273    impl Serialize for DifficultyAdjustTaiko {
10274        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10275            let field_count = self.scroll_speed.is_some() as usize
10276                + self.drain_rate.is_some() as usize
10277                + self.overall_difficulty.is_some() as usize
10278                + self.extended_limits.is_some() as usize;
10279            let mut map = s.serialize_map(Some(field_count))?;
10280            if let Some(ref x) = self.scroll_speed {
10281                map.serialize_entry("scroll_speed", x)?;
10282            }
10283            if let Some(ref x) = self.drain_rate {
10284                map.serialize_entry("drain_rate", x)?;
10285            }
10286            if let Some(ref x) = self.overall_difficulty {
10287                map.serialize_entry("overall_difficulty", x)?;
10288            }
10289            if let Some(ref x) = self.extended_limits {
10290                map.serialize_entry("extended_limits", x)?;
10291            }
10292            map.end()
10293        }
10294    }
10295    impl<'de> Visitor<'de> for GameModVisitor<ClassicTaiko> {
10296        type Value = DeserializedGameMod<'de, ClassicTaiko>;
10297        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10298            f.write_str("ClassicTaiko")
10299        }
10300        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10301            const FIELDS: &'static [&'static str] = &[];
10302            let mut unknown_key__ = None;
10303            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10304                match key.as_str() {
10305                    _ => {
10306                        unknown_key__ = Some(key);
10307                        let _: IgnoredAny = map.next_value()?;
10308                    }
10309                }
10310            }
10311            let gamemod = ClassicTaiko {};
10312            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10313        }
10314    }
10315    impl Serialize for ClassicTaiko {
10316        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10317            let field_count = 0;
10318            let map = s.serialize_map(Some(field_count))?;
10319            map.end()
10320        }
10321    }
10322    impl<'de> Visitor<'de> for GameModVisitor<SwapTaiko> {
10323        type Value = DeserializedGameMod<'de, SwapTaiko>;
10324        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10325            f.write_str("SwapTaiko")
10326        }
10327        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10328            const FIELDS: &'static [&'static str] = &[];
10329            let mut unknown_key__ = None;
10330            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10331                match key.as_str() {
10332                    _ => {
10333                        unknown_key__ = Some(key);
10334                        let _: IgnoredAny = map.next_value()?;
10335                    }
10336                }
10337            }
10338            let gamemod = SwapTaiko {};
10339            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10340        }
10341    }
10342    impl Serialize for SwapTaiko {
10343        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10344            let field_count = 0;
10345            let map = s.serialize_map(Some(field_count))?;
10346            map.end()
10347        }
10348    }
10349    impl<'de> Visitor<'de> for GameModVisitor<SingleTapTaiko> {
10350        type Value = DeserializedGameMod<'de, SingleTapTaiko>;
10351        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10352            f.write_str("SingleTapTaiko")
10353        }
10354        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10355            const FIELDS: &'static [&'static str] = &[];
10356            let mut unknown_key__ = None;
10357            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10358                match key.as_str() {
10359                    _ => {
10360                        unknown_key__ = Some(key);
10361                        let _: IgnoredAny = map.next_value()?;
10362                    }
10363                }
10364            }
10365            let gamemod = SingleTapTaiko {};
10366            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10367        }
10368    }
10369    impl Serialize for SingleTapTaiko {
10370        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10371            let field_count = 0;
10372            let map = s.serialize_map(Some(field_count))?;
10373            map.end()
10374        }
10375    }
10376    impl<'de> Visitor<'de> for GameModVisitor<ConstantSpeedTaiko> {
10377        type Value = DeserializedGameMod<'de, ConstantSpeedTaiko>;
10378        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10379            f.write_str("ConstantSpeedTaiko")
10380        }
10381        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10382            const FIELDS: &'static [&'static str] = &[];
10383            let mut unknown_key__ = None;
10384            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10385                match key.as_str() {
10386                    _ => {
10387                        unknown_key__ = Some(key);
10388                        let _: IgnoredAny = map.next_value()?;
10389                    }
10390                }
10391            }
10392            let gamemod = ConstantSpeedTaiko {};
10393            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10394        }
10395    }
10396    impl Serialize for ConstantSpeedTaiko {
10397        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10398            let field_count = 0;
10399            let map = s.serialize_map(Some(field_count))?;
10400            map.end()
10401        }
10402    }
10403    impl<'de> Visitor<'de> for GameModVisitor<AutoplayTaiko> {
10404        type Value = DeserializedGameMod<'de, AutoplayTaiko>;
10405        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10406            f.write_str("AutoplayTaiko")
10407        }
10408        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10409            const FIELDS: &'static [&'static str] = &[];
10410            let mut unknown_key__ = None;
10411            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10412                match key.as_str() {
10413                    _ => {
10414                        unknown_key__ = Some(key);
10415                        let _: IgnoredAny = map.next_value()?;
10416                    }
10417                }
10418            }
10419            let gamemod = AutoplayTaiko {};
10420            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10421        }
10422    }
10423    impl Serialize for AutoplayTaiko {
10424        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10425            let field_count = 0;
10426            let map = s.serialize_map(Some(field_count))?;
10427            map.end()
10428        }
10429    }
10430    impl<'de> Visitor<'de> for GameModVisitor<CinemaTaiko> {
10431        type Value = DeserializedGameMod<'de, CinemaTaiko>;
10432        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10433            f.write_str("CinemaTaiko")
10434        }
10435        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10436            const FIELDS: &'static [&'static str] = &[];
10437            let mut unknown_key__ = None;
10438            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10439                match key.as_str() {
10440                    _ => {
10441                        unknown_key__ = Some(key);
10442                        let _: IgnoredAny = map.next_value()?;
10443                    }
10444                }
10445            }
10446            let gamemod = CinemaTaiko {};
10447            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10448        }
10449    }
10450    impl Serialize for CinemaTaiko {
10451        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10452            let field_count = 0;
10453            let map = s.serialize_map(Some(field_count))?;
10454            map.end()
10455        }
10456    }
10457    impl<'de> Visitor<'de> for GameModVisitor<RelaxTaiko> {
10458        type Value = DeserializedGameMod<'de, RelaxTaiko>;
10459        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10460            f.write_str("RelaxTaiko")
10461        }
10462        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10463            const FIELDS: &'static [&'static str] = &[];
10464            let mut unknown_key__ = None;
10465            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10466                match key.as_str() {
10467                    _ => {
10468                        unknown_key__ = Some(key);
10469                        let _: IgnoredAny = map.next_value()?;
10470                    }
10471                }
10472            }
10473            let gamemod = RelaxTaiko {};
10474            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10475        }
10476    }
10477    impl Serialize for RelaxTaiko {
10478        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10479            let field_count = 0;
10480            let map = s.serialize_map(Some(field_count))?;
10481            map.end()
10482        }
10483    }
10484    impl<'de> Visitor<'de> for GameModVisitor<WindUpTaiko> {
10485        type Value = DeserializedGameMod<'de, WindUpTaiko>;
10486        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10487            f.write_str("WindUpTaiko")
10488        }
10489        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10490            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
10491            let mut unknown_key__ = None;
10492            let mut initial_rate = None;
10493            let mut final_rate = None;
10494            let mut adjust_pitch = None;
10495            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10496                match key.as_str() {
10497                    "initial_rate" => initial_rate = Some(map.next_value()?),
10498                    "final_rate" => final_rate = Some(map.next_value()?),
10499                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10500                    _ => {
10501                        unknown_key__ = Some(key);
10502                        let _: IgnoredAny = map.next_value()?;
10503                    }
10504                }
10505            }
10506            let gamemod = WindUpTaiko {
10507                initial_rate: initial_rate.unwrap_or_default(),
10508                final_rate: final_rate.unwrap_or_default(),
10509                adjust_pitch: adjust_pitch.unwrap_or_default(),
10510            };
10511            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10512        }
10513    }
10514    impl Serialize for WindUpTaiko {
10515        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10516            let field_count = self.initial_rate.is_some() as usize
10517                + self.final_rate.is_some() as usize
10518                + self.adjust_pitch.is_some() as usize;
10519            let mut map = s.serialize_map(Some(field_count))?;
10520            if let Some(ref x) = self.initial_rate {
10521                map.serialize_entry("initial_rate", x)?;
10522            }
10523            if let Some(ref x) = self.final_rate {
10524                map.serialize_entry("final_rate", x)?;
10525            }
10526            if let Some(ref x) = self.adjust_pitch {
10527                map.serialize_entry("adjust_pitch", x)?;
10528            }
10529            map.end()
10530        }
10531    }
10532    impl<'de> Visitor<'de> for GameModVisitor<WindDownTaiko> {
10533        type Value = DeserializedGameMod<'de, WindDownTaiko>;
10534        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10535            f.write_str("WindDownTaiko")
10536        }
10537        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10538            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
10539            let mut unknown_key__ = None;
10540            let mut initial_rate = None;
10541            let mut final_rate = None;
10542            let mut adjust_pitch = None;
10543            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10544                match key.as_str() {
10545                    "initial_rate" => initial_rate = Some(map.next_value()?),
10546                    "final_rate" => final_rate = Some(map.next_value()?),
10547                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10548                    _ => {
10549                        unknown_key__ = Some(key);
10550                        let _: IgnoredAny = map.next_value()?;
10551                    }
10552                }
10553            }
10554            let gamemod = WindDownTaiko {
10555                initial_rate: initial_rate.unwrap_or_default(),
10556                final_rate: final_rate.unwrap_or_default(),
10557                adjust_pitch: adjust_pitch.unwrap_or_default(),
10558            };
10559            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10560        }
10561    }
10562    impl Serialize for WindDownTaiko {
10563        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10564            let field_count = self.initial_rate.is_some() as usize
10565                + self.final_rate.is_some() as usize
10566                + self.adjust_pitch.is_some() as usize;
10567            let mut map = s.serialize_map(Some(field_count))?;
10568            if let Some(ref x) = self.initial_rate {
10569                map.serialize_entry("initial_rate", x)?;
10570            }
10571            if let Some(ref x) = self.final_rate {
10572                map.serialize_entry("final_rate", x)?;
10573            }
10574            if let Some(ref x) = self.adjust_pitch {
10575                map.serialize_entry("adjust_pitch", x)?;
10576            }
10577            map.end()
10578        }
10579    }
10580    impl<'de> Visitor<'de> for GameModVisitor<MutedTaiko> {
10581        type Value = DeserializedGameMod<'de, MutedTaiko>;
10582        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10583            f.write_str("MutedTaiko")
10584        }
10585        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10586            const FIELDS: &'static [&'static str] = &[
10587                "inverse_muting",
10588                "enable_metronome",
10589                "mute_combo_count",
10590                "affects_hit_sounds",
10591            ];
10592            let mut unknown_key__ = None;
10593            let mut inverse_muting = None;
10594            let mut enable_metronome = None;
10595            let mut mute_combo_count = None;
10596            let mut affects_hit_sounds = None;
10597            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10598                match key.as_str() {
10599                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
10600                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
10601                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
10602                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
10603                    _ => {
10604                        unknown_key__ = Some(key);
10605                        let _: IgnoredAny = map.next_value()?;
10606                    }
10607                }
10608            }
10609            let gamemod = MutedTaiko {
10610                inverse_muting: inverse_muting.unwrap_or_default(),
10611                enable_metronome: enable_metronome.unwrap_or_default(),
10612                mute_combo_count: mute_combo_count.unwrap_or_default(),
10613                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
10614            };
10615            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10616        }
10617    }
10618    impl Serialize for MutedTaiko {
10619        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10620            let field_count = self.inverse_muting.is_some() as usize
10621                + self.enable_metronome.is_some() as usize
10622                + self.mute_combo_count.is_some() as usize
10623                + self.affects_hit_sounds.is_some() as usize;
10624            let mut map = s.serialize_map(Some(field_count))?;
10625            if let Some(ref x) = self.inverse_muting {
10626                map.serialize_entry("inverse_muting", x)?;
10627            }
10628            if let Some(ref x) = self.enable_metronome {
10629                map.serialize_entry("enable_metronome", x)?;
10630            }
10631            if let Some(ref x) = self.mute_combo_count {
10632                map.serialize_entry("mute_combo_count", x)?;
10633            }
10634            if let Some(ref x) = self.affects_hit_sounds {
10635                map.serialize_entry("affects_hit_sounds", x)?;
10636            }
10637            map.end()
10638        }
10639    }
10640    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedTaiko> {
10641        type Value = DeserializedGameMod<'de, AdaptiveSpeedTaiko>;
10642        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10643            f.write_str("AdaptiveSpeedTaiko")
10644        }
10645        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10646            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
10647            let mut unknown_key__ = None;
10648            let mut initial_rate = None;
10649            let mut adjust_pitch = None;
10650            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10651                match key.as_str() {
10652                    "initial_rate" => initial_rate = Some(map.next_value()?),
10653                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10654                    _ => {
10655                        unknown_key__ = Some(key);
10656                        let _: IgnoredAny = map.next_value()?;
10657                    }
10658                }
10659            }
10660            let gamemod = AdaptiveSpeedTaiko {
10661                initial_rate: initial_rate.unwrap_or_default(),
10662                adjust_pitch: adjust_pitch.unwrap_or_default(),
10663            };
10664            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10665        }
10666    }
10667    impl Serialize for AdaptiveSpeedTaiko {
10668        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10669            let field_count =
10670                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
10671            let mut map = s.serialize_map(Some(field_count))?;
10672            if let Some(ref x) = self.initial_rate {
10673                map.serialize_entry("initial_rate", x)?;
10674            }
10675            if let Some(ref x) = self.adjust_pitch {
10676                map.serialize_entry("adjust_pitch", x)?;
10677            }
10678            map.end()
10679        }
10680    }
10681    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Taiko> {
10682        type Value = DeserializedGameMod<'de, ScoreV2Taiko>;
10683        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10684            f.write_str("ScoreV2Taiko")
10685        }
10686        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10687            const FIELDS: &'static [&'static str] = &[];
10688            let mut unknown_key__ = None;
10689            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10690                match key.as_str() {
10691                    _ => {
10692                        unknown_key__ = Some(key);
10693                        let _: IgnoredAny = map.next_value()?;
10694                    }
10695                }
10696            }
10697            let gamemod = ScoreV2Taiko {};
10698            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10699        }
10700    }
10701    impl Serialize for ScoreV2Taiko {
10702        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10703            let field_count = 0;
10704            let map = s.serialize_map(Some(field_count))?;
10705            map.end()
10706        }
10707    }
10708    impl<'de> Visitor<'de> for GameModVisitor<EasyCatch> {
10709        type Value = DeserializedGameMod<'de, EasyCatch>;
10710        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10711            f.write_str("EasyCatch")
10712        }
10713        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10714            const FIELDS: &'static [&'static str] = &["retries"];
10715            let mut unknown_key__ = None;
10716            let mut retries = None;
10717            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10718                match key.as_str() {
10719                    "retries" => retries = Some(map.next_value()?),
10720                    _ => {
10721                        unknown_key__ = Some(key);
10722                        let _: IgnoredAny = map.next_value()?;
10723                    }
10724                }
10725            }
10726            let gamemod = EasyCatch {
10727                retries: retries.unwrap_or_default(),
10728            };
10729            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10730        }
10731    }
10732    impl Serialize for EasyCatch {
10733        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10734            let field_count = self.retries.is_some() as usize;
10735            let mut map = s.serialize_map(Some(field_count))?;
10736            if let Some(ref x) = self.retries {
10737                map.serialize_entry("retries", x)?;
10738            }
10739            map.end()
10740        }
10741    }
10742    impl<'de> Visitor<'de> for GameModVisitor<NoFailCatch> {
10743        type Value = DeserializedGameMod<'de, NoFailCatch>;
10744        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10745            f.write_str("NoFailCatch")
10746        }
10747        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10748            const FIELDS: &'static [&'static str] = &[];
10749            let mut unknown_key__ = None;
10750            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10751                match key.as_str() {
10752                    _ => {
10753                        unknown_key__ = Some(key);
10754                        let _: IgnoredAny = map.next_value()?;
10755                    }
10756                }
10757            }
10758            let gamemod = NoFailCatch {};
10759            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10760        }
10761    }
10762    impl Serialize for NoFailCatch {
10763        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10764            let field_count = 0;
10765            let map = s.serialize_map(Some(field_count))?;
10766            map.end()
10767        }
10768    }
10769    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeCatch> {
10770        type Value = DeserializedGameMod<'de, HalfTimeCatch>;
10771        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10772            f.write_str("HalfTimeCatch")
10773        }
10774        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10775            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
10776            let mut unknown_key__ = None;
10777            let mut speed_change = None;
10778            let mut adjust_pitch = None;
10779            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10780                match key.as_str() {
10781                    "speed_change" => speed_change = Some(map.next_value()?),
10782                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10783                    _ => {
10784                        unknown_key__ = Some(key);
10785                        let _: IgnoredAny = map.next_value()?;
10786                    }
10787                }
10788            }
10789            let gamemod = HalfTimeCatch {
10790                speed_change: speed_change.unwrap_or_default(),
10791                adjust_pitch: adjust_pitch.unwrap_or_default(),
10792            };
10793            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10794        }
10795    }
10796    impl Serialize for HalfTimeCatch {
10797        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10798            let field_count =
10799                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
10800            let mut map = s.serialize_map(Some(field_count))?;
10801            if let Some(ref x) = self.speed_change {
10802                map.serialize_entry("speed_change", x)?;
10803            }
10804            if let Some(ref x) = self.adjust_pitch {
10805                map.serialize_entry("adjust_pitch", x)?;
10806            }
10807            map.end()
10808        }
10809    }
10810    impl<'de> Visitor<'de> for GameModVisitor<DaycoreCatch> {
10811        type Value = DeserializedGameMod<'de, DaycoreCatch>;
10812        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10813            f.write_str("DaycoreCatch")
10814        }
10815        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10816            const FIELDS: &'static [&'static str] = &["speed_change"];
10817            let mut unknown_key__ = None;
10818            let mut speed_change = None;
10819            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10820                match key.as_str() {
10821                    "speed_change" => speed_change = Some(map.next_value()?),
10822                    _ => {
10823                        unknown_key__ = Some(key);
10824                        let _: IgnoredAny = map.next_value()?;
10825                    }
10826                }
10827            }
10828            let gamemod = DaycoreCatch {
10829                speed_change: speed_change.unwrap_or_default(),
10830            };
10831            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10832        }
10833    }
10834    impl Serialize for DaycoreCatch {
10835        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10836            let field_count = self.speed_change.is_some() as usize;
10837            let mut map = s.serialize_map(Some(field_count))?;
10838            if let Some(ref x) = self.speed_change {
10839                map.serialize_entry("speed_change", x)?;
10840            }
10841            map.end()
10842        }
10843    }
10844    impl<'de> Visitor<'de> for GameModVisitor<HardRockCatch> {
10845        type Value = DeserializedGameMod<'de, HardRockCatch>;
10846        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10847            f.write_str("HardRockCatch")
10848        }
10849        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10850            const FIELDS: &'static [&'static str] = &[];
10851            let mut unknown_key__ = None;
10852            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10853                match key.as_str() {
10854                    _ => {
10855                        unknown_key__ = Some(key);
10856                        let _: IgnoredAny = map.next_value()?;
10857                    }
10858                }
10859            }
10860            let gamemod = HardRockCatch {};
10861            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10862        }
10863    }
10864    impl Serialize for HardRockCatch {
10865        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10866            let field_count = 0;
10867            let map = s.serialize_map(Some(field_count))?;
10868            map.end()
10869        }
10870    }
10871    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathCatch> {
10872        type Value = DeserializedGameMod<'de, SuddenDeathCatch>;
10873        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10874            f.write_str("SuddenDeathCatch")
10875        }
10876        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10877            const FIELDS: &'static [&'static str] = &["restart"];
10878            let mut unknown_key__ = None;
10879            let mut restart = None;
10880            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10881                match key.as_str() {
10882                    "restart" => restart = Some(map.next_value()?),
10883                    _ => {
10884                        unknown_key__ = Some(key);
10885                        let _: IgnoredAny = map.next_value()?;
10886                    }
10887                }
10888            }
10889            let gamemod = SuddenDeathCatch {
10890                restart: restart.unwrap_or_default(),
10891            };
10892            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10893        }
10894    }
10895    impl Serialize for SuddenDeathCatch {
10896        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10897            let field_count = self.restart.is_some() as usize;
10898            let mut map = s.serialize_map(Some(field_count))?;
10899            if let Some(ref x) = self.restart {
10900                map.serialize_entry("restart", x)?;
10901            }
10902            map.end()
10903        }
10904    }
10905    impl<'de> Visitor<'de> for GameModVisitor<PerfectCatch> {
10906        type Value = DeserializedGameMod<'de, PerfectCatch>;
10907        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10908            f.write_str("PerfectCatch")
10909        }
10910        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10911            const FIELDS: &'static [&'static str] = &["restart"];
10912            let mut unknown_key__ = None;
10913            let mut restart = None;
10914            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10915                match key.as_str() {
10916                    "restart" => restart = Some(map.next_value()?),
10917                    _ => {
10918                        unknown_key__ = Some(key);
10919                        let _: IgnoredAny = map.next_value()?;
10920                    }
10921                }
10922            }
10923            let gamemod = PerfectCatch {
10924                restart: restart.unwrap_or_default(),
10925            };
10926            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10927        }
10928    }
10929    impl Serialize for PerfectCatch {
10930        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10931            let field_count = self.restart.is_some() as usize;
10932            let mut map = s.serialize_map(Some(field_count))?;
10933            if let Some(ref x) = self.restart {
10934                map.serialize_entry("restart", x)?;
10935            }
10936            map.end()
10937        }
10938    }
10939    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeCatch> {
10940        type Value = DeserializedGameMod<'de, DoubleTimeCatch>;
10941        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10942            f.write_str("DoubleTimeCatch")
10943        }
10944        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10945            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
10946            let mut unknown_key__ = None;
10947            let mut speed_change = None;
10948            let mut adjust_pitch = None;
10949            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10950                match key.as_str() {
10951                    "speed_change" => speed_change = Some(map.next_value()?),
10952                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10953                    _ => {
10954                        unknown_key__ = Some(key);
10955                        let _: IgnoredAny = map.next_value()?;
10956                    }
10957                }
10958            }
10959            let gamemod = DoubleTimeCatch {
10960                speed_change: speed_change.unwrap_or_default(),
10961                adjust_pitch: adjust_pitch.unwrap_or_default(),
10962            };
10963            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10964        }
10965    }
10966    impl Serialize for DoubleTimeCatch {
10967        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10968            let field_count =
10969                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
10970            let mut map = s.serialize_map(Some(field_count))?;
10971            if let Some(ref x) = self.speed_change {
10972                map.serialize_entry("speed_change", x)?;
10973            }
10974            if let Some(ref x) = self.adjust_pitch {
10975                map.serialize_entry("adjust_pitch", x)?;
10976            }
10977            map.end()
10978        }
10979    }
10980    impl<'de> Visitor<'de> for GameModVisitor<NightcoreCatch> {
10981        type Value = DeserializedGameMod<'de, NightcoreCatch>;
10982        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10983            f.write_str("NightcoreCatch")
10984        }
10985        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10986            const FIELDS: &'static [&'static str] = &["speed_change"];
10987            let mut unknown_key__ = None;
10988            let mut speed_change = None;
10989            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10990                match key.as_str() {
10991                    "speed_change" => speed_change = Some(map.next_value()?),
10992                    _ => {
10993                        unknown_key__ = Some(key);
10994                        let _: IgnoredAny = map.next_value()?;
10995                    }
10996                }
10997            }
10998            let gamemod = NightcoreCatch {
10999                speed_change: speed_change.unwrap_or_default(),
11000            };
11001            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11002        }
11003    }
11004    impl Serialize for NightcoreCatch {
11005        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11006            let field_count = self.speed_change.is_some() as usize;
11007            let mut map = s.serialize_map(Some(field_count))?;
11008            if let Some(ref x) = self.speed_change {
11009                map.serialize_entry("speed_change", x)?;
11010            }
11011            map.end()
11012        }
11013    }
11014    impl<'de> Visitor<'de> for GameModVisitor<HiddenCatch> {
11015        type Value = DeserializedGameMod<'de, HiddenCatch>;
11016        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11017            f.write_str("HiddenCatch")
11018        }
11019        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11020            const FIELDS: &'static [&'static str] = &[];
11021            let mut unknown_key__ = None;
11022            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11023                match key.as_str() {
11024                    _ => {
11025                        unknown_key__ = Some(key);
11026                        let _: IgnoredAny = map.next_value()?;
11027                    }
11028                }
11029            }
11030            let gamemod = HiddenCatch {};
11031            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11032        }
11033    }
11034    impl Serialize for HiddenCatch {
11035        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11036            let field_count = 0;
11037            let map = s.serialize_map(Some(field_count))?;
11038            map.end()
11039        }
11040    }
11041    impl<'de> Visitor<'de> for GameModVisitor<FlashlightCatch> {
11042        type Value = DeserializedGameMod<'de, FlashlightCatch>;
11043        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11044            f.write_str("FlashlightCatch")
11045        }
11046        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11047            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
11048            let mut unknown_key__ = None;
11049            let mut size_multiplier = None;
11050            let mut combo_based_size = None;
11051            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11052                match key.as_str() {
11053                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
11054                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
11055                    _ => {
11056                        unknown_key__ = Some(key);
11057                        let _: IgnoredAny = map.next_value()?;
11058                    }
11059                }
11060            }
11061            let gamemod = FlashlightCatch {
11062                size_multiplier: size_multiplier.unwrap_or_default(),
11063                combo_based_size: combo_based_size.unwrap_or_default(),
11064            };
11065            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11066        }
11067    }
11068    impl Serialize for FlashlightCatch {
11069        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11070            let field_count =
11071                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
11072            let mut map = s.serialize_map(Some(field_count))?;
11073            if let Some(ref x) = self.size_multiplier {
11074                map.serialize_entry("size_multiplier", x)?;
11075            }
11076            if let Some(ref x) = self.combo_based_size {
11077                map.serialize_entry("combo_based_size", x)?;
11078            }
11079            map.end()
11080        }
11081    }
11082    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeCatch> {
11083        type Value = DeserializedGameMod<'de, AccuracyChallengeCatch>;
11084        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11085            f.write_str("AccuracyChallengeCatch")
11086        }
11087        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11088            const FIELDS: &'static [&'static str] =
11089                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
11090            let mut unknown_key__ = None;
11091            let mut minimum_accuracy = None;
11092            let mut accuracy_judge_mode = None;
11093            let mut restart = None;
11094            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11095                match key.as_str() {
11096                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
11097                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
11098                    "restart" => restart = Some(map.next_value()?),
11099                    _ => {
11100                        unknown_key__ = Some(key);
11101                        let _: IgnoredAny = map.next_value()?;
11102                    }
11103                }
11104            }
11105            let gamemod = AccuracyChallengeCatch {
11106                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
11107                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
11108                restart: restart.unwrap_or_default(),
11109            };
11110            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11111        }
11112    }
11113    impl Serialize for AccuracyChallengeCatch {
11114        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11115            let field_count = self.minimum_accuracy.is_some() as usize
11116                + self.accuracy_judge_mode.is_some() as usize
11117                + self.restart.is_some() as usize;
11118            let mut map = s.serialize_map(Some(field_count))?;
11119            if let Some(ref x) = self.minimum_accuracy {
11120                map.serialize_entry("minimum_accuracy", x)?;
11121            }
11122            if let Some(ref x) = self.accuracy_judge_mode {
11123                map.serialize_entry("accuracy_judge_mode", x)?;
11124            }
11125            if let Some(ref x) = self.restart {
11126                map.serialize_entry("restart", x)?;
11127            }
11128            map.end()
11129        }
11130    }
11131    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustCatch> {
11132        type Value = DeserializedGameMod<'de, DifficultyAdjustCatch>;
11133        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11134            f.write_str("DifficultyAdjustCatch")
11135        }
11136        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11137            const FIELDS: &'static [&'static str] = &[
11138                "circle_size",
11139                "approach_rate",
11140                "hard_rock_offsets",
11141                "drain_rate",
11142                "overall_difficulty",
11143                "extended_limits",
11144            ];
11145            let mut unknown_key__ = None;
11146            let mut circle_size = None;
11147            let mut approach_rate = None;
11148            let mut hard_rock_offsets = None;
11149            let mut drain_rate = None;
11150            let mut overall_difficulty = None;
11151            let mut extended_limits = None;
11152            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11153                match key.as_str() {
11154                    "circle_size" => circle_size = Some(map.next_value()?),
11155                    "approach_rate" => approach_rate = Some(map.next_value()?),
11156                    "hard_rock_offsets" => hard_rock_offsets = Some(map.next_value()?),
11157                    "drain_rate" => drain_rate = Some(map.next_value()?),
11158                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
11159                    "extended_limits" => extended_limits = Some(map.next_value()?),
11160                    _ => {
11161                        unknown_key__ = Some(key);
11162                        let _: IgnoredAny = map.next_value()?;
11163                    }
11164                }
11165            }
11166            let gamemod = DifficultyAdjustCatch {
11167                circle_size: circle_size.unwrap_or_default(),
11168                approach_rate: approach_rate.unwrap_or_default(),
11169                hard_rock_offsets: hard_rock_offsets.unwrap_or_default(),
11170                drain_rate: drain_rate.unwrap_or_default(),
11171                overall_difficulty: overall_difficulty.unwrap_or_default(),
11172                extended_limits: extended_limits.unwrap_or_default(),
11173            };
11174            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11175        }
11176    }
11177    impl Serialize for DifficultyAdjustCatch {
11178        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11179            let field_count = self.circle_size.is_some() as usize
11180                + self.approach_rate.is_some() as usize
11181                + self.hard_rock_offsets.is_some() as usize
11182                + self.drain_rate.is_some() as usize
11183                + self.overall_difficulty.is_some() as usize
11184                + self.extended_limits.is_some() as usize;
11185            let mut map = s.serialize_map(Some(field_count))?;
11186            if let Some(ref x) = self.circle_size {
11187                map.serialize_entry("circle_size", x)?;
11188            }
11189            if let Some(ref x) = self.approach_rate {
11190                map.serialize_entry("approach_rate", x)?;
11191            }
11192            if let Some(ref x) = self.hard_rock_offsets {
11193                map.serialize_entry("hard_rock_offsets", x)?;
11194            }
11195            if let Some(ref x) = self.drain_rate {
11196                map.serialize_entry("drain_rate", x)?;
11197            }
11198            if let Some(ref x) = self.overall_difficulty {
11199                map.serialize_entry("overall_difficulty", x)?;
11200            }
11201            if let Some(ref x) = self.extended_limits {
11202                map.serialize_entry("extended_limits", x)?;
11203            }
11204            map.end()
11205        }
11206    }
11207    impl<'de> Visitor<'de> for GameModVisitor<ClassicCatch> {
11208        type Value = DeserializedGameMod<'de, ClassicCatch>;
11209        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11210            f.write_str("ClassicCatch")
11211        }
11212        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11213            const FIELDS: &'static [&'static str] = &[];
11214            let mut unknown_key__ = None;
11215            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11216                match key.as_str() {
11217                    _ => {
11218                        unknown_key__ = Some(key);
11219                        let _: IgnoredAny = map.next_value()?;
11220                    }
11221                }
11222            }
11223            let gamemod = ClassicCatch {};
11224            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11225        }
11226    }
11227    impl Serialize for ClassicCatch {
11228        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11229            let field_count = 0;
11230            let map = s.serialize_map(Some(field_count))?;
11231            map.end()
11232        }
11233    }
11234    impl<'de> Visitor<'de> for GameModVisitor<MirrorCatch> {
11235        type Value = DeserializedGameMod<'de, MirrorCatch>;
11236        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11237            f.write_str("MirrorCatch")
11238        }
11239        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11240            const FIELDS: &'static [&'static str] = &[];
11241            let mut unknown_key__ = None;
11242            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11243                match key.as_str() {
11244                    _ => {
11245                        unknown_key__ = Some(key);
11246                        let _: IgnoredAny = map.next_value()?;
11247                    }
11248                }
11249            }
11250            let gamemod = MirrorCatch {};
11251            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11252        }
11253    }
11254    impl Serialize for MirrorCatch {
11255        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11256            let field_count = 0;
11257            let map = s.serialize_map(Some(field_count))?;
11258            map.end()
11259        }
11260    }
11261    impl<'de> Visitor<'de> for GameModVisitor<AutoplayCatch> {
11262        type Value = DeserializedGameMod<'de, AutoplayCatch>;
11263        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11264            f.write_str("AutoplayCatch")
11265        }
11266        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11267            const FIELDS: &'static [&'static str] = &[];
11268            let mut unknown_key__ = None;
11269            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11270                match key.as_str() {
11271                    _ => {
11272                        unknown_key__ = Some(key);
11273                        let _: IgnoredAny = map.next_value()?;
11274                    }
11275                }
11276            }
11277            let gamemod = AutoplayCatch {};
11278            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11279        }
11280    }
11281    impl Serialize for AutoplayCatch {
11282        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11283            let field_count = 0;
11284            let map = s.serialize_map(Some(field_count))?;
11285            map.end()
11286        }
11287    }
11288    impl<'de> Visitor<'de> for GameModVisitor<CinemaCatch> {
11289        type Value = DeserializedGameMod<'de, CinemaCatch>;
11290        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11291            f.write_str("CinemaCatch")
11292        }
11293        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11294            const FIELDS: &'static [&'static str] = &[];
11295            let mut unknown_key__ = None;
11296            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11297                match key.as_str() {
11298                    _ => {
11299                        unknown_key__ = Some(key);
11300                        let _: IgnoredAny = map.next_value()?;
11301                    }
11302                }
11303            }
11304            let gamemod = CinemaCatch {};
11305            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11306        }
11307    }
11308    impl Serialize for CinemaCatch {
11309        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11310            let field_count = 0;
11311            let map = s.serialize_map(Some(field_count))?;
11312            map.end()
11313        }
11314    }
11315    impl<'de> Visitor<'de> for GameModVisitor<RelaxCatch> {
11316        type Value = DeserializedGameMod<'de, RelaxCatch>;
11317        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11318            f.write_str("RelaxCatch")
11319        }
11320        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11321            const FIELDS: &'static [&'static str] = &[];
11322            let mut unknown_key__ = None;
11323            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11324                match key.as_str() {
11325                    _ => {
11326                        unknown_key__ = Some(key);
11327                        let _: IgnoredAny = map.next_value()?;
11328                    }
11329                }
11330            }
11331            let gamemod = RelaxCatch {};
11332            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11333        }
11334    }
11335    impl Serialize for RelaxCatch {
11336        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11337            let field_count = 0;
11338            let map = s.serialize_map(Some(field_count))?;
11339            map.end()
11340        }
11341    }
11342    impl<'de> Visitor<'de> for GameModVisitor<WindUpCatch> {
11343        type Value = DeserializedGameMod<'de, WindUpCatch>;
11344        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11345            f.write_str("WindUpCatch")
11346        }
11347        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11348            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
11349            let mut unknown_key__ = None;
11350            let mut initial_rate = None;
11351            let mut final_rate = None;
11352            let mut adjust_pitch = None;
11353            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11354                match key.as_str() {
11355                    "initial_rate" => initial_rate = Some(map.next_value()?),
11356                    "final_rate" => final_rate = Some(map.next_value()?),
11357                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11358                    _ => {
11359                        unknown_key__ = Some(key);
11360                        let _: IgnoredAny = map.next_value()?;
11361                    }
11362                }
11363            }
11364            let gamemod = WindUpCatch {
11365                initial_rate: initial_rate.unwrap_or_default(),
11366                final_rate: final_rate.unwrap_or_default(),
11367                adjust_pitch: adjust_pitch.unwrap_or_default(),
11368            };
11369            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11370        }
11371    }
11372    impl Serialize for WindUpCatch {
11373        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11374            let field_count = self.initial_rate.is_some() as usize
11375                + self.final_rate.is_some() as usize
11376                + self.adjust_pitch.is_some() as usize;
11377            let mut map = s.serialize_map(Some(field_count))?;
11378            if let Some(ref x) = self.initial_rate {
11379                map.serialize_entry("initial_rate", x)?;
11380            }
11381            if let Some(ref x) = self.final_rate {
11382                map.serialize_entry("final_rate", x)?;
11383            }
11384            if let Some(ref x) = self.adjust_pitch {
11385                map.serialize_entry("adjust_pitch", x)?;
11386            }
11387            map.end()
11388        }
11389    }
11390    impl<'de> Visitor<'de> for GameModVisitor<WindDownCatch> {
11391        type Value = DeserializedGameMod<'de, WindDownCatch>;
11392        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11393            f.write_str("WindDownCatch")
11394        }
11395        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11396            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
11397            let mut unknown_key__ = None;
11398            let mut initial_rate = None;
11399            let mut final_rate = None;
11400            let mut adjust_pitch = None;
11401            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11402                match key.as_str() {
11403                    "initial_rate" => initial_rate = Some(map.next_value()?),
11404                    "final_rate" => final_rate = Some(map.next_value()?),
11405                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11406                    _ => {
11407                        unknown_key__ = Some(key);
11408                        let _: IgnoredAny = map.next_value()?;
11409                    }
11410                }
11411            }
11412            let gamemod = WindDownCatch {
11413                initial_rate: initial_rate.unwrap_or_default(),
11414                final_rate: final_rate.unwrap_or_default(),
11415                adjust_pitch: adjust_pitch.unwrap_or_default(),
11416            };
11417            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11418        }
11419    }
11420    impl Serialize for WindDownCatch {
11421        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11422            let field_count = self.initial_rate.is_some() as usize
11423                + self.final_rate.is_some() as usize
11424                + self.adjust_pitch.is_some() as usize;
11425            let mut map = s.serialize_map(Some(field_count))?;
11426            if let Some(ref x) = self.initial_rate {
11427                map.serialize_entry("initial_rate", x)?;
11428            }
11429            if let Some(ref x) = self.final_rate {
11430                map.serialize_entry("final_rate", x)?;
11431            }
11432            if let Some(ref x) = self.adjust_pitch {
11433                map.serialize_entry("adjust_pitch", x)?;
11434            }
11435            map.end()
11436        }
11437    }
11438    impl<'de> Visitor<'de> for GameModVisitor<FloatingFruitsCatch> {
11439        type Value = DeserializedGameMod<'de, FloatingFruitsCatch>;
11440        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11441            f.write_str("FloatingFruitsCatch")
11442        }
11443        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11444            const FIELDS: &'static [&'static str] = &[];
11445            let mut unknown_key__ = None;
11446            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11447                match key.as_str() {
11448                    _ => {
11449                        unknown_key__ = Some(key);
11450                        let _: IgnoredAny = map.next_value()?;
11451                    }
11452                }
11453            }
11454            let gamemod = FloatingFruitsCatch {};
11455            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11456        }
11457    }
11458    impl Serialize for FloatingFruitsCatch {
11459        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11460            let field_count = 0;
11461            let map = s.serialize_map(Some(field_count))?;
11462            map.end()
11463        }
11464    }
11465    impl<'de> Visitor<'de> for GameModVisitor<MutedCatch> {
11466        type Value = DeserializedGameMod<'de, MutedCatch>;
11467        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11468            f.write_str("MutedCatch")
11469        }
11470        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11471            const FIELDS: &'static [&'static str] = &[
11472                "inverse_muting",
11473                "enable_metronome",
11474                "mute_combo_count",
11475                "affects_hit_sounds",
11476            ];
11477            let mut unknown_key__ = None;
11478            let mut inverse_muting = None;
11479            let mut enable_metronome = None;
11480            let mut mute_combo_count = None;
11481            let mut affects_hit_sounds = None;
11482            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11483                match key.as_str() {
11484                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
11485                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
11486                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
11487                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
11488                    _ => {
11489                        unknown_key__ = Some(key);
11490                        let _: IgnoredAny = map.next_value()?;
11491                    }
11492                }
11493            }
11494            let gamemod = MutedCatch {
11495                inverse_muting: inverse_muting.unwrap_or_default(),
11496                enable_metronome: enable_metronome.unwrap_or_default(),
11497                mute_combo_count: mute_combo_count.unwrap_or_default(),
11498                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
11499            };
11500            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11501        }
11502    }
11503    impl Serialize for MutedCatch {
11504        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11505            let field_count = self.inverse_muting.is_some() as usize
11506                + self.enable_metronome.is_some() as usize
11507                + self.mute_combo_count.is_some() as usize
11508                + self.affects_hit_sounds.is_some() as usize;
11509            let mut map = s.serialize_map(Some(field_count))?;
11510            if let Some(ref x) = self.inverse_muting {
11511                map.serialize_entry("inverse_muting", x)?;
11512            }
11513            if let Some(ref x) = self.enable_metronome {
11514                map.serialize_entry("enable_metronome", x)?;
11515            }
11516            if let Some(ref x) = self.mute_combo_count {
11517                map.serialize_entry("mute_combo_count", x)?;
11518            }
11519            if let Some(ref x) = self.affects_hit_sounds {
11520                map.serialize_entry("affects_hit_sounds", x)?;
11521            }
11522            map.end()
11523        }
11524    }
11525    impl<'de> Visitor<'de> for GameModVisitor<NoScopeCatch> {
11526        type Value = DeserializedGameMod<'de, NoScopeCatch>;
11527        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11528            f.write_str("NoScopeCatch")
11529        }
11530        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11531            const FIELDS: &'static [&'static str] = &["hidden_combo_count"];
11532            let mut unknown_key__ = None;
11533            let mut hidden_combo_count = None;
11534            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11535                match key.as_str() {
11536                    "hidden_combo_count" => hidden_combo_count = Some(map.next_value()?),
11537                    _ => {
11538                        unknown_key__ = Some(key);
11539                        let _: IgnoredAny = map.next_value()?;
11540                    }
11541                }
11542            }
11543            let gamemod = NoScopeCatch {
11544                hidden_combo_count: hidden_combo_count.unwrap_or_default(),
11545            };
11546            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11547        }
11548    }
11549    impl Serialize for NoScopeCatch {
11550        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11551            let field_count = self.hidden_combo_count.is_some() as usize;
11552            let mut map = s.serialize_map(Some(field_count))?;
11553            if let Some(ref x) = self.hidden_combo_count {
11554                map.serialize_entry("hidden_combo_count", x)?;
11555            }
11556            map.end()
11557        }
11558    }
11559    impl<'de> Visitor<'de> for GameModVisitor<MovingFastCatch> {
11560        type Value = DeserializedGameMod<'de, MovingFastCatch>;
11561        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11562            f.write_str("MovingFastCatch")
11563        }
11564        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11565            const FIELDS: &'static [&'static str] = &[];
11566            let mut unknown_key__ = None;
11567            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11568                match key.as_str() {
11569                    _ => {
11570                        unknown_key__ = Some(key);
11571                        let _: IgnoredAny = map.next_value()?;
11572                    }
11573                }
11574            }
11575            let gamemod = MovingFastCatch {};
11576            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11577        }
11578    }
11579    impl Serialize for MovingFastCatch {
11580        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11581            let field_count = 0;
11582            let map = s.serialize_map(Some(field_count))?;
11583            map.end()
11584        }
11585    }
11586    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Catch> {
11587        type Value = DeserializedGameMod<'de, ScoreV2Catch>;
11588        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11589            f.write_str("ScoreV2Catch")
11590        }
11591        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11592            const FIELDS: &'static [&'static str] = &[];
11593            let mut unknown_key__ = None;
11594            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11595                match key.as_str() {
11596                    _ => {
11597                        unknown_key__ = Some(key);
11598                        let _: IgnoredAny = map.next_value()?;
11599                    }
11600                }
11601            }
11602            let gamemod = ScoreV2Catch {};
11603            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11604        }
11605    }
11606    impl Serialize for ScoreV2Catch {
11607        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11608            let field_count = 0;
11609            let map = s.serialize_map(Some(field_count))?;
11610            map.end()
11611        }
11612    }
11613    impl<'de> Visitor<'de> for GameModVisitor<EasyMania> {
11614        type Value = DeserializedGameMod<'de, EasyMania>;
11615        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11616            f.write_str("EasyMania")
11617        }
11618        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11619            const FIELDS: &'static [&'static str] = &["retries"];
11620            let mut unknown_key__ = None;
11621            let mut retries = None;
11622            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11623                match key.as_str() {
11624                    "retries" => retries = Some(map.next_value()?),
11625                    _ => {
11626                        unknown_key__ = Some(key);
11627                        let _: IgnoredAny = map.next_value()?;
11628                    }
11629                }
11630            }
11631            let gamemod = EasyMania {
11632                retries: retries.unwrap_or_default(),
11633            };
11634            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11635        }
11636    }
11637    impl Serialize for EasyMania {
11638        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11639            let field_count = self.retries.is_some() as usize;
11640            let mut map = s.serialize_map(Some(field_count))?;
11641            if let Some(ref x) = self.retries {
11642                map.serialize_entry("retries", x)?;
11643            }
11644            map.end()
11645        }
11646    }
11647    impl<'de> Visitor<'de> for GameModVisitor<NoFailMania> {
11648        type Value = DeserializedGameMod<'de, NoFailMania>;
11649        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11650            f.write_str("NoFailMania")
11651        }
11652        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11653            const FIELDS: &'static [&'static str] = &[];
11654            let mut unknown_key__ = None;
11655            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11656                match key.as_str() {
11657                    _ => {
11658                        unknown_key__ = Some(key);
11659                        let _: IgnoredAny = map.next_value()?;
11660                    }
11661                }
11662            }
11663            let gamemod = NoFailMania {};
11664            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11665        }
11666    }
11667    impl Serialize for NoFailMania {
11668        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11669            let field_count = 0;
11670            let map = s.serialize_map(Some(field_count))?;
11671            map.end()
11672        }
11673    }
11674    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeMania> {
11675        type Value = DeserializedGameMod<'de, HalfTimeMania>;
11676        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11677            f.write_str("HalfTimeMania")
11678        }
11679        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11680            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
11681            let mut unknown_key__ = None;
11682            let mut speed_change = None;
11683            let mut adjust_pitch = None;
11684            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11685                match key.as_str() {
11686                    "speed_change" => speed_change = Some(map.next_value()?),
11687                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11688                    _ => {
11689                        unknown_key__ = Some(key);
11690                        let _: IgnoredAny = map.next_value()?;
11691                    }
11692                }
11693            }
11694            let gamemod = HalfTimeMania {
11695                speed_change: speed_change.unwrap_or_default(),
11696                adjust_pitch: adjust_pitch.unwrap_or_default(),
11697            };
11698            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11699        }
11700    }
11701    impl Serialize for HalfTimeMania {
11702        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11703            let field_count =
11704                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
11705            let mut map = s.serialize_map(Some(field_count))?;
11706            if let Some(ref x) = self.speed_change {
11707                map.serialize_entry("speed_change", x)?;
11708            }
11709            if let Some(ref x) = self.adjust_pitch {
11710                map.serialize_entry("adjust_pitch", x)?;
11711            }
11712            map.end()
11713        }
11714    }
11715    impl<'de> Visitor<'de> for GameModVisitor<DaycoreMania> {
11716        type Value = DeserializedGameMod<'de, DaycoreMania>;
11717        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11718            f.write_str("DaycoreMania")
11719        }
11720        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11721            const FIELDS: &'static [&'static str] = &["speed_change"];
11722            let mut unknown_key__ = None;
11723            let mut speed_change = None;
11724            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11725                match key.as_str() {
11726                    "speed_change" => speed_change = Some(map.next_value()?),
11727                    _ => {
11728                        unknown_key__ = Some(key);
11729                        let _: IgnoredAny = map.next_value()?;
11730                    }
11731                }
11732            }
11733            let gamemod = DaycoreMania {
11734                speed_change: speed_change.unwrap_or_default(),
11735            };
11736            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11737        }
11738    }
11739    impl Serialize for DaycoreMania {
11740        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11741            let field_count = self.speed_change.is_some() as usize;
11742            let mut map = s.serialize_map(Some(field_count))?;
11743            if let Some(ref x) = self.speed_change {
11744                map.serialize_entry("speed_change", x)?;
11745            }
11746            map.end()
11747        }
11748    }
11749    impl<'de> Visitor<'de> for GameModVisitor<NoReleaseMania> {
11750        type Value = DeserializedGameMod<'de, NoReleaseMania>;
11751        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11752            f.write_str("NoReleaseMania")
11753        }
11754        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11755            const FIELDS: &'static [&'static str] = &[];
11756            let mut unknown_key__ = None;
11757            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11758                match key.as_str() {
11759                    _ => {
11760                        unknown_key__ = Some(key);
11761                        let _: IgnoredAny = map.next_value()?;
11762                    }
11763                }
11764            }
11765            let gamemod = NoReleaseMania {};
11766            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11767        }
11768    }
11769    impl Serialize for NoReleaseMania {
11770        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11771            let field_count = 0;
11772            let map = s.serialize_map(Some(field_count))?;
11773            map.end()
11774        }
11775    }
11776    impl<'de> Visitor<'de> for GameModVisitor<HardRockMania> {
11777        type Value = DeserializedGameMod<'de, HardRockMania>;
11778        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11779            f.write_str("HardRockMania")
11780        }
11781        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11782            const FIELDS: &'static [&'static str] = &[];
11783            let mut unknown_key__ = None;
11784            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11785                match key.as_str() {
11786                    _ => {
11787                        unknown_key__ = Some(key);
11788                        let _: IgnoredAny = map.next_value()?;
11789                    }
11790                }
11791            }
11792            let gamemod = HardRockMania {};
11793            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11794        }
11795    }
11796    impl Serialize for HardRockMania {
11797        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11798            let field_count = 0;
11799            let map = s.serialize_map(Some(field_count))?;
11800            map.end()
11801        }
11802    }
11803    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathMania> {
11804        type Value = DeserializedGameMod<'de, SuddenDeathMania>;
11805        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11806            f.write_str("SuddenDeathMania")
11807        }
11808        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11809            const FIELDS: &'static [&'static str] = &["restart"];
11810            let mut unknown_key__ = None;
11811            let mut restart = None;
11812            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11813                match key.as_str() {
11814                    "restart" => restart = Some(map.next_value()?),
11815                    _ => {
11816                        unknown_key__ = Some(key);
11817                        let _: IgnoredAny = map.next_value()?;
11818                    }
11819                }
11820            }
11821            let gamemod = SuddenDeathMania {
11822                restart: restart.unwrap_or_default(),
11823            };
11824            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11825        }
11826    }
11827    impl Serialize for SuddenDeathMania {
11828        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11829            let field_count = self.restart.is_some() as usize;
11830            let mut map = s.serialize_map(Some(field_count))?;
11831            if let Some(ref x) = self.restart {
11832                map.serialize_entry("restart", x)?;
11833            }
11834            map.end()
11835        }
11836    }
11837    impl<'de> Visitor<'de> for GameModVisitor<PerfectMania> {
11838        type Value = DeserializedGameMod<'de, PerfectMania>;
11839        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11840            f.write_str("PerfectMania")
11841        }
11842        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11843            const FIELDS: &'static [&'static str] = &["require_perfect_hits", "restart"];
11844            let mut unknown_key__ = None;
11845            let mut require_perfect_hits = None;
11846            let mut restart = None;
11847            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11848                match key.as_str() {
11849                    "require_perfect_hits" => require_perfect_hits = Some(map.next_value()?),
11850                    "restart" => restart = Some(map.next_value()?),
11851                    _ => {
11852                        unknown_key__ = Some(key);
11853                        let _: IgnoredAny = map.next_value()?;
11854                    }
11855                }
11856            }
11857            let gamemod = PerfectMania {
11858                require_perfect_hits: require_perfect_hits.unwrap_or_default(),
11859                restart: restart.unwrap_or_default(),
11860            };
11861            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11862        }
11863    }
11864    impl Serialize for PerfectMania {
11865        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11866            let field_count =
11867                self.require_perfect_hits.is_some() as usize + self.restart.is_some() as usize;
11868            let mut map = s.serialize_map(Some(field_count))?;
11869            if let Some(ref x) = self.require_perfect_hits {
11870                map.serialize_entry("require_perfect_hits", x)?;
11871            }
11872            if let Some(ref x) = self.restart {
11873                map.serialize_entry("restart", x)?;
11874            }
11875            map.end()
11876        }
11877    }
11878    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeMania> {
11879        type Value = DeserializedGameMod<'de, DoubleTimeMania>;
11880        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11881            f.write_str("DoubleTimeMania")
11882        }
11883        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11884            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
11885            let mut unknown_key__ = None;
11886            let mut speed_change = None;
11887            let mut adjust_pitch = None;
11888            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11889                match key.as_str() {
11890                    "speed_change" => speed_change = Some(map.next_value()?),
11891                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11892                    _ => {
11893                        unknown_key__ = Some(key);
11894                        let _: IgnoredAny = map.next_value()?;
11895                    }
11896                }
11897            }
11898            let gamemod = DoubleTimeMania {
11899                speed_change: speed_change.unwrap_or_default(),
11900                adjust_pitch: adjust_pitch.unwrap_or_default(),
11901            };
11902            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11903        }
11904    }
11905    impl Serialize for DoubleTimeMania {
11906        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11907            let field_count =
11908                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
11909            let mut map = s.serialize_map(Some(field_count))?;
11910            if let Some(ref x) = self.speed_change {
11911                map.serialize_entry("speed_change", x)?;
11912            }
11913            if let Some(ref x) = self.adjust_pitch {
11914                map.serialize_entry("adjust_pitch", x)?;
11915            }
11916            map.end()
11917        }
11918    }
11919    impl<'de> Visitor<'de> for GameModVisitor<NightcoreMania> {
11920        type Value = DeserializedGameMod<'de, NightcoreMania>;
11921        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11922            f.write_str("NightcoreMania")
11923        }
11924        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11925            const FIELDS: &'static [&'static str] = &["speed_change"];
11926            let mut unknown_key__ = None;
11927            let mut speed_change = None;
11928            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11929                match key.as_str() {
11930                    "speed_change" => speed_change = Some(map.next_value()?),
11931                    _ => {
11932                        unknown_key__ = Some(key);
11933                        let _: IgnoredAny = map.next_value()?;
11934                    }
11935                }
11936            }
11937            let gamemod = NightcoreMania {
11938                speed_change: speed_change.unwrap_or_default(),
11939            };
11940            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11941        }
11942    }
11943    impl Serialize for NightcoreMania {
11944        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11945            let field_count = self.speed_change.is_some() as usize;
11946            let mut map = s.serialize_map(Some(field_count))?;
11947            if let Some(ref x) = self.speed_change {
11948                map.serialize_entry("speed_change", x)?;
11949            }
11950            map.end()
11951        }
11952    }
11953    impl<'de> Visitor<'de> for GameModVisitor<FadeInMania> {
11954        type Value = DeserializedGameMod<'de, FadeInMania>;
11955        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11956            f.write_str("FadeInMania")
11957        }
11958        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11959            const FIELDS: &'static [&'static str] = &[];
11960            let mut unknown_key__ = None;
11961            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11962                match key.as_str() {
11963                    _ => {
11964                        unknown_key__ = Some(key);
11965                        let _: IgnoredAny = map.next_value()?;
11966                    }
11967                }
11968            }
11969            let gamemod = FadeInMania {};
11970            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11971        }
11972    }
11973    impl Serialize for FadeInMania {
11974        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11975            let field_count = 0;
11976            let map = s.serialize_map(Some(field_count))?;
11977            map.end()
11978        }
11979    }
11980    impl<'de> Visitor<'de> for GameModVisitor<HiddenMania> {
11981        type Value = DeserializedGameMod<'de, HiddenMania>;
11982        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11983            f.write_str("HiddenMania")
11984        }
11985        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11986            const FIELDS: &'static [&'static str] = &[];
11987            let mut unknown_key__ = None;
11988            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11989                match key.as_str() {
11990                    _ => {
11991                        unknown_key__ = Some(key);
11992                        let _: IgnoredAny = map.next_value()?;
11993                    }
11994                }
11995            }
11996            let gamemod = HiddenMania {};
11997            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11998        }
11999    }
12000    impl Serialize for HiddenMania {
12001        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12002            let field_count = 0;
12003            let map = s.serialize_map(Some(field_count))?;
12004            map.end()
12005        }
12006    }
12007    impl<'de> Visitor<'de> for GameModVisitor<CoverMania> {
12008        type Value = DeserializedGameMod<'de, CoverMania>;
12009        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12010            f.write_str("CoverMania")
12011        }
12012        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12013            const FIELDS: &'static [&'static str] = &["coverage", "direction"];
12014            let mut unknown_key__ = None;
12015            let mut coverage = None;
12016            let mut direction = None;
12017            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12018                match key.as_str() {
12019                    "coverage" => coverage = Some(map.next_value()?),
12020                    "direction" => direction = Some(map.next_value()?),
12021                    _ => {
12022                        unknown_key__ = Some(key);
12023                        let _: IgnoredAny = map.next_value()?;
12024                    }
12025                }
12026            }
12027            let gamemod = CoverMania {
12028                coverage: coverage.unwrap_or_default(),
12029                direction: direction.unwrap_or_default(),
12030            };
12031            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12032        }
12033    }
12034    impl Serialize for CoverMania {
12035        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12036            let field_count = self.coverage.is_some() as usize + self.direction.is_some() as usize;
12037            let mut map = s.serialize_map(Some(field_count))?;
12038            if let Some(ref x) = self.coverage {
12039                map.serialize_entry("coverage", x)?;
12040            }
12041            if let Some(ref x) = self.direction {
12042                map.serialize_entry("direction", x)?;
12043            }
12044            map.end()
12045        }
12046    }
12047    impl<'de> Visitor<'de> for GameModVisitor<FlashlightMania> {
12048        type Value = DeserializedGameMod<'de, FlashlightMania>;
12049        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12050            f.write_str("FlashlightMania")
12051        }
12052        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12053            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
12054            let mut unknown_key__ = None;
12055            let mut size_multiplier = None;
12056            let mut combo_based_size = None;
12057            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12058                match key.as_str() {
12059                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
12060                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
12061                    _ => {
12062                        unknown_key__ = Some(key);
12063                        let _: IgnoredAny = map.next_value()?;
12064                    }
12065                }
12066            }
12067            let gamemod = FlashlightMania {
12068                size_multiplier: size_multiplier.unwrap_or_default(),
12069                combo_based_size: combo_based_size.unwrap_or_default(),
12070            };
12071            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12072        }
12073    }
12074    impl Serialize for FlashlightMania {
12075        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12076            let field_count =
12077                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
12078            let mut map = s.serialize_map(Some(field_count))?;
12079            if let Some(ref x) = self.size_multiplier {
12080                map.serialize_entry("size_multiplier", x)?;
12081            }
12082            if let Some(ref x) = self.combo_based_size {
12083                map.serialize_entry("combo_based_size", x)?;
12084            }
12085            map.end()
12086        }
12087    }
12088    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeMania> {
12089        type Value = DeserializedGameMod<'de, AccuracyChallengeMania>;
12090        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12091            f.write_str("AccuracyChallengeMania")
12092        }
12093        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12094            const FIELDS: &'static [&'static str] =
12095                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
12096            let mut unknown_key__ = None;
12097            let mut minimum_accuracy = None;
12098            let mut accuracy_judge_mode = None;
12099            let mut restart = None;
12100            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12101                match key.as_str() {
12102                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
12103                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
12104                    "restart" => restart = Some(map.next_value()?),
12105                    _ => {
12106                        unknown_key__ = Some(key);
12107                        let _: IgnoredAny = map.next_value()?;
12108                    }
12109                }
12110            }
12111            let gamemod = AccuracyChallengeMania {
12112                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
12113                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
12114                restart: restart.unwrap_or_default(),
12115            };
12116            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12117        }
12118    }
12119    impl Serialize for AccuracyChallengeMania {
12120        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12121            let field_count = self.minimum_accuracy.is_some() as usize
12122                + self.accuracy_judge_mode.is_some() as usize
12123                + self.restart.is_some() as usize;
12124            let mut map = s.serialize_map(Some(field_count))?;
12125            if let Some(ref x) = self.minimum_accuracy {
12126                map.serialize_entry("minimum_accuracy", x)?;
12127            }
12128            if let Some(ref x) = self.accuracy_judge_mode {
12129                map.serialize_entry("accuracy_judge_mode", x)?;
12130            }
12131            if let Some(ref x) = self.restart {
12132                map.serialize_entry("restart", x)?;
12133            }
12134            map.end()
12135        }
12136    }
12137    impl<'de> Visitor<'de> for GameModVisitor<RandomMania> {
12138        type Value = DeserializedGameMod<'de, RandomMania>;
12139        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12140            f.write_str("RandomMania")
12141        }
12142        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12143            const FIELDS: &'static [&'static str] = &["seed"];
12144            let mut unknown_key__ = None;
12145            let mut seed = None;
12146            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12147                match key.as_str() {
12148                    "seed" => seed = Some(map.next_value()?),
12149                    _ => {
12150                        unknown_key__ = Some(key);
12151                        let _: IgnoredAny = map.next_value()?;
12152                    }
12153                }
12154            }
12155            let gamemod = RandomMania {
12156                seed: seed.unwrap_or_default(),
12157            };
12158            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12159        }
12160    }
12161    impl Serialize for RandomMania {
12162        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12163            let field_count = self.seed.is_some() as usize;
12164            let mut map = s.serialize_map(Some(field_count))?;
12165            if let Some(ref x) = self.seed {
12166                map.serialize_entry("seed", x)?;
12167            }
12168            map.end()
12169        }
12170    }
12171    impl<'de> Visitor<'de> for GameModVisitor<DualStagesMania> {
12172        type Value = DeserializedGameMod<'de, DualStagesMania>;
12173        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12174            f.write_str("DualStagesMania")
12175        }
12176        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12177            const FIELDS: &'static [&'static str] = &[];
12178            let mut unknown_key__ = None;
12179            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12180                match key.as_str() {
12181                    _ => {
12182                        unknown_key__ = Some(key);
12183                        let _: IgnoredAny = map.next_value()?;
12184                    }
12185                }
12186            }
12187            let gamemod = DualStagesMania {};
12188            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12189        }
12190    }
12191    impl Serialize for DualStagesMania {
12192        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12193            let field_count = 0;
12194            let map = s.serialize_map(Some(field_count))?;
12195            map.end()
12196        }
12197    }
12198    impl<'de> Visitor<'de> for GameModVisitor<MirrorMania> {
12199        type Value = DeserializedGameMod<'de, MirrorMania>;
12200        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12201            f.write_str("MirrorMania")
12202        }
12203        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12204            const FIELDS: &'static [&'static str] = &[];
12205            let mut unknown_key__ = None;
12206            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12207                match key.as_str() {
12208                    _ => {
12209                        unknown_key__ = Some(key);
12210                        let _: IgnoredAny = map.next_value()?;
12211                    }
12212                }
12213            }
12214            let gamemod = MirrorMania {};
12215            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12216        }
12217    }
12218    impl Serialize for MirrorMania {
12219        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12220            let field_count = 0;
12221            let map = s.serialize_map(Some(field_count))?;
12222            map.end()
12223        }
12224    }
12225    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustMania> {
12226        type Value = DeserializedGameMod<'de, DifficultyAdjustMania>;
12227        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12228            f.write_str("DifficultyAdjustMania")
12229        }
12230        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12231            const FIELDS: &'static [&'static str] =
12232                &["overall_difficulty", "drain_rate", "extended_limits"];
12233            let mut unknown_key__ = None;
12234            let mut overall_difficulty = None;
12235            let mut drain_rate = None;
12236            let mut extended_limits = None;
12237            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12238                match key.as_str() {
12239                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
12240                    "drain_rate" => drain_rate = Some(map.next_value()?),
12241                    "extended_limits" => extended_limits = Some(map.next_value()?),
12242                    _ => {
12243                        unknown_key__ = Some(key);
12244                        let _: IgnoredAny = map.next_value()?;
12245                    }
12246                }
12247            }
12248            let gamemod = DifficultyAdjustMania {
12249                overall_difficulty: overall_difficulty.unwrap_or_default(),
12250                drain_rate: drain_rate.unwrap_or_default(),
12251                extended_limits: extended_limits.unwrap_or_default(),
12252            };
12253            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12254        }
12255    }
12256    impl Serialize for DifficultyAdjustMania {
12257        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12258            let field_count = self.overall_difficulty.is_some() as usize
12259                + self.drain_rate.is_some() as usize
12260                + self.extended_limits.is_some() as usize;
12261            let mut map = s.serialize_map(Some(field_count))?;
12262            if let Some(ref x) = self.overall_difficulty {
12263                map.serialize_entry("overall_difficulty", x)?;
12264            }
12265            if let Some(ref x) = self.drain_rate {
12266                map.serialize_entry("drain_rate", x)?;
12267            }
12268            if let Some(ref x) = self.extended_limits {
12269                map.serialize_entry("extended_limits", x)?;
12270            }
12271            map.end()
12272        }
12273    }
12274    impl<'de> Visitor<'de> for GameModVisitor<ClassicMania> {
12275        type Value = DeserializedGameMod<'de, ClassicMania>;
12276        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12277            f.write_str("ClassicMania")
12278        }
12279        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12280            const FIELDS: &'static [&'static str] = &[];
12281            let mut unknown_key__ = None;
12282            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12283                match key.as_str() {
12284                    _ => {
12285                        unknown_key__ = Some(key);
12286                        let _: IgnoredAny = map.next_value()?;
12287                    }
12288                }
12289            }
12290            let gamemod = ClassicMania {};
12291            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12292        }
12293    }
12294    impl Serialize for ClassicMania {
12295        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12296            let field_count = 0;
12297            let map = s.serialize_map(Some(field_count))?;
12298            map.end()
12299        }
12300    }
12301    impl<'de> Visitor<'de> for GameModVisitor<InvertMania> {
12302        type Value = DeserializedGameMod<'de, InvertMania>;
12303        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12304            f.write_str("InvertMania")
12305        }
12306        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12307            const FIELDS: &'static [&'static str] = &[];
12308            let mut unknown_key__ = None;
12309            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12310                match key.as_str() {
12311                    _ => {
12312                        unknown_key__ = Some(key);
12313                        let _: IgnoredAny = map.next_value()?;
12314                    }
12315                }
12316            }
12317            let gamemod = InvertMania {};
12318            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12319        }
12320    }
12321    impl Serialize for InvertMania {
12322        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12323            let field_count = 0;
12324            let map = s.serialize_map(Some(field_count))?;
12325            map.end()
12326        }
12327    }
12328    impl<'de> Visitor<'de> for GameModVisitor<ConstantSpeedMania> {
12329        type Value = DeserializedGameMod<'de, ConstantSpeedMania>;
12330        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12331            f.write_str("ConstantSpeedMania")
12332        }
12333        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12334            const FIELDS: &'static [&'static str] = &[];
12335            let mut unknown_key__ = None;
12336            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12337                match key.as_str() {
12338                    _ => {
12339                        unknown_key__ = Some(key);
12340                        let _: IgnoredAny = map.next_value()?;
12341                    }
12342                }
12343            }
12344            let gamemod = ConstantSpeedMania {};
12345            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12346        }
12347    }
12348    impl Serialize for ConstantSpeedMania {
12349        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12350            let field_count = 0;
12351            let map = s.serialize_map(Some(field_count))?;
12352            map.end()
12353        }
12354    }
12355    impl<'de> Visitor<'de> for GameModVisitor<HoldOffMania> {
12356        type Value = DeserializedGameMod<'de, HoldOffMania>;
12357        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12358            f.write_str("HoldOffMania")
12359        }
12360        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12361            const FIELDS: &'static [&'static str] = &[];
12362            let mut unknown_key__ = None;
12363            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12364                match key.as_str() {
12365                    _ => {
12366                        unknown_key__ = Some(key);
12367                        let _: IgnoredAny = map.next_value()?;
12368                    }
12369                }
12370            }
12371            let gamemod = HoldOffMania {};
12372            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12373        }
12374    }
12375    impl Serialize for HoldOffMania {
12376        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12377            let field_count = 0;
12378            let map = s.serialize_map(Some(field_count))?;
12379            map.end()
12380        }
12381    }
12382    impl<'de> Visitor<'de> for GameModVisitor<OneKeyMania> {
12383        type Value = DeserializedGameMod<'de, OneKeyMania>;
12384        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12385            f.write_str("OneKeyMania")
12386        }
12387        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12388            const FIELDS: &'static [&'static str] = &[];
12389            let mut unknown_key__ = None;
12390            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12391                match key.as_str() {
12392                    _ => {
12393                        unknown_key__ = Some(key);
12394                        let _: IgnoredAny = map.next_value()?;
12395                    }
12396                }
12397            }
12398            let gamemod = OneKeyMania {};
12399            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12400        }
12401    }
12402    impl Serialize for OneKeyMania {
12403        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12404            let field_count = 0;
12405            let map = s.serialize_map(Some(field_count))?;
12406            map.end()
12407        }
12408    }
12409    impl<'de> Visitor<'de> for GameModVisitor<TwoKeysMania> {
12410        type Value = DeserializedGameMod<'de, TwoKeysMania>;
12411        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12412            f.write_str("TwoKeysMania")
12413        }
12414        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12415            const FIELDS: &'static [&'static str] = &[];
12416            let mut unknown_key__ = None;
12417            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12418                match key.as_str() {
12419                    _ => {
12420                        unknown_key__ = Some(key);
12421                        let _: IgnoredAny = map.next_value()?;
12422                    }
12423                }
12424            }
12425            let gamemod = TwoKeysMania {};
12426            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12427        }
12428    }
12429    impl Serialize for TwoKeysMania {
12430        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12431            let field_count = 0;
12432            let map = s.serialize_map(Some(field_count))?;
12433            map.end()
12434        }
12435    }
12436    impl<'de> Visitor<'de> for GameModVisitor<ThreeKeysMania> {
12437        type Value = DeserializedGameMod<'de, ThreeKeysMania>;
12438        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12439            f.write_str("ThreeKeysMania")
12440        }
12441        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12442            const FIELDS: &'static [&'static str] = &[];
12443            let mut unknown_key__ = None;
12444            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12445                match key.as_str() {
12446                    _ => {
12447                        unknown_key__ = Some(key);
12448                        let _: IgnoredAny = map.next_value()?;
12449                    }
12450                }
12451            }
12452            let gamemod = ThreeKeysMania {};
12453            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12454        }
12455    }
12456    impl Serialize for ThreeKeysMania {
12457        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12458            let field_count = 0;
12459            let map = s.serialize_map(Some(field_count))?;
12460            map.end()
12461        }
12462    }
12463    impl<'de> Visitor<'de> for GameModVisitor<FourKeysMania> {
12464        type Value = DeserializedGameMod<'de, FourKeysMania>;
12465        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12466            f.write_str("FourKeysMania")
12467        }
12468        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12469            const FIELDS: &'static [&'static str] = &[];
12470            let mut unknown_key__ = None;
12471            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12472                match key.as_str() {
12473                    _ => {
12474                        unknown_key__ = Some(key);
12475                        let _: IgnoredAny = map.next_value()?;
12476                    }
12477                }
12478            }
12479            let gamemod = FourKeysMania {};
12480            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12481        }
12482    }
12483    impl Serialize for FourKeysMania {
12484        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12485            let field_count = 0;
12486            let map = s.serialize_map(Some(field_count))?;
12487            map.end()
12488        }
12489    }
12490    impl<'de> Visitor<'de> for GameModVisitor<FiveKeysMania> {
12491        type Value = DeserializedGameMod<'de, FiveKeysMania>;
12492        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12493            f.write_str("FiveKeysMania")
12494        }
12495        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12496            const FIELDS: &'static [&'static str] = &[];
12497            let mut unknown_key__ = None;
12498            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12499                match key.as_str() {
12500                    _ => {
12501                        unknown_key__ = Some(key);
12502                        let _: IgnoredAny = map.next_value()?;
12503                    }
12504                }
12505            }
12506            let gamemod = FiveKeysMania {};
12507            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12508        }
12509    }
12510    impl Serialize for FiveKeysMania {
12511        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12512            let field_count = 0;
12513            let map = s.serialize_map(Some(field_count))?;
12514            map.end()
12515        }
12516    }
12517    impl<'de> Visitor<'de> for GameModVisitor<SixKeysMania> {
12518        type Value = DeserializedGameMod<'de, SixKeysMania>;
12519        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12520            f.write_str("SixKeysMania")
12521        }
12522        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12523            const FIELDS: &'static [&'static str] = &[];
12524            let mut unknown_key__ = None;
12525            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12526                match key.as_str() {
12527                    _ => {
12528                        unknown_key__ = Some(key);
12529                        let _: IgnoredAny = map.next_value()?;
12530                    }
12531                }
12532            }
12533            let gamemod = SixKeysMania {};
12534            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12535        }
12536    }
12537    impl Serialize for SixKeysMania {
12538        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12539            let field_count = 0;
12540            let map = s.serialize_map(Some(field_count))?;
12541            map.end()
12542        }
12543    }
12544    impl<'de> Visitor<'de> for GameModVisitor<SevenKeysMania> {
12545        type Value = DeserializedGameMod<'de, SevenKeysMania>;
12546        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12547            f.write_str("SevenKeysMania")
12548        }
12549        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12550            const FIELDS: &'static [&'static str] = &[];
12551            let mut unknown_key__ = None;
12552            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12553                match key.as_str() {
12554                    _ => {
12555                        unknown_key__ = Some(key);
12556                        let _: IgnoredAny = map.next_value()?;
12557                    }
12558                }
12559            }
12560            let gamemod = SevenKeysMania {};
12561            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12562        }
12563    }
12564    impl Serialize for SevenKeysMania {
12565        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12566            let field_count = 0;
12567            let map = s.serialize_map(Some(field_count))?;
12568            map.end()
12569        }
12570    }
12571    impl<'de> Visitor<'de> for GameModVisitor<EightKeysMania> {
12572        type Value = DeserializedGameMod<'de, EightKeysMania>;
12573        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12574            f.write_str("EightKeysMania")
12575        }
12576        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12577            const FIELDS: &'static [&'static str] = &[];
12578            let mut unknown_key__ = None;
12579            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12580                match key.as_str() {
12581                    _ => {
12582                        unknown_key__ = Some(key);
12583                        let _: IgnoredAny = map.next_value()?;
12584                    }
12585                }
12586            }
12587            let gamemod = EightKeysMania {};
12588            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12589        }
12590    }
12591    impl Serialize for EightKeysMania {
12592        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12593            let field_count = 0;
12594            let map = s.serialize_map(Some(field_count))?;
12595            map.end()
12596        }
12597    }
12598    impl<'de> Visitor<'de> for GameModVisitor<NineKeysMania> {
12599        type Value = DeserializedGameMod<'de, NineKeysMania>;
12600        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12601            f.write_str("NineKeysMania")
12602        }
12603        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12604            const FIELDS: &'static [&'static str] = &[];
12605            let mut unknown_key__ = None;
12606            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12607                match key.as_str() {
12608                    _ => {
12609                        unknown_key__ = Some(key);
12610                        let _: IgnoredAny = map.next_value()?;
12611                    }
12612                }
12613            }
12614            let gamemod = NineKeysMania {};
12615            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12616        }
12617    }
12618    impl Serialize for NineKeysMania {
12619        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12620            let field_count = 0;
12621            let map = s.serialize_map(Some(field_count))?;
12622            map.end()
12623        }
12624    }
12625    impl<'de> Visitor<'de> for GameModVisitor<TenKeysMania> {
12626        type Value = DeserializedGameMod<'de, TenKeysMania>;
12627        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12628            f.write_str("TenKeysMania")
12629        }
12630        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12631            const FIELDS: &'static [&'static str] = &[];
12632            let mut unknown_key__ = None;
12633            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12634                match key.as_str() {
12635                    _ => {
12636                        unknown_key__ = Some(key);
12637                        let _: IgnoredAny = map.next_value()?;
12638                    }
12639                }
12640            }
12641            let gamemod = TenKeysMania {};
12642            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12643        }
12644    }
12645    impl Serialize for TenKeysMania {
12646        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12647            let field_count = 0;
12648            let map = s.serialize_map(Some(field_count))?;
12649            map.end()
12650        }
12651    }
12652    impl<'de> Visitor<'de> for GameModVisitor<AutoplayMania> {
12653        type Value = DeserializedGameMod<'de, AutoplayMania>;
12654        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12655            f.write_str("AutoplayMania")
12656        }
12657        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12658            const FIELDS: &'static [&'static str] = &[];
12659            let mut unknown_key__ = None;
12660            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12661                match key.as_str() {
12662                    _ => {
12663                        unknown_key__ = Some(key);
12664                        let _: IgnoredAny = map.next_value()?;
12665                    }
12666                }
12667            }
12668            let gamemod = AutoplayMania {};
12669            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12670        }
12671    }
12672    impl Serialize for AutoplayMania {
12673        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12674            let field_count = 0;
12675            let map = s.serialize_map(Some(field_count))?;
12676            map.end()
12677        }
12678    }
12679    impl<'de> Visitor<'de> for GameModVisitor<CinemaMania> {
12680        type Value = DeserializedGameMod<'de, CinemaMania>;
12681        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12682            f.write_str("CinemaMania")
12683        }
12684        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12685            const FIELDS: &'static [&'static str] = &[];
12686            let mut unknown_key__ = None;
12687            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12688                match key.as_str() {
12689                    _ => {
12690                        unknown_key__ = Some(key);
12691                        let _: IgnoredAny = map.next_value()?;
12692                    }
12693                }
12694            }
12695            let gamemod = CinemaMania {};
12696            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12697        }
12698    }
12699    impl Serialize for CinemaMania {
12700        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12701            let field_count = 0;
12702            let map = s.serialize_map(Some(field_count))?;
12703            map.end()
12704        }
12705    }
12706    impl<'de> Visitor<'de> for GameModVisitor<WindUpMania> {
12707        type Value = DeserializedGameMod<'de, WindUpMania>;
12708        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12709            f.write_str("WindUpMania")
12710        }
12711        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12712            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
12713            let mut unknown_key__ = None;
12714            let mut initial_rate = None;
12715            let mut final_rate = None;
12716            let mut adjust_pitch = None;
12717            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12718                match key.as_str() {
12719                    "initial_rate" => initial_rate = Some(map.next_value()?),
12720                    "final_rate" => final_rate = Some(map.next_value()?),
12721                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
12722                    _ => {
12723                        unknown_key__ = Some(key);
12724                        let _: IgnoredAny = map.next_value()?;
12725                    }
12726                }
12727            }
12728            let gamemod = WindUpMania {
12729                initial_rate: initial_rate.unwrap_or_default(),
12730                final_rate: final_rate.unwrap_or_default(),
12731                adjust_pitch: adjust_pitch.unwrap_or_default(),
12732            };
12733            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12734        }
12735    }
12736    impl Serialize for WindUpMania {
12737        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12738            let field_count = self.initial_rate.is_some() as usize
12739                + self.final_rate.is_some() as usize
12740                + self.adjust_pitch.is_some() as usize;
12741            let mut map = s.serialize_map(Some(field_count))?;
12742            if let Some(ref x) = self.initial_rate {
12743                map.serialize_entry("initial_rate", x)?;
12744            }
12745            if let Some(ref x) = self.final_rate {
12746                map.serialize_entry("final_rate", x)?;
12747            }
12748            if let Some(ref x) = self.adjust_pitch {
12749                map.serialize_entry("adjust_pitch", x)?;
12750            }
12751            map.end()
12752        }
12753    }
12754    impl<'de> Visitor<'de> for GameModVisitor<WindDownMania> {
12755        type Value = DeserializedGameMod<'de, WindDownMania>;
12756        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12757            f.write_str("WindDownMania")
12758        }
12759        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12760            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
12761            let mut unknown_key__ = None;
12762            let mut initial_rate = None;
12763            let mut final_rate = None;
12764            let mut adjust_pitch = None;
12765            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12766                match key.as_str() {
12767                    "initial_rate" => initial_rate = Some(map.next_value()?),
12768                    "final_rate" => final_rate = Some(map.next_value()?),
12769                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
12770                    _ => {
12771                        unknown_key__ = Some(key);
12772                        let _: IgnoredAny = map.next_value()?;
12773                    }
12774                }
12775            }
12776            let gamemod = WindDownMania {
12777                initial_rate: initial_rate.unwrap_or_default(),
12778                final_rate: final_rate.unwrap_or_default(),
12779                adjust_pitch: adjust_pitch.unwrap_or_default(),
12780            };
12781            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12782        }
12783    }
12784    impl Serialize for WindDownMania {
12785        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12786            let field_count = self.initial_rate.is_some() as usize
12787                + self.final_rate.is_some() as usize
12788                + self.adjust_pitch.is_some() as usize;
12789            let mut map = s.serialize_map(Some(field_count))?;
12790            if let Some(ref x) = self.initial_rate {
12791                map.serialize_entry("initial_rate", x)?;
12792            }
12793            if let Some(ref x) = self.final_rate {
12794                map.serialize_entry("final_rate", x)?;
12795            }
12796            if let Some(ref x) = self.adjust_pitch {
12797                map.serialize_entry("adjust_pitch", x)?;
12798            }
12799            map.end()
12800        }
12801    }
12802    impl<'de> Visitor<'de> for GameModVisitor<MutedMania> {
12803        type Value = DeserializedGameMod<'de, MutedMania>;
12804        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12805            f.write_str("MutedMania")
12806        }
12807        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12808            const FIELDS: &'static [&'static str] = &[
12809                "inverse_muting",
12810                "enable_metronome",
12811                "mute_combo_count",
12812                "affects_hit_sounds",
12813            ];
12814            let mut unknown_key__ = None;
12815            let mut inverse_muting = None;
12816            let mut enable_metronome = None;
12817            let mut mute_combo_count = None;
12818            let mut affects_hit_sounds = None;
12819            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12820                match key.as_str() {
12821                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
12822                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
12823                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
12824                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
12825                    _ => {
12826                        unknown_key__ = Some(key);
12827                        let _: IgnoredAny = map.next_value()?;
12828                    }
12829                }
12830            }
12831            let gamemod = MutedMania {
12832                inverse_muting: inverse_muting.unwrap_or_default(),
12833                enable_metronome: enable_metronome.unwrap_or_default(),
12834                mute_combo_count: mute_combo_count.unwrap_or_default(),
12835                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
12836            };
12837            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12838        }
12839    }
12840    impl Serialize for MutedMania {
12841        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12842            let field_count = self.inverse_muting.is_some() as usize
12843                + self.enable_metronome.is_some() as usize
12844                + self.mute_combo_count.is_some() as usize
12845                + self.affects_hit_sounds.is_some() as usize;
12846            let mut map = s.serialize_map(Some(field_count))?;
12847            if let Some(ref x) = self.inverse_muting {
12848                map.serialize_entry("inverse_muting", x)?;
12849            }
12850            if let Some(ref x) = self.enable_metronome {
12851                map.serialize_entry("enable_metronome", x)?;
12852            }
12853            if let Some(ref x) = self.mute_combo_count {
12854                map.serialize_entry("mute_combo_count", x)?;
12855            }
12856            if let Some(ref x) = self.affects_hit_sounds {
12857                map.serialize_entry("affects_hit_sounds", x)?;
12858            }
12859            map.end()
12860        }
12861    }
12862    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedMania> {
12863        type Value = DeserializedGameMod<'de, AdaptiveSpeedMania>;
12864        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12865            f.write_str("AdaptiveSpeedMania")
12866        }
12867        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12868            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
12869            let mut unknown_key__ = None;
12870            let mut initial_rate = None;
12871            let mut adjust_pitch = None;
12872            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12873                match key.as_str() {
12874                    "initial_rate" => initial_rate = Some(map.next_value()?),
12875                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
12876                    _ => {
12877                        unknown_key__ = Some(key);
12878                        let _: IgnoredAny = map.next_value()?;
12879                    }
12880                }
12881            }
12882            let gamemod = AdaptiveSpeedMania {
12883                initial_rate: initial_rate.unwrap_or_default(),
12884                adjust_pitch: adjust_pitch.unwrap_or_default(),
12885            };
12886            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12887        }
12888    }
12889    impl Serialize for AdaptiveSpeedMania {
12890        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12891            let field_count =
12892                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
12893            let mut map = s.serialize_map(Some(field_count))?;
12894            if let Some(ref x) = self.initial_rate {
12895                map.serialize_entry("initial_rate", x)?;
12896            }
12897            if let Some(ref x) = self.adjust_pitch {
12898                map.serialize_entry("adjust_pitch", x)?;
12899            }
12900            map.end()
12901        }
12902    }
12903    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Mania> {
12904        type Value = DeserializedGameMod<'de, ScoreV2Mania>;
12905        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12906            f.write_str("ScoreV2Mania")
12907        }
12908        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12909            const FIELDS: &'static [&'static str] = &[];
12910            let mut unknown_key__ = None;
12911            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12912                match key.as_str() {
12913                    _ => {
12914                        unknown_key__ = Some(key);
12915                        let _: IgnoredAny = map.next_value()?;
12916                    }
12917                }
12918            }
12919            let gamemod = ScoreV2Mania {};
12920            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12921        }
12922    }
12923    impl Serialize for ScoreV2Mania {
12924        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12925            let field_count = 0;
12926            let map = s.serialize_map(Some(field_count))?;
12927            map.end()
12928        }
12929    }
12930    impl<'de> Deserialize<'de> for UnknownMod {
12931        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
12932            struct UnknownModVisitor;
12933            impl<'de> Visitor<'de> for UnknownModVisitor {
12934                type Value = UnknownMod;
12935                fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12936                    f.write_str("any unknown mod")
12937                }
12938                fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12939                    while map.next_entry::<IgnoredAny, IgnoredAny>()?.is_some() {}
12940                    Ok(UnknownMod {
12941                        acronym: UnknownMod::UNKNOWN_ACRONYM,
12942                    })
12943                }
12944            }
12945            d.deserialize_map(UnknownModVisitor)
12946        }
12947    }
12948    impl Serialize for UnknownMod {
12949        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12950            s.serialize_map(Some(0)).and_then(SerializeMap::end)
12951        }
12952    }
12953    impl<'a, 'de> Visitor<'de> for GameModSettingsSeed<'a> {
12954        type Value = GameMod;
12955        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12956            f.write_str("GameMod settings")
12957        }
12958        fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
12959            let d = MapAccessDeserializer::new(map);
12960            let res = match (self.acronym, self.mode) {
12961                ("EZ", GameMode::Osu) => GameMod::EasyOsu(
12962                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12963                ),
12964                ("NF", GameMode::Osu) => GameMod::NoFailOsu(
12965                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12966                ),
12967                ("HT", GameMode::Osu) => GameMod::HalfTimeOsu(
12968                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12969                ),
12970                ("DC", GameMode::Osu) => GameMod::DaycoreOsu(
12971                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12972                ),
12973                ("HR", GameMode::Osu) => GameMod::HardRockOsu(
12974                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12975                ),
12976                ("SD", GameMode::Osu) => GameMod::SuddenDeathOsu(
12977                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12978                ),
12979                ("PF", GameMode::Osu) => GameMod::PerfectOsu(
12980                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12981                ),
12982                ("DT", GameMode::Osu) => GameMod::DoubleTimeOsu(
12983                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12984                ),
12985                ("NC", GameMode::Osu) => GameMod::NightcoreOsu(
12986                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12987                ),
12988                ("HD", GameMode::Osu) => GameMod::HiddenOsu(
12989                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12990                ),
12991                ("TC", GameMode::Osu) => GameMod::TraceableOsu(
12992                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12993                ),
12994                ("FL", GameMode::Osu) => GameMod::FlashlightOsu(
12995                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12996                ),
12997                ("BL", GameMode::Osu) => GameMod::BlindsOsu(
12998                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12999                ),
13000                ("ST", GameMode::Osu) => GameMod::StrictTrackingOsu(
13001                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13002                ),
13003                ("AC", GameMode::Osu) => GameMod::AccuracyChallengeOsu(
13004                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13005                ),
13006                ("TP", GameMode::Osu) => GameMod::TargetPracticeOsu(
13007                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13008                ),
13009                ("DA", GameMode::Osu) => GameMod::DifficultyAdjustOsu(
13010                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13011                ),
13012                ("CL", GameMode::Osu) => GameMod::ClassicOsu(
13013                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13014                ),
13015                ("RD", GameMode::Osu) => GameMod::RandomOsu(
13016                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13017                ),
13018                ("MR", GameMode::Osu) => GameMod::MirrorOsu(
13019                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13020                ),
13021                ("AL", GameMode::Osu) => GameMod::AlternateOsu(
13022                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13023                ),
13024                ("SG", GameMode::Osu) => GameMod::SingleTapOsu(
13025                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13026                ),
13027                ("AT", GameMode::Osu) => GameMod::AutoplayOsu(
13028                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13029                ),
13030                ("CN", GameMode::Osu) => GameMod::CinemaOsu(
13031                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13032                ),
13033                ("RX", GameMode::Osu) => GameMod::RelaxOsu(
13034                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13035                ),
13036                ("AP", GameMode::Osu) => GameMod::AutopilotOsu(
13037                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13038                ),
13039                ("SO", GameMode::Osu) => GameMod::SpunOutOsu(
13040                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13041                ),
13042                ("TR", GameMode::Osu) => GameMod::TransformOsu(
13043                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13044                ),
13045                ("WG", GameMode::Osu) => GameMod::WiggleOsu(
13046                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13047                ),
13048                ("SI", GameMode::Osu) => GameMod::SpinInOsu(
13049                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13050                ),
13051                ("GR", GameMode::Osu) => GameMod::GrowOsu(
13052                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13053                ),
13054                ("DF", GameMode::Osu) => GameMod::DeflateOsu(
13055                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13056                ),
13057                ("WU", GameMode::Osu) => GameMod::WindUpOsu(
13058                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13059                ),
13060                ("WD", GameMode::Osu) => GameMod::WindDownOsu(
13061                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13062                ),
13063                ("BR", GameMode::Osu) => GameMod::BarrelRollOsu(
13064                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13065                ),
13066                ("AD", GameMode::Osu) => GameMod::ApproachDifferentOsu(
13067                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13068                ),
13069                ("MU", GameMode::Osu) => GameMod::MutedOsu(
13070                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13071                ),
13072                ("NS", GameMode::Osu) => GameMod::NoScopeOsu(
13073                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13074                ),
13075                ("MG", GameMode::Osu) => GameMod::MagnetisedOsu(
13076                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13077                ),
13078                ("RP", GameMode::Osu) => GameMod::RepelOsu(
13079                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13080                ),
13081                ("AS", GameMode::Osu) => GameMod::AdaptiveSpeedOsu(
13082                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13083                ),
13084                ("FR", GameMode::Osu) => GameMod::FreezeFrameOsu(
13085                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13086                ),
13087                ("BU", GameMode::Osu) => GameMod::BubblesOsu(
13088                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13089                ),
13090                ("SY", GameMode::Osu) => GameMod::SynesthesiaOsu(
13091                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13092                ),
13093                ("DP", GameMode::Osu) => GameMod::DepthOsu(
13094                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13095                ),
13096                ("BM", GameMode::Osu) => GameMod::BloomOsu(
13097                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13098                ),
13099                ("TD", GameMode::Osu) => GameMod::TouchDeviceOsu(
13100                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13101                ),
13102                ("SV2", GameMode::Osu) => GameMod::ScoreV2Osu(
13103                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13104                ),
13105                ("EZ", GameMode::Taiko) => GameMod::EasyTaiko(
13106                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13107                ),
13108                ("NF", GameMode::Taiko) => GameMod::NoFailTaiko(
13109                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13110                ),
13111                ("HT", GameMode::Taiko) => GameMod::HalfTimeTaiko(
13112                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13113                ),
13114                ("DC", GameMode::Taiko) => GameMod::DaycoreTaiko(
13115                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13116                ),
13117                ("SR", GameMode::Taiko) => GameMod::SimplifiedRhythmTaiko(
13118                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13119                ),
13120                ("HR", GameMode::Taiko) => GameMod::HardRockTaiko(
13121                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13122                ),
13123                ("SD", GameMode::Taiko) => GameMod::SuddenDeathTaiko(
13124                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13125                ),
13126                ("PF", GameMode::Taiko) => GameMod::PerfectTaiko(
13127                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13128                ),
13129                ("DT", GameMode::Taiko) => GameMod::DoubleTimeTaiko(
13130                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13131                ),
13132                ("NC", GameMode::Taiko) => GameMod::NightcoreTaiko(
13133                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13134                ),
13135                ("HD", GameMode::Taiko) => GameMod::HiddenTaiko(
13136                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13137                ),
13138                ("FL", GameMode::Taiko) => GameMod::FlashlightTaiko(
13139                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13140                ),
13141                ("AC", GameMode::Taiko) => GameMod::AccuracyChallengeTaiko(
13142                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13143                ),
13144                ("RD", GameMode::Taiko) => GameMod::RandomTaiko(
13145                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13146                ),
13147                ("DA", GameMode::Taiko) => GameMod::DifficultyAdjustTaiko(
13148                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13149                ),
13150                ("CL", GameMode::Taiko) => GameMod::ClassicTaiko(
13151                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13152                ),
13153                ("SW", GameMode::Taiko) => GameMod::SwapTaiko(
13154                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13155                ),
13156                ("SG", GameMode::Taiko) => GameMod::SingleTapTaiko(
13157                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13158                ),
13159                ("CS", GameMode::Taiko) => GameMod::ConstantSpeedTaiko(
13160                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13161                ),
13162                ("AT", GameMode::Taiko) => GameMod::AutoplayTaiko(
13163                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13164                ),
13165                ("CN", GameMode::Taiko) => GameMod::CinemaTaiko(
13166                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13167                ),
13168                ("RX", GameMode::Taiko) => GameMod::RelaxTaiko(
13169                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13170                ),
13171                ("WU", GameMode::Taiko) => GameMod::WindUpTaiko(
13172                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13173                ),
13174                ("WD", GameMode::Taiko) => GameMod::WindDownTaiko(
13175                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13176                ),
13177                ("MU", GameMode::Taiko) => GameMod::MutedTaiko(
13178                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13179                ),
13180                ("AS", GameMode::Taiko) => GameMod::AdaptiveSpeedTaiko(
13181                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13182                ),
13183                ("SV2", GameMode::Taiko) => GameMod::ScoreV2Taiko(
13184                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13185                ),
13186                ("EZ", GameMode::Catch) => GameMod::EasyCatch(
13187                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13188                ),
13189                ("NF", GameMode::Catch) => GameMod::NoFailCatch(
13190                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13191                ),
13192                ("HT", GameMode::Catch) => GameMod::HalfTimeCatch(
13193                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13194                ),
13195                ("DC", GameMode::Catch) => GameMod::DaycoreCatch(
13196                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13197                ),
13198                ("HR", GameMode::Catch) => GameMod::HardRockCatch(
13199                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13200                ),
13201                ("SD", GameMode::Catch) => GameMod::SuddenDeathCatch(
13202                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13203                ),
13204                ("PF", GameMode::Catch) => GameMod::PerfectCatch(
13205                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13206                ),
13207                ("DT", GameMode::Catch) => GameMod::DoubleTimeCatch(
13208                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13209                ),
13210                ("NC", GameMode::Catch) => GameMod::NightcoreCatch(
13211                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13212                ),
13213                ("HD", GameMode::Catch) => GameMod::HiddenCatch(
13214                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13215                ),
13216                ("FL", GameMode::Catch) => GameMod::FlashlightCatch(
13217                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13218                ),
13219                ("AC", GameMode::Catch) => GameMod::AccuracyChallengeCatch(
13220                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13221                ),
13222                ("DA", GameMode::Catch) => GameMod::DifficultyAdjustCatch(
13223                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13224                ),
13225                ("CL", GameMode::Catch) => GameMod::ClassicCatch(
13226                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13227                ),
13228                ("MR", GameMode::Catch) => GameMod::MirrorCatch(
13229                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13230                ),
13231                ("AT", GameMode::Catch) => GameMod::AutoplayCatch(
13232                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13233                ),
13234                ("CN", GameMode::Catch) => GameMod::CinemaCatch(
13235                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13236                ),
13237                ("RX", GameMode::Catch) => GameMod::RelaxCatch(
13238                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13239                ),
13240                ("WU", GameMode::Catch) => GameMod::WindUpCatch(
13241                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13242                ),
13243                ("WD", GameMode::Catch) => GameMod::WindDownCatch(
13244                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13245                ),
13246                ("FF", GameMode::Catch) => GameMod::FloatingFruitsCatch(
13247                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13248                ),
13249                ("MU", GameMode::Catch) => GameMod::MutedCatch(
13250                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13251                ),
13252                ("NS", GameMode::Catch) => GameMod::NoScopeCatch(
13253                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13254                ),
13255                ("MF", GameMode::Catch) => GameMod::MovingFastCatch(
13256                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13257                ),
13258                ("SV2", GameMode::Catch) => GameMod::ScoreV2Catch(
13259                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13260                ),
13261                ("EZ", GameMode::Mania) => GameMod::EasyMania(
13262                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13263                ),
13264                ("NF", GameMode::Mania) => GameMod::NoFailMania(
13265                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13266                ),
13267                ("HT", GameMode::Mania) => GameMod::HalfTimeMania(
13268                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13269                ),
13270                ("DC", GameMode::Mania) => GameMod::DaycoreMania(
13271                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13272                ),
13273                ("NR", GameMode::Mania) => GameMod::NoReleaseMania(
13274                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13275                ),
13276                ("HR", GameMode::Mania) => GameMod::HardRockMania(
13277                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13278                ),
13279                ("SD", GameMode::Mania) => GameMod::SuddenDeathMania(
13280                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13281                ),
13282                ("PF", GameMode::Mania) => GameMod::PerfectMania(
13283                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13284                ),
13285                ("DT", GameMode::Mania) => GameMod::DoubleTimeMania(
13286                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13287                ),
13288                ("NC", GameMode::Mania) => GameMod::NightcoreMania(
13289                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13290                ),
13291                ("FI", GameMode::Mania) => GameMod::FadeInMania(
13292                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13293                ),
13294                ("HD", GameMode::Mania) => GameMod::HiddenMania(
13295                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13296                ),
13297                ("CO", GameMode::Mania) => GameMod::CoverMania(
13298                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13299                ),
13300                ("FL", GameMode::Mania) => GameMod::FlashlightMania(
13301                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13302                ),
13303                ("AC", GameMode::Mania) => GameMod::AccuracyChallengeMania(
13304                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13305                ),
13306                ("RD", GameMode::Mania) => GameMod::RandomMania(
13307                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13308                ),
13309                ("DS", GameMode::Mania) => GameMod::DualStagesMania(
13310                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13311                ),
13312                ("MR", GameMode::Mania) => GameMod::MirrorMania(
13313                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13314                ),
13315                ("DA", GameMode::Mania) => GameMod::DifficultyAdjustMania(
13316                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13317                ),
13318                ("CL", GameMode::Mania) => GameMod::ClassicMania(
13319                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13320                ),
13321                ("IN", GameMode::Mania) => GameMod::InvertMania(
13322                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13323                ),
13324                ("CS", GameMode::Mania) => GameMod::ConstantSpeedMania(
13325                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13326                ),
13327                ("HO", GameMode::Mania) => GameMod::HoldOffMania(
13328                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13329                ),
13330                ("1K", GameMode::Mania) => GameMod::OneKeyMania(
13331                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13332                ),
13333                ("2K", GameMode::Mania) => GameMod::TwoKeysMania(
13334                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13335                ),
13336                ("3K", GameMode::Mania) => GameMod::ThreeKeysMania(
13337                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13338                ),
13339                ("4K", GameMode::Mania) => GameMod::FourKeysMania(
13340                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13341                ),
13342                ("5K", GameMode::Mania) => GameMod::FiveKeysMania(
13343                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13344                ),
13345                ("6K", GameMode::Mania) => GameMod::SixKeysMania(
13346                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13347                ),
13348                ("7K", GameMode::Mania) => GameMod::SevenKeysMania(
13349                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13350                ),
13351                ("8K", GameMode::Mania) => GameMod::EightKeysMania(
13352                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13353                ),
13354                ("9K", GameMode::Mania) => GameMod::NineKeysMania(
13355                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13356                ),
13357                ("10K", GameMode::Mania) => GameMod::TenKeysMania(
13358                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13359                ),
13360                ("AT", GameMode::Mania) => GameMod::AutoplayMania(
13361                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13362                ),
13363                ("CN", GameMode::Mania) => GameMod::CinemaMania(
13364                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13365                ),
13366                ("WU", GameMode::Mania) => GameMod::WindUpMania(
13367                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13368                ),
13369                ("WD", GameMode::Mania) => GameMod::WindDownMania(
13370                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13371                ),
13372                ("MU", GameMode::Mania) => GameMod::MutedMania(
13373                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13374                ),
13375                ("AS", GameMode::Mania) => GameMod::AdaptiveSpeedMania(
13376                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13377                ),
13378                ("SV2", GameMode::Mania) => GameMod::ScoreV2Mania(
13379                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
13380                ),
13381                _ => {
13382                    let acronym = <Acronym as std::str::FromStr>::from_str(self.acronym)
13383                        .map_err(DeError::custom)?;
13384                    // All fields are specified already but we still want to clear
13385                    // out content from the deserializer.
13386                    #[allow(clippy::needless_update)]
13387                    let unknown = UnknownMod {
13388                        acronym,
13389                        ..Deserialize::deserialize(d)?
13390                    };
13391                    match self.mode {
13392                        GameMode::Osu => GameMod::UnknownOsu(unknown),
13393                        GameMode::Taiko => GameMod::UnknownTaiko(unknown),
13394                        GameMode::Catch => GameMod::UnknownCatch(unknown),
13395                        GameMode::Mania => GameMod::UnknownMania(unknown),
13396                    }
13397                }
13398            };
13399            Ok(res)
13400        }
13401    }
13402    impl Serialize for GameMod {
13403        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
13404            let mut s = s.serialize_map(None)?;
13405            s.serialize_entry("acronym", self.acronym().as_str())?;
13406            match self {
13407                Self::EasyOsu(m) => {
13408                    let has_some = m.retries.is_some();
13409                    if has_some {
13410                        s.serialize_entry("settings", m)?;
13411                    }
13412                }
13413                Self::HalfTimeOsu(m) => {
13414                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13415                    if has_some {
13416                        s.serialize_entry("settings", m)?;
13417                    }
13418                }
13419                Self::DaycoreOsu(m) => {
13420                    let has_some = m.speed_change.is_some();
13421                    if has_some {
13422                        s.serialize_entry("settings", m)?;
13423                    }
13424                }
13425                Self::SuddenDeathOsu(m) => {
13426                    let has_some = m.fail_on_slider_tail.is_some() || m.restart.is_some();
13427                    if has_some {
13428                        s.serialize_entry("settings", m)?;
13429                    }
13430                }
13431                Self::PerfectOsu(m) => {
13432                    let has_some = m.restart.is_some();
13433                    if has_some {
13434                        s.serialize_entry("settings", m)?;
13435                    }
13436                }
13437                Self::DoubleTimeOsu(m) => {
13438                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13439                    if has_some {
13440                        s.serialize_entry("settings", m)?;
13441                    }
13442                }
13443                Self::NightcoreOsu(m) => {
13444                    let has_some = m.speed_change.is_some();
13445                    if has_some {
13446                        s.serialize_entry("settings", m)?;
13447                    }
13448                }
13449                Self::HiddenOsu(m) => {
13450                    let has_some = m.only_fade_approach_circles.is_some();
13451                    if has_some {
13452                        s.serialize_entry("settings", m)?;
13453                    }
13454                }
13455                Self::FlashlightOsu(m) => {
13456                    let has_some = m.follow_delay.is_some()
13457                        || m.size_multiplier.is_some()
13458                        || m.combo_based_size.is_some();
13459                    if has_some {
13460                        s.serialize_entry("settings", m)?;
13461                    }
13462                }
13463                Self::AccuracyChallengeOsu(m) => {
13464                    let has_some = m.minimum_accuracy.is_some()
13465                        || m.accuracy_judge_mode.is_some()
13466                        || m.restart.is_some();
13467                    if has_some {
13468                        s.serialize_entry("settings", m)?;
13469                    }
13470                }
13471                Self::TargetPracticeOsu(m) => {
13472                    let has_some = m.seed.is_some() || m.metronome.is_some();
13473                    if has_some {
13474                        s.serialize_entry("settings", m)?;
13475                    }
13476                }
13477                Self::DifficultyAdjustOsu(m) => {
13478                    let has_some = m.circle_size.is_some()
13479                        || m.approach_rate.is_some()
13480                        || m.drain_rate.is_some()
13481                        || m.overall_difficulty.is_some()
13482                        || m.extended_limits.is_some();
13483                    if has_some {
13484                        s.serialize_entry("settings", m)?;
13485                    }
13486                }
13487                Self::ClassicOsu(m) => {
13488                    let has_some = m.no_slider_head_accuracy.is_some()
13489                        || m.classic_note_lock.is_some()
13490                        || m.always_play_tail_sample.is_some()
13491                        || m.fade_hit_circle_early.is_some()
13492                        || m.classic_health.is_some();
13493                    if has_some {
13494                        s.serialize_entry("settings", m)?;
13495                    }
13496                }
13497                Self::RandomOsu(m) => {
13498                    let has_some = m.angle_sharpness.is_some() || m.seed.is_some();
13499                    if has_some {
13500                        s.serialize_entry("settings", m)?;
13501                    }
13502                }
13503                Self::MirrorOsu(m) => {
13504                    let has_some = m.reflection.is_some();
13505                    if has_some {
13506                        s.serialize_entry("settings", m)?;
13507                    }
13508                }
13509                Self::WiggleOsu(m) => {
13510                    let has_some = m.strength.is_some();
13511                    if has_some {
13512                        s.serialize_entry("settings", m)?;
13513                    }
13514                }
13515                Self::GrowOsu(m) => {
13516                    let has_some = m.start_scale.is_some();
13517                    if has_some {
13518                        s.serialize_entry("settings", m)?;
13519                    }
13520                }
13521                Self::DeflateOsu(m) => {
13522                    let has_some = m.start_scale.is_some();
13523                    if has_some {
13524                        s.serialize_entry("settings", m)?;
13525                    }
13526                }
13527                Self::WindUpOsu(m) => {
13528                    let has_some = m.initial_rate.is_some()
13529                        || m.final_rate.is_some()
13530                        || m.adjust_pitch.is_some();
13531                    if has_some {
13532                        s.serialize_entry("settings", m)?;
13533                    }
13534                }
13535                Self::WindDownOsu(m) => {
13536                    let has_some = m.initial_rate.is_some()
13537                        || m.final_rate.is_some()
13538                        || m.adjust_pitch.is_some();
13539                    if has_some {
13540                        s.serialize_entry("settings", m)?;
13541                    }
13542                }
13543                Self::BarrelRollOsu(m) => {
13544                    let has_some = m.spin_speed.is_some() || m.direction.is_some();
13545                    if has_some {
13546                        s.serialize_entry("settings", m)?;
13547                    }
13548                }
13549                Self::ApproachDifferentOsu(m) => {
13550                    let has_some = m.scale.is_some() || m.style.is_some();
13551                    if has_some {
13552                        s.serialize_entry("settings", m)?;
13553                    }
13554                }
13555                Self::MutedOsu(m) => {
13556                    let has_some = m.inverse_muting.is_some()
13557                        || m.enable_metronome.is_some()
13558                        || m.mute_combo_count.is_some()
13559                        || m.affects_hit_sounds.is_some();
13560                    if has_some {
13561                        s.serialize_entry("settings", m)?;
13562                    }
13563                }
13564                Self::NoScopeOsu(m) => {
13565                    let has_some = m.hidden_combo_count.is_some();
13566                    if has_some {
13567                        s.serialize_entry("settings", m)?;
13568                    }
13569                }
13570                Self::MagnetisedOsu(m) => {
13571                    let has_some = m.attraction_strength.is_some();
13572                    if has_some {
13573                        s.serialize_entry("settings", m)?;
13574                    }
13575                }
13576                Self::RepelOsu(m) => {
13577                    let has_some = m.repulsion_strength.is_some();
13578                    if has_some {
13579                        s.serialize_entry("settings", m)?;
13580                    }
13581                }
13582                Self::AdaptiveSpeedOsu(m) => {
13583                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
13584                    if has_some {
13585                        s.serialize_entry("settings", m)?;
13586                    }
13587                }
13588                Self::DepthOsu(m) => {
13589                    let has_some = m.max_depth.is_some() || m.show_approach_circles.is_some();
13590                    if has_some {
13591                        s.serialize_entry("settings", m)?;
13592                    }
13593                }
13594                Self::BloomOsu(m) => {
13595                    let has_some = m.max_size_combo_count.is_some() || m.max_cursor_size.is_some();
13596                    if has_some {
13597                        s.serialize_entry("settings", m)?;
13598                    }
13599                }
13600                Self::HalfTimeTaiko(m) => {
13601                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13602                    if has_some {
13603                        s.serialize_entry("settings", m)?;
13604                    }
13605                }
13606                Self::DaycoreTaiko(m) => {
13607                    let has_some = m.speed_change.is_some();
13608                    if has_some {
13609                        s.serialize_entry("settings", m)?;
13610                    }
13611                }
13612                Self::SimplifiedRhythmTaiko(m) => {
13613                    let has_some = m.one_third_conversion.is_some()
13614                        || m.one_sixth_conversion.is_some()
13615                        || m.one_eighth_conversion.is_some();
13616                    if has_some {
13617                        s.serialize_entry("settings", m)?;
13618                    }
13619                }
13620                Self::SuddenDeathTaiko(m) => {
13621                    let has_some = m.restart.is_some();
13622                    if has_some {
13623                        s.serialize_entry("settings", m)?;
13624                    }
13625                }
13626                Self::PerfectTaiko(m) => {
13627                    let has_some = m.restart.is_some();
13628                    if has_some {
13629                        s.serialize_entry("settings", m)?;
13630                    }
13631                }
13632                Self::DoubleTimeTaiko(m) => {
13633                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13634                    if has_some {
13635                        s.serialize_entry("settings", m)?;
13636                    }
13637                }
13638                Self::NightcoreTaiko(m) => {
13639                    let has_some = m.speed_change.is_some();
13640                    if has_some {
13641                        s.serialize_entry("settings", m)?;
13642                    }
13643                }
13644                Self::FlashlightTaiko(m) => {
13645                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
13646                    if has_some {
13647                        s.serialize_entry("settings", m)?;
13648                    }
13649                }
13650                Self::AccuracyChallengeTaiko(m) => {
13651                    let has_some = m.minimum_accuracy.is_some()
13652                        || m.accuracy_judge_mode.is_some()
13653                        || m.restart.is_some();
13654                    if has_some {
13655                        s.serialize_entry("settings", m)?;
13656                    }
13657                }
13658                Self::RandomTaiko(m) => {
13659                    let has_some = m.seed.is_some();
13660                    if has_some {
13661                        s.serialize_entry("settings", m)?;
13662                    }
13663                }
13664                Self::DifficultyAdjustTaiko(m) => {
13665                    let has_some = m.scroll_speed.is_some()
13666                        || m.drain_rate.is_some()
13667                        || m.overall_difficulty.is_some()
13668                        || m.extended_limits.is_some();
13669                    if has_some {
13670                        s.serialize_entry("settings", m)?;
13671                    }
13672                }
13673                Self::WindUpTaiko(m) => {
13674                    let has_some = m.initial_rate.is_some()
13675                        || m.final_rate.is_some()
13676                        || m.adjust_pitch.is_some();
13677                    if has_some {
13678                        s.serialize_entry("settings", m)?;
13679                    }
13680                }
13681                Self::WindDownTaiko(m) => {
13682                    let has_some = m.initial_rate.is_some()
13683                        || m.final_rate.is_some()
13684                        || m.adjust_pitch.is_some();
13685                    if has_some {
13686                        s.serialize_entry("settings", m)?;
13687                    }
13688                }
13689                Self::MutedTaiko(m) => {
13690                    let has_some = m.inverse_muting.is_some()
13691                        || m.enable_metronome.is_some()
13692                        || m.mute_combo_count.is_some()
13693                        || m.affects_hit_sounds.is_some();
13694                    if has_some {
13695                        s.serialize_entry("settings", m)?;
13696                    }
13697                }
13698                Self::AdaptiveSpeedTaiko(m) => {
13699                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
13700                    if has_some {
13701                        s.serialize_entry("settings", m)?;
13702                    }
13703                }
13704                Self::EasyCatch(m) => {
13705                    let has_some = m.retries.is_some();
13706                    if has_some {
13707                        s.serialize_entry("settings", m)?;
13708                    }
13709                }
13710                Self::HalfTimeCatch(m) => {
13711                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13712                    if has_some {
13713                        s.serialize_entry("settings", m)?;
13714                    }
13715                }
13716                Self::DaycoreCatch(m) => {
13717                    let has_some = m.speed_change.is_some();
13718                    if has_some {
13719                        s.serialize_entry("settings", m)?;
13720                    }
13721                }
13722                Self::SuddenDeathCatch(m) => {
13723                    let has_some = m.restart.is_some();
13724                    if has_some {
13725                        s.serialize_entry("settings", m)?;
13726                    }
13727                }
13728                Self::PerfectCatch(m) => {
13729                    let has_some = m.restart.is_some();
13730                    if has_some {
13731                        s.serialize_entry("settings", m)?;
13732                    }
13733                }
13734                Self::DoubleTimeCatch(m) => {
13735                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13736                    if has_some {
13737                        s.serialize_entry("settings", m)?;
13738                    }
13739                }
13740                Self::NightcoreCatch(m) => {
13741                    let has_some = m.speed_change.is_some();
13742                    if has_some {
13743                        s.serialize_entry("settings", m)?;
13744                    }
13745                }
13746                Self::FlashlightCatch(m) => {
13747                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
13748                    if has_some {
13749                        s.serialize_entry("settings", m)?;
13750                    }
13751                }
13752                Self::AccuracyChallengeCatch(m) => {
13753                    let has_some = m.minimum_accuracy.is_some()
13754                        || m.accuracy_judge_mode.is_some()
13755                        || m.restart.is_some();
13756                    if has_some {
13757                        s.serialize_entry("settings", m)?;
13758                    }
13759                }
13760                Self::DifficultyAdjustCatch(m) => {
13761                    let has_some = m.circle_size.is_some()
13762                        || m.approach_rate.is_some()
13763                        || m.hard_rock_offsets.is_some()
13764                        || m.drain_rate.is_some()
13765                        || m.overall_difficulty.is_some()
13766                        || m.extended_limits.is_some();
13767                    if has_some {
13768                        s.serialize_entry("settings", m)?;
13769                    }
13770                }
13771                Self::WindUpCatch(m) => {
13772                    let has_some = m.initial_rate.is_some()
13773                        || m.final_rate.is_some()
13774                        || m.adjust_pitch.is_some();
13775                    if has_some {
13776                        s.serialize_entry("settings", m)?;
13777                    }
13778                }
13779                Self::WindDownCatch(m) => {
13780                    let has_some = m.initial_rate.is_some()
13781                        || m.final_rate.is_some()
13782                        || m.adjust_pitch.is_some();
13783                    if has_some {
13784                        s.serialize_entry("settings", m)?;
13785                    }
13786                }
13787                Self::MutedCatch(m) => {
13788                    let has_some = m.inverse_muting.is_some()
13789                        || m.enable_metronome.is_some()
13790                        || m.mute_combo_count.is_some()
13791                        || m.affects_hit_sounds.is_some();
13792                    if has_some {
13793                        s.serialize_entry("settings", m)?;
13794                    }
13795                }
13796                Self::NoScopeCatch(m) => {
13797                    let has_some = m.hidden_combo_count.is_some();
13798                    if has_some {
13799                        s.serialize_entry("settings", m)?;
13800                    }
13801                }
13802                Self::EasyMania(m) => {
13803                    let has_some = m.retries.is_some();
13804                    if has_some {
13805                        s.serialize_entry("settings", m)?;
13806                    }
13807                }
13808                Self::HalfTimeMania(m) => {
13809                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13810                    if has_some {
13811                        s.serialize_entry("settings", m)?;
13812                    }
13813                }
13814                Self::DaycoreMania(m) => {
13815                    let has_some = m.speed_change.is_some();
13816                    if has_some {
13817                        s.serialize_entry("settings", m)?;
13818                    }
13819                }
13820                Self::SuddenDeathMania(m) => {
13821                    let has_some = m.restart.is_some();
13822                    if has_some {
13823                        s.serialize_entry("settings", m)?;
13824                    }
13825                }
13826                Self::PerfectMania(m) => {
13827                    let has_some = m.require_perfect_hits.is_some() || m.restart.is_some();
13828                    if has_some {
13829                        s.serialize_entry("settings", m)?;
13830                    }
13831                }
13832                Self::DoubleTimeMania(m) => {
13833                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
13834                    if has_some {
13835                        s.serialize_entry("settings", m)?;
13836                    }
13837                }
13838                Self::NightcoreMania(m) => {
13839                    let has_some = m.speed_change.is_some();
13840                    if has_some {
13841                        s.serialize_entry("settings", m)?;
13842                    }
13843                }
13844                Self::CoverMania(m) => {
13845                    let has_some = m.coverage.is_some() || m.direction.is_some();
13846                    if has_some {
13847                        s.serialize_entry("settings", m)?;
13848                    }
13849                }
13850                Self::FlashlightMania(m) => {
13851                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
13852                    if has_some {
13853                        s.serialize_entry("settings", m)?;
13854                    }
13855                }
13856                Self::AccuracyChallengeMania(m) => {
13857                    let has_some = m.minimum_accuracy.is_some()
13858                        || m.accuracy_judge_mode.is_some()
13859                        || m.restart.is_some();
13860                    if has_some {
13861                        s.serialize_entry("settings", m)?;
13862                    }
13863                }
13864                Self::RandomMania(m) => {
13865                    let has_some = m.seed.is_some();
13866                    if has_some {
13867                        s.serialize_entry("settings", m)?;
13868                    }
13869                }
13870                Self::DifficultyAdjustMania(m) => {
13871                    let has_some = m.overall_difficulty.is_some()
13872                        || m.drain_rate.is_some()
13873                        || m.extended_limits.is_some();
13874                    if has_some {
13875                        s.serialize_entry("settings", m)?;
13876                    }
13877                }
13878                Self::WindUpMania(m) => {
13879                    let has_some = m.initial_rate.is_some()
13880                        || m.final_rate.is_some()
13881                        || m.adjust_pitch.is_some();
13882                    if has_some {
13883                        s.serialize_entry("settings", m)?;
13884                    }
13885                }
13886                Self::WindDownMania(m) => {
13887                    let has_some = m.initial_rate.is_some()
13888                        || m.final_rate.is_some()
13889                        || m.adjust_pitch.is_some();
13890                    if has_some {
13891                        s.serialize_entry("settings", m)?;
13892                    }
13893                }
13894                Self::MutedMania(m) => {
13895                    let has_some = m.inverse_muting.is_some()
13896                        || m.enable_metronome.is_some()
13897                        || m.mute_combo_count.is_some()
13898                        || m.affects_hit_sounds.is_some();
13899                    if has_some {
13900                        s.serialize_entry("settings", m)?;
13901                    }
13902                }
13903                Self::AdaptiveSpeedMania(m) => {
13904                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
13905                    if has_some {
13906                        s.serialize_entry("settings", m)?;
13907                    }
13908                }
13909                _ => {}
13910            }
13911            s.end()
13912        }
13913    }
13914    impl<'de> Deserialize<'de> for GameModIntermode {
13915        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
13916            fn try_acronym_to_gamemod<E: DeError>(
13917                acronym: &MaybeOwnedStr<'_>,
13918            ) -> Result<GameModIntermode, E> {
13919                acronym
13920                    .as_str()
13921                    .parse()
13922                    .map(GameModIntermode::from_acronym)
13923                    .map_err(DeError::custom)
13924            }
13925            let raw_seed = GameModRawSeed {
13926                deny_unknown_fields: true,
13927            };
13928            match raw_seed.deserialize(d)? {
13929                GameModRaw::Bits(bits) => GameModIntermode::try_from_bits(bits)
13930                    .ok_or_else(|| DeError::custom("invalid bitflags")),
13931                GameModRaw::Acronym(acronym) => try_acronym_to_gamemod(&acronym),
13932                GameModRaw::Full { acronym, .. } => try_acronym_to_gamemod(&acronym),
13933            }
13934        }
13935    }
13936    impl serde::Serialize for GameModIntermode {
13937        fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
13938            s.serialize_str(self.acronym().as_str())
13939        }
13940    }
13941    impl GameModSettings<'_> {
13942        pub(crate) fn try_deserialize(
13943            &self,
13944            acronym: &str,
13945            deny_unknown_fields: bool,
13946        ) -> Option<GameMod> {
13947            macro_rules! try_deser {
13948                ( $osu_mod:ident, $taiko_mod:ident, $catch_mod:ident, $mania_mod:ident, ) => {{
13949                    try_deser!(@ $osu_mod Osu);
13950                    try_deser!(@ $taiko_mod Taiko);
13951                    try_deser!(@ $catch_mod Catch);
13952                    try_deser!(@ $mania_mod Mania);
13953                }};
13954                ( @ Skip_ $mode:ident ) => {};
13955                ( @ $name:ident $mode:ident ) => {
13956                    if let Ok(m) = DeserializedGameMod::try_deserialize_mod(self, deny_unknown_fields) {
13957                        return Some(GameMod::$name(m));
13958                    }
13959                };
13960            }
13961            match acronym {
13962                "10K" => try_deser!(Skip_, Skip_, Skip_, TenKeysMania,),
13963                "1K" => try_deser!(Skip_, Skip_, Skip_, OneKeyMania,),
13964                "2K" => try_deser!(Skip_, Skip_, Skip_, TwoKeysMania,),
13965                "3K" => try_deser!(Skip_, Skip_, Skip_, ThreeKeysMania,),
13966                "4K" => try_deser!(Skip_, Skip_, Skip_, FourKeysMania,),
13967                "5K" => try_deser!(Skip_, Skip_, Skip_, FiveKeysMania,),
13968                "6K" => try_deser!(Skip_, Skip_, Skip_, SixKeysMania,),
13969                "7K" => try_deser!(Skip_, Skip_, Skip_, SevenKeysMania,),
13970                "8K" => try_deser!(Skip_, Skip_, Skip_, EightKeysMania,),
13971                "9K" => try_deser!(Skip_, Skip_, Skip_, NineKeysMania,),
13972                "AC" => try_deser!(
13973                    AccuracyChallengeOsu,
13974                    AccuracyChallengeTaiko,
13975                    AccuracyChallengeCatch,
13976                    AccuracyChallengeMania,
13977                ),
13978                "AD" => try_deser!(ApproachDifferentOsu, Skip_, Skip_, Skip_,),
13979                "AL" => try_deser!(AlternateOsu, Skip_, Skip_, Skip_,),
13980                "AP" => try_deser!(AutopilotOsu, Skip_, Skip_, Skip_,),
13981                "AS" => try_deser!(
13982                    AdaptiveSpeedOsu,
13983                    AdaptiveSpeedTaiko,
13984                    Skip_,
13985                    AdaptiveSpeedMania,
13986                ),
13987                "AT" => try_deser!(AutoplayOsu, AutoplayTaiko, AutoplayCatch, AutoplayMania,),
13988                "BL" => try_deser!(BlindsOsu, Skip_, Skip_, Skip_,),
13989                "BM" => try_deser!(BloomOsu, Skip_, Skip_, Skip_,),
13990                "BR" => try_deser!(BarrelRollOsu, Skip_, Skip_, Skip_,),
13991                "BU" => try_deser!(BubblesOsu, Skip_, Skip_, Skip_,),
13992                "CL" => try_deser!(ClassicOsu, ClassicTaiko, ClassicCatch, ClassicMania,),
13993                "CN" => try_deser!(CinemaOsu, CinemaTaiko, CinemaCatch, CinemaMania,),
13994                "CO" => try_deser!(Skip_, Skip_, Skip_, CoverMania,),
13995                "CS" => try_deser!(Skip_, ConstantSpeedTaiko, Skip_, ConstantSpeedMania,),
13996                "DA" => try_deser!(
13997                    DifficultyAdjustOsu,
13998                    DifficultyAdjustTaiko,
13999                    DifficultyAdjustCatch,
14000                    DifficultyAdjustMania,
14001                ),
14002                "DC" => try_deser!(DaycoreOsu, DaycoreTaiko, DaycoreCatch, DaycoreMania,),
14003                "DF" => try_deser!(DeflateOsu, Skip_, Skip_, Skip_,),
14004                "DP" => try_deser!(DepthOsu, Skip_, Skip_, Skip_,),
14005                "DS" => try_deser!(Skip_, Skip_, Skip_, DualStagesMania,),
14006                "DT" => try_deser!(
14007                    DoubleTimeOsu,
14008                    DoubleTimeTaiko,
14009                    DoubleTimeCatch,
14010                    DoubleTimeMania,
14011                ),
14012                "EZ" => try_deser!(EasyOsu, EasyTaiko, EasyCatch, EasyMania,),
14013                "FF" => try_deser!(Skip_, Skip_, FloatingFruitsCatch, Skip_,),
14014                "FI" => try_deser!(Skip_, Skip_, Skip_, FadeInMania,),
14015                "FL" => try_deser!(
14016                    FlashlightOsu,
14017                    FlashlightTaiko,
14018                    FlashlightCatch,
14019                    FlashlightMania,
14020                ),
14021                "FR" => try_deser!(FreezeFrameOsu, Skip_, Skip_, Skip_,),
14022                "GR" => try_deser!(GrowOsu, Skip_, Skip_, Skip_,),
14023                "HD" => try_deser!(HiddenOsu, HiddenTaiko, HiddenCatch, HiddenMania,),
14024                "HO" => try_deser!(Skip_, Skip_, Skip_, HoldOffMania,),
14025                "HR" => try_deser!(HardRockOsu, HardRockTaiko, HardRockCatch, HardRockMania,),
14026                "HT" => try_deser!(HalfTimeOsu, HalfTimeTaiko, HalfTimeCatch, HalfTimeMania,),
14027                "IN" => try_deser!(Skip_, Skip_, Skip_, InvertMania,),
14028                "MF" => try_deser!(Skip_, Skip_, MovingFastCatch, Skip_,),
14029                "MG" => try_deser!(MagnetisedOsu, Skip_, Skip_, Skip_,),
14030                "MR" => try_deser!(MirrorOsu, Skip_, MirrorCatch, MirrorMania,),
14031                "MU" => try_deser!(MutedOsu, MutedTaiko, MutedCatch, MutedMania,),
14032                "NC" => try_deser!(NightcoreOsu, NightcoreTaiko, NightcoreCatch, NightcoreMania,),
14033                "NF" => try_deser!(NoFailOsu, NoFailTaiko, NoFailCatch, NoFailMania,),
14034                "NR" => try_deser!(Skip_, Skip_, Skip_, NoReleaseMania,),
14035                "NS" => try_deser!(NoScopeOsu, Skip_, NoScopeCatch, Skip_,),
14036                "PF" => try_deser!(PerfectOsu, PerfectTaiko, PerfectCatch, PerfectMania,),
14037                "RD" => try_deser!(RandomOsu, RandomTaiko, Skip_, RandomMania,),
14038                "RP" => try_deser!(RepelOsu, Skip_, Skip_, Skip_,),
14039                "RX" => try_deser!(RelaxOsu, RelaxTaiko, RelaxCatch, Skip_,),
14040                "SD" => try_deser!(
14041                    SuddenDeathOsu,
14042                    SuddenDeathTaiko,
14043                    SuddenDeathCatch,
14044                    SuddenDeathMania,
14045                ),
14046                "SG" => try_deser!(SingleTapOsu, SingleTapTaiko, Skip_, Skip_,),
14047                "SI" => try_deser!(SpinInOsu, Skip_, Skip_, Skip_,),
14048                "SO" => try_deser!(SpunOutOsu, Skip_, Skip_, Skip_,),
14049                "SR" => try_deser!(Skip_, SimplifiedRhythmTaiko, Skip_, Skip_,),
14050                "ST" => try_deser!(StrictTrackingOsu, Skip_, Skip_, Skip_,),
14051                "SV2" => try_deser!(ScoreV2Osu, ScoreV2Taiko, ScoreV2Catch, ScoreV2Mania,),
14052                "SW" => try_deser!(Skip_, SwapTaiko, Skip_, Skip_,),
14053                "SY" => try_deser!(SynesthesiaOsu, Skip_, Skip_, Skip_,),
14054                "TC" => try_deser!(TraceableOsu, Skip_, Skip_, Skip_,),
14055                "TD" => try_deser!(TouchDeviceOsu, Skip_, Skip_, Skip_,),
14056                "TP" => try_deser!(TargetPracticeOsu, Skip_, Skip_, Skip_,),
14057                "TR" => try_deser!(TransformOsu, Skip_, Skip_, Skip_,),
14058                "WD" => try_deser!(WindDownOsu, WindDownTaiko, WindDownCatch, WindDownMania,),
14059                "WG" => try_deser!(WiggleOsu, Skip_, Skip_, Skip_,),
14060                "WU" => try_deser!(WindUpOsu, WindUpTaiko, WindUpCatch, WindUpMania,),
14061                _ => {}
14062            }
14063            None
14064        }
14065    }
14066};
14067#[macro_export(local_inner_macros)]
14068#[cfg(feature = "macros")]
14069#[doc(hidden)]
14070macro_rules! mods_inner {
14071    ( @ $mode:ident: $( $acronym:tt )* ) => {{
14072        // Making sure it's a valid GameMode
14073        let _ = $crate::GameMode::$mode;
14074
14075        #[allow(unused_mut)]
14076        let mut mods = $crate::GameMods::new();
14077        $( mods.insert(mods_inner!(< ! $mode $acronym)(Default::default())); )*
14078        mods
14079    }};
14080    ( @ $( $acronym:tt )* ) => {{
14081        #[allow(unused_mut)]
14082        let mut mods = $crate::GameModsIntermode::new();
14083        $( mods.insert(mods_inner!(< $acronym)); )*
14084        mods
14085    }};
14086
14087    // Translating acronym to variant name
14088    ( < $( ! $mode:ident )? 10K ) => { mods_inner!(> $( $mode )? TenKeys ) };
14089    ( < $( ! $mode:ident )? 1K ) => { mods_inner!(> $( $mode )? OneKey ) };
14090    ( < $( ! $mode:ident )? 2K ) => { mods_inner!(> $( $mode )? TwoKeys ) };
14091    ( < $( ! $mode:ident )? 3K ) => { mods_inner!(> $( $mode )? ThreeKeys ) };
14092    ( < $( ! $mode:ident )? 4K ) => { mods_inner!(> $( $mode )? FourKeys ) };
14093    ( < $( ! $mode:ident )? 5K ) => { mods_inner!(> $( $mode )? FiveKeys ) };
14094    ( < $( ! $mode:ident )? 6K ) => { mods_inner!(> $( $mode )? SixKeys ) };
14095    ( < $( ! $mode:ident )? 7K ) => { mods_inner!(> $( $mode )? SevenKeys ) };
14096    ( < $( ! $mode:ident )? 8K ) => { mods_inner!(> $( $mode )? EightKeys ) };
14097    ( < $( ! $mode:ident )? 9K ) => { mods_inner!(> $( $mode )? NineKeys ) };
14098    ( < $( ! $mode:ident )? AC ) => { mods_inner!(> $( $mode )? AccuracyChallenge ) };
14099    ( < $( ! $mode:ident )? AD ) => { mods_inner!(> $( $mode )? ApproachDifferent ) };
14100    ( < $( ! $mode:ident )? AL ) => { mods_inner!(> $( $mode )? Alternate ) };
14101    ( < $( ! $mode:ident )? AP ) => { mods_inner!(> $( $mode )? Autopilot ) };
14102    ( < $( ! $mode:ident )? AS ) => { mods_inner!(> $( $mode )? AdaptiveSpeed ) };
14103    ( < $( ! $mode:ident )? AT ) => { mods_inner!(> $( $mode )? Autoplay ) };
14104    ( < $( ! $mode:ident )? BL ) => { mods_inner!(> $( $mode )? Blinds ) };
14105    ( < $( ! $mode:ident )? BM ) => { mods_inner!(> $( $mode )? Bloom ) };
14106    ( < $( ! $mode:ident )? BR ) => { mods_inner!(> $( $mode )? BarrelRoll ) };
14107    ( < $( ! $mode:ident )? BU ) => { mods_inner!(> $( $mode )? Bubbles ) };
14108    ( < $( ! $mode:ident )? CL ) => { mods_inner!(> $( $mode )? Classic ) };
14109    ( < $( ! $mode:ident )? CN ) => { mods_inner!(> $( $mode )? Cinema ) };
14110    ( < $( ! $mode:ident )? CO ) => { mods_inner!(> $( $mode )? Cover ) };
14111    ( < $( ! $mode:ident )? CS ) => { mods_inner!(> $( $mode )? ConstantSpeed ) };
14112    ( < $( ! $mode:ident )? DA ) => { mods_inner!(> $( $mode )? DifficultyAdjust ) };
14113    ( < $( ! $mode:ident )? DC ) => { mods_inner!(> $( $mode )? Daycore ) };
14114    ( < $( ! $mode:ident )? DF ) => { mods_inner!(> $( $mode )? Deflate ) };
14115    ( < $( ! $mode:ident )? DP ) => { mods_inner!(> $( $mode )? Depth ) };
14116    ( < $( ! $mode:ident )? DS ) => { mods_inner!(> $( $mode )? DualStages ) };
14117    ( < $( ! $mode:ident )? DT ) => { mods_inner!(> $( $mode )? DoubleTime ) };
14118    ( < $( ! $mode:ident )? EZ ) => { mods_inner!(> $( $mode )? Easy ) };
14119    ( < $( ! $mode:ident )? FF ) => { mods_inner!(> $( $mode )? FloatingFruits ) };
14120    ( < $( ! $mode:ident )? FI ) => { mods_inner!(> $( $mode )? FadeIn ) };
14121    ( < $( ! $mode:ident )? FL ) => { mods_inner!(> $( $mode )? Flashlight ) };
14122    ( < $( ! $mode:ident )? FR ) => { mods_inner!(> $( $mode )? FreezeFrame ) };
14123    ( < $( ! $mode:ident )? GR ) => { mods_inner!(> $( $mode )? Grow ) };
14124    ( < $( ! $mode:ident )? HD ) => { mods_inner!(> $( $mode )? Hidden ) };
14125    ( < $( ! $mode:ident )? HO ) => { mods_inner!(> $( $mode )? HoldOff ) };
14126    ( < $( ! $mode:ident )? HR ) => { mods_inner!(> $( $mode )? HardRock ) };
14127    ( < $( ! $mode:ident )? HT ) => { mods_inner!(> $( $mode )? HalfTime ) };
14128    ( < $( ! $mode:ident )? IN ) => { mods_inner!(> $( $mode )? Invert ) };
14129    ( < $( ! $mode:ident )? MF ) => { mods_inner!(> $( $mode )? MovingFast ) };
14130    ( < $( ! $mode:ident )? MG ) => { mods_inner!(> $( $mode )? Magnetised ) };
14131    ( < $( ! $mode:ident )? MR ) => { mods_inner!(> $( $mode )? Mirror ) };
14132    ( < $( ! $mode:ident )? MU ) => { mods_inner!(> $( $mode )? Muted ) };
14133    ( < $( ! $mode:ident )? NC ) => { mods_inner!(> $( $mode )? Nightcore ) };
14134    ( < $( ! $mode:ident )? NF ) => { mods_inner!(> $( $mode )? NoFail ) };
14135    ( < $( ! $mode:ident )? NR ) => { mods_inner!(> $( $mode )? NoRelease ) };
14136    ( < $( ! $mode:ident )? NS ) => { mods_inner!(> $( $mode )? NoScope ) };
14137    ( < $( ! $mode:ident )? PF ) => { mods_inner!(> $( $mode )? Perfect ) };
14138    ( < $( ! $mode:ident )? RD ) => { mods_inner!(> $( $mode )? Random ) };
14139    ( < $( ! $mode:ident )? RP ) => { mods_inner!(> $( $mode )? Repel ) };
14140    ( < $( ! $mode:ident )? RX ) => { mods_inner!(> $( $mode )? Relax ) };
14141    ( < $( ! $mode:ident )? SD ) => { mods_inner!(> $( $mode )? SuddenDeath ) };
14142    ( < $( ! $mode:ident )? SG ) => { mods_inner!(> $( $mode )? SingleTap ) };
14143    ( < $( ! $mode:ident )? SI ) => { mods_inner!(> $( $mode )? SpinIn ) };
14144    ( < $( ! $mode:ident )? SO ) => { mods_inner!(> $( $mode )? SpunOut ) };
14145    ( < $( ! $mode:ident )? SR ) => { mods_inner!(> $( $mode )? SimplifiedRhythm ) };
14146    ( < $( ! $mode:ident )? ST ) => { mods_inner!(> $( $mode )? StrictTracking ) };
14147    ( < $( ! $mode:ident )? SV2 ) => { mods_inner!(> $( $mode )? ScoreV2 ) };
14148    ( < $( ! $mode:ident )? SW ) => { mods_inner!(> $( $mode )? Swap ) };
14149    ( < $( ! $mode:ident )? SY ) => { mods_inner!(> $( $mode )? Synesthesia ) };
14150    ( < $( ! $mode:ident )? TC ) => { mods_inner!(> $( $mode )? Traceable ) };
14151    ( < $( ! $mode:ident )? TD ) => { mods_inner!(> $( $mode )? TouchDevice ) };
14152    ( < $( ! $mode:ident )? TP ) => { mods_inner!(> $( $mode )? TargetPractice ) };
14153    ( < $( ! $mode:ident )? TR ) => { mods_inner!(> $( $mode )? Transform ) };
14154    ( < $( ! $mode:ident )? WD ) => { mods_inner!(> $( $mode )? WindDown ) };
14155    ( < $( ! $mode:ident )? WG ) => { mods_inner!(> $( $mode )? Wiggle ) };
14156    ( < $( ! $mode:ident )? WU ) => { mods_inner!(> $( $mode )? WindUp ) };
14157
14158    // Unknown acronym
14159    ( < ! $mode:ident $other:tt $( $rest:tt )* ) => { mods_inner!(<< $other) };
14160    ( < $other:tt $( $rest:tt )* ) => { mods_inner!(<< $other) };
14161    ( << $other:tt ) => {
14162        std::compile_error!(std::concat!("unknown mod acronym `", std::stringify!($other), "`"))
14163    };
14164
14165    // Prefixing variant name with the full type path
14166    ( > $mode:ident $name:ident ) => {
14167        $crate::macros::paste! { $crate::generated_mods::GameMod::[<$name $mode>] }
14168    };
14169    ( > $name:ident ) => {
14170        $crate::generated_mods::GameModIntermode::$name
14171    };
14172}
rosu_mods/generated_mods.rs

rosu_mods/
generated_mods.rs
