engage/generated/app/
systemcalculator.rs

1// @generated by il2cpp-bindgen — do not edit by hand.
2
3#[cfg(feature = "app-systemcalculator-types")]
4mod __types {
5    #[allow(unused_imports)] use ::unity::prelude::*;
6
7    use super::*;
8    use crate::{
9        app::{
10            calculatorcommand::{CalculatorCommand, ICalculatorCommand},
11            calculatormanager::{CalculatorManager, ICalculatorManager},
12            calculatorutil::{CalculatorUtil, ICalculatorUtil},
13            gamecalculatorcommand::{GameCalculatorCommand, IGameCalculatorCommand},
14        },
15        system::object::{IObject, Object},
16    };
17
18    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleSideDefenseCommand.md"))]
19    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleSideDefenseCommand")]
20    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
21    pub struct SystemCalculator_BattleSideDefenseCommand {}
22
23    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WalkAttributeCommand.md"))]
24    #[::unity::class(namespace = "App", name = "SystemCalculator.WalkAttributeCommand")]
25    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
26    pub struct SystemCalculator_WalkAttributeCommand {}
27
28    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_EvilAttributeCommand.md"))]
29    #[::unity::class(namespace = "App", name = "SystemCalculator.EvilAttributeCommand")]
30    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
31    pub struct SystemCalculator_EvilAttributeCommand {}
32
33    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_RodTypeBasicCommand.md"))]
34    #[::unity::class(namespace = "App", name = "SystemCalculator.RodTypeBasicCommand")]
35    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
36    pub struct SystemCalculator_RodTypeBasicCommand {}
37
38    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_MoveCostCommand.md"))]
39    #[::unity::class(namespace = "App", name = "SystemCalculator.MoveCostCommand")]
40    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
41    pub struct SystemCalculator_MoveCostCommand {}
42
43    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_GoodCommand.md"))]
44    #[::unity::class(namespace = "App", name = "SystemCalculator.GoodCommand")]
45    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
46    pub struct SystemCalculator_GoodCommand {}
47
48    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BadCommand.md"))]
49    #[::unity::class(namespace = "App", name = "SystemCalculator.BadCommand")]
50    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
51    pub struct SystemCalculator_BadCommand {}
52
53    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_HorseAttributeCommand.md"))]
54    #[::unity::class(namespace = "App", name = "SystemCalculator.HorseAttributeCommand")]
55    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
56    pub struct SystemCalculator_HorseAttributeCommand {}
57
58    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleDragonCommand.md"))]
59    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleDragonCommand")]
60    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
61    pub struct SystemCalculator_BattleStyleDragonCommand {}
62
63    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WeaponLevelDCommand.md"))]
64    #[::unity::class(namespace = "App", name = "SystemCalculator.WeaponLevelDCommand")]
65    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
66    pub struct SystemCalculator_WeaponLevelDCommand {}
67
68    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStylePranaCommand.md"))]
69    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStylePranaCommand")]
70    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
71    pub struct SystemCalculator_BattleStylePranaCommand {}
72
73    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_RodTypeHealCommand.md"))]
74    #[::unity::class(namespace = "App", name = "SystemCalculator.RodTypeHealCommand")]
75    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
76    pub struct SystemCalculator_RodTypeHealCommand {}
77
78    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator.md"))]
79    #[::unity::class(namespace = "App", name = "SystemCalculator")]
80    #[parent(crate::app::calculatormanager::CalculatorManager)]
81    pub struct SystemCalculator {}
82
83    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindSpecialCommand.md"))]
84    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindSpecialCommand")]
85    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
86    pub struct SystemCalculator_ItemKindSpecialCommand {}
87
88    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_PhaseOtherCommand.md"))]
89    #[::unity::class(namespace = "App", name = "SystemCalculator.PhaseOtherCommand")]
90    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
91    pub struct SystemCalculator_PhaseOtherCommand {}
92
93    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_SkillIndexCommand.md"))]
94    #[::unity::class(namespace = "App", name = "SystemCalculator.SkillIndexCommand")]
95    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
96    pub struct SystemCalculator_SkillIndexCommand {}
97
98    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_RodTypeInterferenceCommand.md"))]
99    #[::unity::class(namespace = "App", name = "SystemCalculator.RodTypeInterferenceCommand")]
100    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
101    pub struct SystemCalculator_RodTypeInterferenceCommand {}
102
103    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindDaggerCommand.md"))]
104    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindDaggerCommand")]
105    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
106    pub struct SystemCalculator_ItemKindDaggerCommand {}
107
108    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_DifficultyHardCommand.md"))]
109    #[::unity::class(namespace = "App", name = "SystemCalculator.DifficultyHardCommand")]
110    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
111    pub struct SystemCalculator_DifficultyHardCommand {}
112
113    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_GameModeCasualCommand.md"))]
114    #[::unity::class(namespace = "App", name = "SystemCalculator.GameModeCasualCommand")]
115    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
116    pub struct SystemCalculator_GameModeCasualCommand {}
117
118    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleSideChainDefenseCommand.md"))]
119    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleSideChainDefenseCommand")]
120    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
121    pub struct SystemCalculator_BattleSideChainDefenseCommand {}
122
123    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WeaponLevelACommand.md"))]
124    #[::unity::class(namespace = "App", name = "SystemCalculator.WeaponLevelACommand")]
125    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
126    pub struct SystemCalculator_WeaponLevelACommand {}
127
128    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ThunderAttributeCommand.md"))]
129    #[::unity::class(namespace = "App", name = "SystemCalculator.ThunderAttributeCommand")]
130    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
131    pub struct SystemCalculator_ThunderAttributeCommand {}
132
133    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleMagicCommand.md"))]
134    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleMagicCommand")]
135    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
136    pub struct SystemCalculator_BattleStyleMagicCommand {}
137
138    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WeaponLevelCCommand.md"))]
139    #[::unity::class(namespace = "App", name = "SystemCalculator.WeaponLevelCCommand")]
140    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
141    pub struct SystemCalculator_WeaponLevelCCommand {}
142
143    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleSideOffenseCommand.md"))]
144    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleSideOffenseCommand")]
145    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
146    pub struct SystemCalculator_BattleSideOffenseCommand {}
147
148    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_DarkAttributeCommand.md"))]
149    #[::unity::class(namespace = "App", name = "SystemCalculator.DarkAttributeCommand")]
150    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
151    pub struct SystemCalculator_DarkAttributeCommand {}
152
153    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleCommand.md"))]
154    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleCommand")]
155    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
156    pub struct SystemCalculator_BattleStyleCommand {}
157
158    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WeaponLevelBCommand.md"))]
159    #[::unity::class(namespace = "App", name = "SystemCalculator.WeaponLevelBCommand")]
160    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
161    pub struct SystemCalculator_WeaponLevelBCommand {}
162
163    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindSwordCommand.md"))]
164    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindSwordCommand")]
165    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
166    pub struct SystemCalculator_ItemKindSwordCommand {}
167
168    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindRodCommand.md"))]
169    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindRodCommand")]
170    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
171    pub struct SystemCalculator_ItemKindRodCommand {}
172
173    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleSideChainOffenseCommand.md"))]
174    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleSideChainOffenseCommand")]
175    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
176    pub struct SystemCalculator_BattleSideChainOffenseCommand {}
177
178    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_HeavyAttributeCommand.md"))]
179    #[::unity::class(namespace = "App", name = "SystemCalculator.HeavyAttributeCommand")]
180    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
181    pub struct SystemCalculator_HeavyAttributeCommand {}
182
183    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleFlyCommand.md"))]
184    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleFlyCommand")]
185    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
186    pub struct SystemCalculator_BattleStyleFlyCommand {}
187
188    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_GenderMaleCommand.md"))]
189    #[::unity::class(namespace = "App", name = "SystemCalculator.GenderMaleCommand")]
190    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
191    pub struct SystemCalculator_GenderMaleCommand {}
192
193    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_MagicAttributeCommand.md"))]
194    #[::unity::class(namespace = "App", name = "SystemCalculator.MagicAttributeCommand")]
195    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
196    pub struct SystemCalculator_MagicAttributeCommand {}
197
198    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_Force1stCommand.md"))]
199    #[::unity::class(namespace = "App", name = "SystemCalculator.Force1stCommand")]
200    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
201    pub struct SystemCalculator_Force1stCommand {}
202
203    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_PhaseCurrentCommand.md"))]
204    #[::unity::class(namespace = "App", name = "SystemCalculator.PhaseCurrentCommand")]
205    #[parent(crate::app::gamecalculatorcommand::GameCalculatorCommand)]
206    pub struct SystemCalculator_PhaseCurrentCommand {}
207
208    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_PersonIndexCommand.md"))]
209    #[::unity::class(namespace = "App", name = "SystemCalculator.PersonIndexCommand")]
210    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
211    pub struct SystemCalculator_PersonIndexCommand {}
212
213    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_JobIndexCommand.md"))]
214    #[::unity::class(namespace = "App", name = "SystemCalculator.JobIndexCommand")]
215    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
216    pub struct SystemCalculator_JobIndexCommand {}
217
218    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ScreenShotCommand.md"))]
219    #[::unity::class(namespace = "App", name = "SystemCalculator.ScreenShotCommand")]
220    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
221    pub struct SystemCalculator_ScreenShotCommand {}
222
223    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemIndexCommand.md"))]
224    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemIndexCommand")]
225    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
226    pub struct SystemCalculator_ItemIndexCommand {}
227
228    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_JobRankHighCommand.md"))]
229    #[::unity::class(namespace = "App", name = "SystemCalculator.JobRankHighCommand")]
230    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
231    pub struct SystemCalculator_JobRankHighCommand {}
232
233    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_Force3rdCommand.md"))]
234    #[::unity::class(namespace = "App", name = "SystemCalculator.Force3rdCommand")]
235    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
236    pub struct SystemCalculator_Force3rdCommand {}
237
238    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_DifficultyLunaticCommand.md"))]
239    #[::unity::class(namespace = "App", name = "SystemCalculator.DifficultyLunaticCommand")]
240    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
241    pub struct SystemCalculator_DifficultyLunaticCommand {}
242
243    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_NoneAttributeCommand.md"))]
244    #[::unity::class(namespace = "App", name = "SystemCalculator.NoneAttributeCommand")]
245    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
246    pub struct SystemCalculator_NoneAttributeCommand {}
247
248    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_JobRankLowCommand.md"))]
249    #[::unity::class(namespace = "App", name = "SystemCalculator.JobRankLowCommand")]
250    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
251    pub struct SystemCalculator_JobRankLowCommand {}
252
253    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_IceAttributeCommand.md"))]
254    #[::unity::class(namespace = "App", name = "SystemCalculator.IceAttributeCommand")]
255    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
256    pub struct SystemCalculator_IceAttributeCommand {}
257
258    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_PhysicalAttributeCommand.md"))]
259    #[::unity::class(namespace = "App", name = "SystemCalculator.PhysicalAttributeCommand")]
260    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
261    pub struct SystemCalculator_PhysicalAttributeCommand {}
262
263    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WindAttributeCommand.md"))]
264    #[::unity::class(namespace = "App", name = "SystemCalculator.WindAttributeCommand")]
265    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
266    pub struct SystemCalculator_WindAttributeCommand {}
267
268    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_LightAttributeCommand.md"))]
269    #[::unity::class(namespace = "App", name = "SystemCalculator.LightAttributeCommand")]
270    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
271    pub struct SystemCalculator_LightAttributeCommand {}
272
273    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_VsyncCommand.md"))]
274    #[::unity::class(namespace = "App", name = "SystemCalculator.VsyncCommand")]
275    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
276    pub struct SystemCalculator_VsyncCommand {}
277
278    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleCooperationCommand.md"))]
279    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleCooperationCommand")]
280    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
281    pub struct SystemCalculator_BattleStyleCooperationCommand {}
282
283    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindFistCommand.md"))]
284    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindFistCommand")]
285    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
286    pub struct SystemCalculator_ItemKindFistCommand {}
287
288    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindLanceCommand.md"))]
289    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindLanceCommand")]
290    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
291    pub struct SystemCalculator_ItemKindLanceCommand {}
292
293    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_MorphAttributeCommand.md"))]
294    #[::unity::class(namespace = "App", name = "SystemCalculator.MorphAttributeCommand")]
295    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
296    pub struct SystemCalculator_MorphAttributeCommand {}
297
298    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleHeavyCommand.md"))]
299    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleHeavyCommand")]
300    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
301    pub struct SystemCalculator_BattleStyleHeavyCommand {}
302
303    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindBowCommand.md"))]
304    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindBowCommand")]
305    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
306    pub struct SystemCalculator_ItemKindBowCommand {}
307
308    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindMagicCommand.md"))]
309    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindMagicCommand")]
310    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
311    pub struct SystemCalculator_ItemKindMagicCommand {}
312
313    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_FireAttributeCommand.md"))]
314    #[::unity::class(namespace = "App", name = "SystemCalculator.FireAttributeCommand")]
315    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
316    pub struct SystemCalculator_FireAttributeCommand {}
317
318    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_ItemKindAxeCommand.md"))]
319    #[::unity::class(namespace = "App", name = "SystemCalculator.ItemKindAxeCommand")]
320    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
321    pub struct SystemCalculator_ItemKindAxeCommand {}
322
323    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_DifficultyNormalCommand.md"))]
324    #[::unity::class(namespace = "App", name = "SystemCalculator.DifficultyNormalCommand")]
325    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
326    pub struct SystemCalculator_DifficultyNormalCommand {}
327
328    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_GenderFemaleCommand.md"))]
329    #[::unity::class(namespace = "App", name = "SystemCalculator.GenderFemaleCommand")]
330    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
331    pub struct SystemCalculator_GenderFemaleCommand {}
332
333    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleCovertCommand.md"))]
334    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleCovertCommand")]
335    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
336    pub struct SystemCalculator_BattleStyleCovertCommand {}
337
338    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_Force2ndCommand.md"))]
339    #[::unity::class(namespace = "App", name = "SystemCalculator.Force2ndCommand")]
340    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
341    pub struct SystemCalculator_Force2ndCommand {}
342
343    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_DragonAttributeCommand.md"))]
344    #[::unity::class(namespace = "App", name = "SystemCalculator.DragonAttributeCommand")]
345    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
346    pub struct SystemCalculator_DragonAttributeCommand {}
347
348    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_BattleStyleHorseCommand.md"))]
349    #[::unity::class(namespace = "App", name = "SystemCalculator.BattleStyleHorseCommand")]
350    #[parent(crate::app::systemcalculator::SystemCalculator_BattleStyleCommand)]
351    pub struct SystemCalculator_BattleStyleHorseCommand {}
352
353    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_WeaponLevelSCommand.md"))]
354    #[::unity::class(namespace = "App", name = "SystemCalculator.WeaponLevelSCommand")]
355    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
356    pub struct SystemCalculator_WeaponLevelSCommand {}
357
358    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_GameModeClassicCommand.md"))]
359    #[::unity::class(namespace = "App", name = "SystemCalculator.GameModeClassicCommand")]
360    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
361    pub struct SystemCalculator_GameModeClassicCommand {}
362
363    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/systemcalculator/SystemCalculator_FlyAttributeCommand.md"))]
364    #[::unity::class(namespace = "App", name = "SystemCalculator.FlyAttributeCommand")]
365    #[parent(crate::app::calculatorcommand::CalculatorCommand)]
366    pub struct SystemCalculator_FlyAttributeCommand {}
367}
368
369#[cfg(feature = "app-systemcalculator-types")]
370pub use __types::*;
371
372#[cfg(feature = "app-systemcalculator")]
373pub trait ISystemCalculator_BattleSideDefenseCommandMethods: ISystemCalculator_BattleSideDefenseCommand {
374    #[doc = "`get_Name()` overload"]
375    fn get_name(self) -> ::unity::Il2CppString {
376        unsafe {
377            let __receiver = <SystemCalculator_BattleSideDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
378                <Self as ::unity::SystemObject>::as_instance(self),
379            );
380            {
381                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
382                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
383                    panic!(
384                        "unity: virtual slot {}
385 out of range (vtable len {}
386) on the runtime class behind {}
387 (method `{}
388`)",
389                        4usize,
390                        __vt.len(),
391                        <SystemCalculator_BattleSideDefenseCommand as ::unity::ClassIdentity>::NAME,
392                        "get_Name",
393                    )
394                });
395                let __inner: extern "C" fn(SystemCalculator_BattleSideDefenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
396                    ::core::mem::transmute(__vi.method_ptr);
397                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
398                __inner(__receiver, __mi)
399            }
400        }
401    }
402    #[doc = "`Get()` overload"]
403    fn get(self) -> f32 {
404        unsafe {
405            let __receiver = <SystemCalculator_BattleSideDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
406                <Self as ::unity::SystemObject>::as_instance(self),
407            );
408            {
409                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
410                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
411                    panic!(
412                        "unity: virtual slot {}
413 out of range (vtable len {}
414) on the runtime class behind {}
415 (method `{}
416`)",
417                        9usize,
418                        __vt.len(),
419                        <SystemCalculator_BattleSideDefenseCommand as ::unity::ClassIdentity>::NAME,
420                        "Get",
421                    )
422                });
423                let __inner: extern "C" fn(SystemCalculator_BattleSideDefenseCommand, ::unity::OptionalMethod) -> f32 =
424                    ::core::mem::transmute(__vi.method_ptr);
425                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
426                __inner(__receiver, __mi)
427            }
428        }
429    }
430    #[doc = "`.ctor()` overload"]
431    fn ctor(self) -> () {
432        unsafe {
433            let __receiver = <SystemCalculator_BattleSideDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
434                <Self as ::unity::SystemObject>::as_instance(self),
435            );
436            ::unity::il2cpp_call!((::unity::module_base()+0x21f7fc0usize)as*mut u8,();
437(SystemCalculator_BattleSideDefenseCommand)__receiver)
438        }
439    }
440}
441
442#[cfg(feature = "app-systemcalculator")]
443impl<__T: ISystemCalculator_BattleSideDefenseCommand> ISystemCalculator_BattleSideDefenseCommandMethods for __T {}
444
445#[cfg(feature = "app-systemcalculator")]
446impl SystemCalculator_BattleSideDefenseCommand {
447    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
448        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
449    }
450
451    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
452        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
453    }
454
455    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
456        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
457    }
458}
459
460#[cfg(feature = "app-systemcalculator")]
461impl SystemCalculator_BattleSideDefenseCommand {
462    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideDefenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
463    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
464        let __mi = Self::get_name_method_info();
465        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
466        __inner(this.into(), ::core::option::Option::None)
467    }
468
469    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideDefenseCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
470    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
471        let __mi = Self::get_method_info();
472        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
473        __inner(this.into(), ::core::option::Option::None)
474    }
475}
476
477#[cfg(feature = "app-systemcalculator")]
478impl SystemCalculator_BattleSideDefenseCommand {
479    #[doc = "`.ctor()` — no args"]
480    pub fn new() -> Self {
481        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
482            panic!(
483                "{}
484::{}
485 failed to instantiate",
486                ::core::stringify!(SystemCalculator_BattleSideDefenseCommand),
487                ::core::stringify!(new),
488            )
489        });
490        <Self as ISystemCalculator_BattleSideDefenseCommandMethods>::ctor(this);
491        this
492    }
493}
494
495#[cfg(feature = "app-systemcalculator")]
496pub trait ISystemCalculator_WalkAttributeCommandMethods: ISystemCalculator_WalkAttributeCommand {
497    #[doc = "`get_Name()` overload"]
498    fn get_name(self) -> ::unity::Il2CppString {
499        unsafe {
500            let __receiver = <SystemCalculator_WalkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
501                <Self as ::unity::SystemObject>::as_instance(self),
502            );
503            {
504                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
505                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
506                    panic!(
507                        "unity: virtual slot {}
508 out of range (vtable len {}
509) on the runtime class behind {}
510 (method `{}
511`)",
512                        4usize,
513                        __vt.len(),
514                        <SystemCalculator_WalkAttributeCommand as ::unity::ClassIdentity>::NAME,
515                        "get_Name",
516                    )
517                });
518                let __inner: extern "C" fn(SystemCalculator_WalkAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
519                    ::core::mem::transmute(__vi.method_ptr);
520                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
521                __inner(__receiver, __mi)
522            }
523        }
524    }
525    #[doc = "`Get()` overload"]
526    fn get(self) -> f32 {
527        unsafe {
528            let __receiver = <SystemCalculator_WalkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
529                <Self as ::unity::SystemObject>::as_instance(self),
530            );
531            {
532                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
533                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
534                    panic!(
535                        "unity: virtual slot {}
536 out of range (vtable len {}
537) on the runtime class behind {}
538 (method `{}
539`)",
540                        9usize,
541                        __vt.len(),
542                        <SystemCalculator_WalkAttributeCommand as ::unity::ClassIdentity>::NAME,
543                        "Get",
544                    )
545                });
546                let __inner: extern "C" fn(SystemCalculator_WalkAttributeCommand, ::unity::OptionalMethod) -> f32 =
547                    ::core::mem::transmute(__vi.method_ptr);
548                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
549                __inner(__receiver, __mi)
550            }
551        }
552    }
553    #[doc = "`.ctor()` overload"]
554    fn ctor(self) -> () {
555        unsafe {
556            let __receiver = <SystemCalculator_WalkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
557                <Self as ::unity::SystemObject>::as_instance(self),
558            );
559            ::unity::il2cpp_call!((::unity::module_base()+0x21f9c70usize)as*mut u8,();
560(SystemCalculator_WalkAttributeCommand)__receiver)
561        }
562    }
563}
564
565#[cfg(feature = "app-systemcalculator")]
566impl<__T: ISystemCalculator_WalkAttributeCommand> ISystemCalculator_WalkAttributeCommandMethods for __T {}
567
568#[cfg(feature = "app-systemcalculator")]
569impl SystemCalculator_WalkAttributeCommand {
570    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
571        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
572    }
573
574    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
575        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
576    }
577
578    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
579        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
580    }
581}
582
583#[cfg(feature = "app-systemcalculator")]
584impl SystemCalculator_WalkAttributeCommand {
585    #[doc = "Direct (non-virtual) call to `SystemCalculator_WalkAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
586    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
587        let __mi = Self::get_name_method_info();
588        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
589        __inner(this.into(), ::core::option::Option::None)
590    }
591
592    #[doc = "Direct (non-virtual) call to `SystemCalculator_WalkAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
593    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
594        let __mi = Self::get_method_info();
595        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
596        __inner(this.into(), ::core::option::Option::None)
597    }
598}
599
600#[cfg(feature = "app-systemcalculator")]
601impl SystemCalculator_WalkAttributeCommand {
602    #[doc = "`.ctor()` — no args"]
603    pub fn new() -> Self {
604        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
605            panic!(
606                "{}
607::{}
608 failed to instantiate",
609                ::core::stringify!(SystemCalculator_WalkAttributeCommand),
610                ::core::stringify!(new),
611            )
612        });
613        <Self as ISystemCalculator_WalkAttributeCommandMethods>::ctor(this);
614        this
615    }
616}
617
618#[cfg(feature = "app-systemcalculator")]
619pub trait ISystemCalculator_EvilAttributeCommandMethods: ISystemCalculator_EvilAttributeCommand {
620    #[doc = "`get_Name()` overload"]
621    fn get_name(self) -> ::unity::Il2CppString {
622        unsafe {
623            let __receiver = <SystemCalculator_EvilAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
624                <Self as ::unity::SystemObject>::as_instance(self),
625            );
626            {
627                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
628                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
629                    panic!(
630                        "unity: virtual slot {}
631 out of range (vtable len {}
632) on the runtime class behind {}
633 (method `{}
634`)",
635                        4usize,
636                        __vt.len(),
637                        <SystemCalculator_EvilAttributeCommand as ::unity::ClassIdentity>::NAME,
638                        "get_Name",
639                    )
640                });
641                let __inner: extern "C" fn(SystemCalculator_EvilAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
642                    ::core::mem::transmute(__vi.method_ptr);
643                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
644                __inner(__receiver, __mi)
645            }
646        }
647    }
648    #[doc = "`Get()` overload"]
649    fn get(self) -> f32 {
650        unsafe {
651            let __receiver = <SystemCalculator_EvilAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
652                <Self as ::unity::SystemObject>::as_instance(self),
653            );
654            {
655                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
656                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
657                    panic!(
658                        "unity: virtual slot {}
659 out of range (vtable len {}
660) on the runtime class behind {}
661 (method `{}
662`)",
663                        9usize,
664                        __vt.len(),
665                        <SystemCalculator_EvilAttributeCommand as ::unity::ClassIdentity>::NAME,
666                        "Get",
667                    )
668                });
669                let __inner: extern "C" fn(SystemCalculator_EvilAttributeCommand, ::unity::OptionalMethod) -> f32 =
670                    ::core::mem::transmute(__vi.method_ptr);
671                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
672                __inner(__receiver, __mi)
673            }
674        }
675    }
676    #[doc = "`.ctor()` overload"]
677    fn ctor(self) -> () {
678        unsafe {
679            let __receiver = <SystemCalculator_EvilAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
680                <Self as ::unity::SystemObject>::as_instance(self),
681            );
682            ::unity::il2cpp_call!((::unity::module_base()+0x21f84a0usize)as*mut u8,();
683(SystemCalculator_EvilAttributeCommand)__receiver)
684        }
685    }
686}
687
688#[cfg(feature = "app-systemcalculator")]
689impl<__T: ISystemCalculator_EvilAttributeCommand> ISystemCalculator_EvilAttributeCommandMethods for __T {}
690
691#[cfg(feature = "app-systemcalculator")]
692impl SystemCalculator_EvilAttributeCommand {
693    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
694        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
695    }
696
697    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
698        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
699    }
700
701    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
702        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
703    }
704}
705
706#[cfg(feature = "app-systemcalculator")]
707impl SystemCalculator_EvilAttributeCommand {
708    #[doc = "Direct (non-virtual) call to `SystemCalculator_EvilAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
709    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
710        let __mi = Self::get_name_method_info();
711        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
712        __inner(this.into(), ::core::option::Option::None)
713    }
714
715    #[doc = "Direct (non-virtual) call to `SystemCalculator_EvilAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
716    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
717        let __mi = Self::get_method_info();
718        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
719        __inner(this.into(), ::core::option::Option::None)
720    }
721}
722
723#[cfg(feature = "app-systemcalculator")]
724impl SystemCalculator_EvilAttributeCommand {
725    #[doc = "`.ctor()` — no args"]
726    pub fn new() -> Self {
727        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
728            panic!(
729                "{}
730::{}
731 failed to instantiate",
732                ::core::stringify!(SystemCalculator_EvilAttributeCommand),
733                ::core::stringify!(new),
734            )
735        });
736        <Self as ISystemCalculator_EvilAttributeCommandMethods>::ctor(this);
737        this
738    }
739}
740
741#[cfg(feature = "app-systemcalculator")]
742pub trait ISystemCalculator_RodTypeBasicCommandMethods: ISystemCalculator_RodTypeBasicCommand {
743    #[doc = "`get_Name()` overload"]
744    fn get_name(self) -> ::unity::Il2CppString {
745        unsafe {
746            let __receiver = <SystemCalculator_RodTypeBasicCommand as ::unity::FromIlInstance>::from_il_instance(
747                <Self as ::unity::SystemObject>::as_instance(self),
748            );
749            {
750                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
751                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
752                    panic!(
753                        "unity: virtual slot {}
754 out of range (vtable len {}
755) on the runtime class behind {}
756 (method `{}
757`)",
758                        4usize,
759                        __vt.len(),
760                        <SystemCalculator_RodTypeBasicCommand as ::unity::ClassIdentity>::NAME,
761                        "get_Name",
762                    )
763                });
764                let __inner: extern "C" fn(SystemCalculator_RodTypeBasicCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
765                    ::core::mem::transmute(__vi.method_ptr);
766                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
767                __inner(__receiver, __mi)
768            }
769        }
770    }
771    #[doc = "`Get()` overload"]
772    fn get(self) -> f32 {
773        unsafe {
774            let __receiver = <SystemCalculator_RodTypeBasicCommand as ::unity::FromIlInstance>::from_il_instance(
775                <Self as ::unity::SystemObject>::as_instance(self),
776            );
777            {
778                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
779                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
780                    panic!(
781                        "unity: virtual slot {}
782 out of range (vtable len {}
783) on the runtime class behind {}
784 (method `{}
785`)",
786                        9usize,
787                        __vt.len(),
788                        <SystemCalculator_RodTypeBasicCommand as ::unity::ClassIdentity>::NAME,
789                        "Get",
790                    )
791                });
792                let __inner: extern "C" fn(SystemCalculator_RodTypeBasicCommand, ::unity::OptionalMethod) -> f32 =
793                    ::core::mem::transmute(__vi.method_ptr);
794                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
795                __inner(__receiver, __mi)
796            }
797        }
798    }
799    #[doc = "`.ctor()` overload"]
800    fn ctor(self) -> () {
801        unsafe {
802            let __receiver = <SystemCalculator_RodTypeBasicCommand as ::unity::FromIlInstance>::from_il_instance(
803                <Self as ::unity::SystemObject>::as_instance(self),
804            );
805            ::unity::il2cpp_call!((::unity::module_base()+0x21f97b0usize)as*mut u8,();
806(SystemCalculator_RodTypeBasicCommand)__receiver)
807        }
808    }
809}
810
811#[cfg(feature = "app-systemcalculator")]
812impl<__T: ISystemCalculator_RodTypeBasicCommand> ISystemCalculator_RodTypeBasicCommandMethods for __T {}
813
814#[cfg(feature = "app-systemcalculator")]
815impl SystemCalculator_RodTypeBasicCommand {
816    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
817        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
818    }
819
820    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
821        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
822    }
823
824    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
825        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
826    }
827}
828
829#[cfg(feature = "app-systemcalculator")]
830impl SystemCalculator_RodTypeBasicCommand {
831    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeBasicCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
832    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
833        let __mi = Self::get_name_method_info();
834        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
835        __inner(this.into(), ::core::option::Option::None)
836    }
837
838    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeBasicCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
839    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
840        let __mi = Self::get_method_info();
841        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
842        __inner(this.into(), ::core::option::Option::None)
843    }
844}
845
846#[cfg(feature = "app-systemcalculator")]
847impl SystemCalculator_RodTypeBasicCommand {
848    #[doc = "`.ctor()` — no args"]
849    pub fn new() -> Self {
850        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
851            panic!(
852                "{}
853::{}
854 failed to instantiate",
855                ::core::stringify!(SystemCalculator_RodTypeBasicCommand),
856                ::core::stringify!(new),
857            )
858        });
859        <Self as ISystemCalculator_RodTypeBasicCommandMethods>::ctor(this);
860        this
861    }
862}
863
864#[cfg(feature = "app-systemcalculator")]
865pub trait ISystemCalculator_MoveCostCommandMethods: ISystemCalculator_MoveCostCommand {
866    #[doc = "`get_Name()` overload"]
867    fn get_name(self) -> ::unity::Il2CppString {
868        unsafe {
869            let __receiver =
870                <SystemCalculator_MoveCostCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
871            {
872                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
873                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
874                    panic!(
875                        "unity: virtual slot {}
876 out of range (vtable len {}
877) on the runtime class behind {}
878 (method `{}
879`)",
880                        4usize,
881                        __vt.len(),
882                        <SystemCalculator_MoveCostCommand as ::unity::ClassIdentity>::NAME,
883                        "get_Name",
884                    )
885                });
886                let __inner: extern "C" fn(SystemCalculator_MoveCostCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
887                    ::core::mem::transmute(__vi.method_ptr);
888                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
889                __inner(__receiver, __mi)
890            }
891        }
892    }
893    #[doc = "`get_ArgNum()` overload"]
894    fn get_arg_num(self) -> i32 {
895        unsafe {
896            let __receiver =
897                <SystemCalculator_MoveCostCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
898            {
899                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
900                let __vi = *__vt.get(7usize).unwrap_or_else(|| {
901                    panic!(
902                        "unity: virtual slot {}
903 out of range (vtable len {}
904) on the runtime class behind {}
905 (method `{}
906`)",
907                        7usize,
908                        __vt.len(),
909                        <SystemCalculator_MoveCostCommand as ::unity::ClassIdentity>::NAME,
910                        "get_ArgNum",
911                    )
912                });
913                let __inner: extern "C" fn(SystemCalculator_MoveCostCommand, ::unity::OptionalMethod) -> i32 =
914                    ::core::mem::transmute(__vi.method_ptr);
915                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
916                __inner(__receiver, __mi)
917            }
918        }
919    }
920    #[doc = "`Func(crate::system::collections::generic::list_1::List_1<f32>)` overload"]
921    fn func(self, args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>) -> f32 {
922        unsafe {
923            let __receiver =
924                <SystemCalculator_MoveCostCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
925            {
926                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
927                let __vi = *__vt.get(24usize).unwrap_or_else(|| {
928                    panic!(
929                        "unity: virtual slot {}
930 out of range (vtable len {}
931) on the runtime class behind {}
932 (method `{}
933`)",
934                        24usize,
935                        __vt.len(),
936                        <SystemCalculator_MoveCostCommand as ::unity::ClassIdentity>::NAME,
937                        "Func",
938                    )
939                });
940                let __inner: extern "C" fn(
941                    SystemCalculator_MoveCostCommand,
942                    crate::system::collections::generic::list_1::List_1<f32>,
943                    ::unity::OptionalMethod,
944                ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
945                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
946                __inner(__receiver, ::core::convert::Into::into(args), __mi)
947            }
948        }
949    }
950    #[doc = "`.ctor()` overload"]
951    fn ctor(self) -> () {
952        unsafe {
953            let __receiver =
954                <SystemCalculator_MoveCostCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
955            ::unity::il2cpp_call!((::unity::module_base()+0x21f9490usize)as*mut u8,();
956(SystemCalculator_MoveCostCommand)__receiver)
957        }
958    }
959}
960
961#[cfg(feature = "app-systemcalculator")]
962impl<__T: ISystemCalculator_MoveCostCommand> ISystemCalculator_MoveCostCommandMethods for __T {}
963
964#[cfg(feature = "app-systemcalculator")]
965impl SystemCalculator_MoveCostCommand {
966    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
967        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
968    }
969
970    pub fn get_arg_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
971        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
972    }
973
974    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
976    }
977
978    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
980    }
981}
982
983#[cfg(feature = "app-systemcalculator")]
984impl SystemCalculator_MoveCostCommand {
985    #[doc = "Direct (non-virtual) call to `SystemCalculator_MoveCostCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
986    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
987        let __mi = Self::get_name_method_info();
988        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
989        __inner(this.into(), ::core::option::Option::None)
990    }
991
992    #[doc = "Direct (non-virtual) call to `SystemCalculator_MoveCostCommand`'s own `get_ArgNum`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
993    pub unsafe fn get_arg_num(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
994        let __mi = Self::get_arg_num_method_info();
995        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
996        __inner(this.into(), ::core::option::Option::None)
997    }
998
999    #[doc = "Direct (non-virtual) call to `SystemCalculator_MoveCostCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1000    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>, args: crate::system::collections::generic::list_1::List_1<f32>) -> f32 {
1001        let __mi = Self::func_method_info();
1002        let __inner: extern "C" fn(::unity::IlInstance, crate::system::collections::generic::list_1::List_1<f32>, ::unity::OptionalMethod) -> f32 =
1003            ::core::mem::transmute(__mi.method_ptr);
1004        __inner(this.into(), args, ::core::option::Option::None)
1005    }
1006}
1007
1008#[cfg(feature = "app-systemcalculator")]
1009impl SystemCalculator_MoveCostCommand {
1010    #[doc = "`.ctor()` — no args"]
1011    pub fn new() -> Self {
1012        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1013            panic!(
1014                "{}
1015::{}
1016 failed to instantiate",
1017                ::core::stringify!(SystemCalculator_MoveCostCommand),
1018                ::core::stringify!(new),
1019            )
1020        });
1021        <Self as ISystemCalculator_MoveCostCommandMethods>::ctor(this);
1022        this
1023    }
1024}
1025
1026#[cfg(feature = "app-systemcalculator")]
1027pub trait ISystemCalculator_GoodCommandMethods: ISystemCalculator_GoodCommand {
1028    #[doc = "`get_Name()` overload"]
1029    fn get_name(self) -> ::unity::Il2CppString {
1030        unsafe {
1031            let __receiver =
1032                <SystemCalculator_GoodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1033            {
1034                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1035                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1036                    panic!(
1037                        "unity: virtual slot {}
1038 out of range (vtable len {}
1039) on the runtime class behind {}
1040 (method `{}
1041`)",
1042                        4usize,
1043                        __vt.len(),
1044                        <SystemCalculator_GoodCommand as ::unity::ClassIdentity>::NAME,
1045                        "get_Name",
1046                    )
1047                });
1048                let __inner: extern "C" fn(SystemCalculator_GoodCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1049                    ::core::mem::transmute(__vi.method_ptr);
1050                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1051                __inner(__receiver, __mi)
1052            }
1053        }
1054    }
1055    #[doc = "`Get()` overload"]
1056    fn get(self) -> f32 {
1057        unsafe {
1058            let __receiver =
1059                <SystemCalculator_GoodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1060            {
1061                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1062                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1063                    panic!(
1064                        "unity: virtual slot {}
1065 out of range (vtable len {}
1066) on the runtime class behind {}
1067 (method `{}
1068`)",
1069                        9usize,
1070                        __vt.len(),
1071                        <SystemCalculator_GoodCommand as ::unity::ClassIdentity>::NAME,
1072                        "Get",
1073                    )
1074                });
1075                let __inner: extern "C" fn(SystemCalculator_GoodCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1076                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1077                __inner(__receiver, __mi)
1078            }
1079        }
1080    }
1081    #[doc = "`.ctor()` overload"]
1082    fn ctor(self) -> () {
1083        unsafe {
1084            let __receiver =
1085                <SystemCalculator_GoodCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1086            ::unity::il2cpp_call!((::unity::module_base()+0x21f8900usize)as*mut u8,();
1087(SystemCalculator_GoodCommand)__receiver)
1088        }
1089    }
1090}
1091
1092#[cfg(feature = "app-systemcalculator")]
1093impl<__T: ISystemCalculator_GoodCommand> ISystemCalculator_GoodCommandMethods for __T {}
1094
1095#[cfg(feature = "app-systemcalculator")]
1096impl SystemCalculator_GoodCommand {
1097    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1098        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1099    }
1100
1101    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1102        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1103    }
1104
1105    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1106        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1107    }
1108}
1109
1110#[cfg(feature = "app-systemcalculator")]
1111impl SystemCalculator_GoodCommand {
1112    #[doc = "Direct (non-virtual) call to `SystemCalculator_GoodCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1113    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1114        let __mi = Self::get_name_method_info();
1115        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1116        __inner(this.into(), ::core::option::Option::None)
1117    }
1118
1119    #[doc = "Direct (non-virtual) call to `SystemCalculator_GoodCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1120    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1121        let __mi = Self::get_method_info();
1122        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1123        __inner(this.into(), ::core::option::Option::None)
1124    }
1125}
1126
1127#[cfg(feature = "app-systemcalculator")]
1128impl SystemCalculator_GoodCommand {
1129    #[doc = "`.ctor()` — no args"]
1130    pub fn new() -> Self {
1131        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1132            panic!(
1133                "{}
1134::{}
1135 failed to instantiate",
1136                ::core::stringify!(SystemCalculator_GoodCommand),
1137                ::core::stringify!(new),
1138            )
1139        });
1140        <Self as ISystemCalculator_GoodCommandMethods>::ctor(this);
1141        this
1142    }
1143}
1144
1145#[cfg(feature = "app-systemcalculator")]
1146pub trait ISystemCalculator_BadCommandMethods: ISystemCalculator_BadCommand {
1147    #[doc = "`get_Name()` overload"]
1148    fn get_name(self) -> ::unity::Il2CppString {
1149        unsafe {
1150            let __receiver =
1151                <SystemCalculator_BadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1152            {
1153                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1154                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1155                    panic!(
1156                        "unity: virtual slot {}
1157 out of range (vtable len {}
1158) on the runtime class behind {}
1159 (method `{}
1160`)",
1161                        4usize,
1162                        __vt.len(),
1163                        <SystemCalculator_BadCommand as ::unity::ClassIdentity>::NAME,
1164                        "get_Name",
1165                    )
1166                });
1167                let __inner: extern "C" fn(SystemCalculator_BadCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1168                    ::core::mem::transmute(__vi.method_ptr);
1169                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1170                __inner(__receiver, __mi)
1171            }
1172        }
1173    }
1174    #[doc = "`Get()` overload"]
1175    fn get(self) -> f32 {
1176        unsafe {
1177            let __receiver =
1178                <SystemCalculator_BadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1179            {
1180                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1181                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1182                    panic!(
1183                        "unity: virtual slot {}
1184 out of range (vtable len {}
1185) on the runtime class behind {}
1186 (method `{}
1187`)",
1188                        9usize,
1189                        __vt.len(),
1190                        <SystemCalculator_BadCommand as ::unity::ClassIdentity>::NAME,
1191                        "Get",
1192                    )
1193                });
1194                let __inner: extern "C" fn(SystemCalculator_BadCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1195                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1196                __inner(__receiver, __mi)
1197            }
1198        }
1199    }
1200    #[doc = "`.ctor()` overload"]
1201    fn ctor(self) -> () {
1202        unsafe {
1203            let __receiver =
1204                <SystemCalculator_BadCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1205            ::unity::il2cpp_call!((::unity::module_base()+0x21f7e70usize)as*mut u8,();
1206(SystemCalculator_BadCommand)__receiver)
1207        }
1208    }
1209}
1210
1211#[cfg(feature = "app-systemcalculator")]
1212impl<__T: ISystemCalculator_BadCommand> ISystemCalculator_BadCommandMethods for __T {}
1213
1214#[cfg(feature = "app-systemcalculator")]
1215impl SystemCalculator_BadCommand {
1216    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1217        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1218    }
1219
1220    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1221        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1222    }
1223
1224    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1225        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1226    }
1227}
1228
1229#[cfg(feature = "app-systemcalculator")]
1230impl SystemCalculator_BadCommand {
1231    #[doc = "Direct (non-virtual) call to `SystemCalculator_BadCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1232    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1233        let __mi = Self::get_name_method_info();
1234        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1235        __inner(this.into(), ::core::option::Option::None)
1236    }
1237
1238    #[doc = "Direct (non-virtual) call to `SystemCalculator_BadCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1239    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1240        let __mi = Self::get_method_info();
1241        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1242        __inner(this.into(), ::core::option::Option::None)
1243    }
1244}
1245
1246#[cfg(feature = "app-systemcalculator")]
1247impl SystemCalculator_BadCommand {
1248    #[doc = "`.ctor()` — no args"]
1249    pub fn new() -> Self {
1250        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1251            panic!(
1252                "{}
1253::{}
1254 failed to instantiate",
1255                ::core::stringify!(SystemCalculator_BadCommand),
1256                ::core::stringify!(new),
1257            )
1258        });
1259        <Self as ISystemCalculator_BadCommandMethods>::ctor(this);
1260        this
1261    }
1262}
1263
1264#[cfg(feature = "app-systemcalculator")]
1265pub trait ISystemCalculator_HorseAttributeCommandMethods: ISystemCalculator_HorseAttributeCommand {
1266    #[doc = "`get_Name()` overload"]
1267    fn get_name(self) -> ::unity::Il2CppString {
1268        unsafe {
1269            let __receiver = <SystemCalculator_HorseAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
1270                <Self as ::unity::SystemObject>::as_instance(self),
1271            );
1272            {
1273                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1274                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1275                    panic!(
1276                        "unity: virtual slot {}
1277 out of range (vtable len {}
1278) on the runtime class behind {}
1279 (method `{}
1280`)",
1281                        4usize,
1282                        __vt.len(),
1283                        <SystemCalculator_HorseAttributeCommand as ::unity::ClassIdentity>::NAME,
1284                        "get_Name",
1285                    )
1286                });
1287                let __inner: extern "C" fn(SystemCalculator_HorseAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1288                    ::core::mem::transmute(__vi.method_ptr);
1289                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1290                __inner(__receiver, __mi)
1291            }
1292        }
1293    }
1294    #[doc = "`Get()` overload"]
1295    fn get(self) -> f32 {
1296        unsafe {
1297            let __receiver = <SystemCalculator_HorseAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
1298                <Self as ::unity::SystemObject>::as_instance(self),
1299            );
1300            {
1301                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1302                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1303                    panic!(
1304                        "unity: virtual slot {}
1305 out of range (vtable len {}
1306) on the runtime class behind {}
1307 (method `{}
1308`)",
1309                        9usize,
1310                        __vt.len(),
1311                        <SystemCalculator_HorseAttributeCommand as ::unity::ClassIdentity>::NAME,
1312                        "Get",
1313                    )
1314                });
1315                let __inner: extern "C" fn(SystemCalculator_HorseAttributeCommand, ::unity::OptionalMethod) -> f32 =
1316                    ::core::mem::transmute(__vi.method_ptr);
1317                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1318                __inner(__receiver, __mi)
1319            }
1320        }
1321    }
1322    #[doc = "`.ctor()` overload"]
1323    fn ctor(self) -> () {
1324        unsafe {
1325            let __receiver = <SystemCalculator_HorseAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
1326                <Self as ::unity::SystemObject>::as_instance(self),
1327            );
1328            ::unity::il2cpp_call!((::unity::module_base()+0x21f89e0usize)as*mut u8,();
1329(SystemCalculator_HorseAttributeCommand)__receiver)
1330        }
1331    }
1332}
1333
1334#[cfg(feature = "app-systemcalculator")]
1335impl<__T: ISystemCalculator_HorseAttributeCommand> ISystemCalculator_HorseAttributeCommandMethods for __T {}
1336
1337#[cfg(feature = "app-systemcalculator")]
1338impl SystemCalculator_HorseAttributeCommand {
1339    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1340        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1341    }
1342
1343    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1344        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1345    }
1346
1347    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1348        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1349    }
1350}
1351
1352#[cfg(feature = "app-systemcalculator")]
1353impl SystemCalculator_HorseAttributeCommand {
1354    #[doc = "Direct (non-virtual) call to `SystemCalculator_HorseAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1355    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1356        let __mi = Self::get_name_method_info();
1357        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1358        __inner(this.into(), ::core::option::Option::None)
1359    }
1360
1361    #[doc = "Direct (non-virtual) call to `SystemCalculator_HorseAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1362    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1363        let __mi = Self::get_method_info();
1364        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1365        __inner(this.into(), ::core::option::Option::None)
1366    }
1367}
1368
1369#[cfg(feature = "app-systemcalculator")]
1370impl SystemCalculator_HorseAttributeCommand {
1371    #[doc = "`.ctor()` — no args"]
1372    pub fn new() -> Self {
1373        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1374            panic!(
1375                "{}
1376::{}
1377 failed to instantiate",
1378                ::core::stringify!(SystemCalculator_HorseAttributeCommand),
1379                ::core::stringify!(new),
1380            )
1381        });
1382        <Self as ISystemCalculator_HorseAttributeCommandMethods>::ctor(this);
1383        this
1384    }
1385}
1386
1387#[cfg(feature = "app-systemcalculator")]
1388pub trait ISystemCalculator_BattleStyleDragonCommandMethods: ISystemCalculator_BattleStyleDragonCommand {
1389    #[doc = "`get_Style()` overload"]
1390    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
1391        unsafe {
1392            let __receiver = <SystemCalculator_BattleStyleDragonCommand as ::unity::FromIlInstance>::from_il_instance(
1393                <Self as ::unity::SystemObject>::as_instance(self),
1394            );
1395            {
1396                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1397                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1398                    panic!(
1399                        "unity: virtual slot {}
1400 out of range (vtable len {}
1401) on the runtime class behind {}
1402 (method `{}
1403`)",
1404                        30usize,
1405                        __vt.len(),
1406                        <SystemCalculator_BattleStyleDragonCommand as ::unity::ClassIdentity>::NAME,
1407                        "get_Style",
1408                    )
1409                });
1410                let __inner: extern "C" fn(
1411                    SystemCalculator_BattleStyleDragonCommand,
1412                    ::unity::OptionalMethod,
1413                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
1414                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1415                __inner(__receiver, __mi)
1416            }
1417        }
1418    }
1419    #[doc = "`.ctor()` overload"]
1420    fn ctor(self) -> () {
1421        unsafe {
1422            let __receiver = <SystemCalculator_BattleStyleDragonCommand as ::unity::FromIlInstance>::from_il_instance(
1423                <Self as ::unity::SystemObject>::as_instance(self),
1424            );
1425            ::unity::il2cpp_call!((::unity::module_base()+0x21f8160usize)as*mut u8,();
1426(SystemCalculator_BattleStyleDragonCommand)__receiver)
1427        }
1428    }
1429}
1430
1431#[cfg(feature = "app-systemcalculator")]
1432impl<__T: ISystemCalculator_BattleStyleDragonCommand> ISystemCalculator_BattleStyleDragonCommandMethods for __T {}
1433
1434#[cfg(feature = "app-systemcalculator")]
1435impl SystemCalculator_BattleStyleDragonCommand {
1436    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1437        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1438    }
1439
1440    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1441        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1442    }
1443}
1444
1445#[cfg(feature = "app-systemcalculator")]
1446impl SystemCalculator_BattleStyleDragonCommand {
1447    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleDragonCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1448    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
1449        let __mi = Self::get_style_method_info();
1450        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
1451            ::core::mem::transmute(__mi.method_ptr);
1452        __inner(this.into(), ::core::option::Option::None)
1453    }
1454}
1455
1456#[cfg(feature = "app-systemcalculator")]
1457impl SystemCalculator_BattleStyleDragonCommand {
1458    #[doc = "`.ctor()` — no args"]
1459    pub fn new() -> Self {
1460        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1461            panic!(
1462                "{}
1463::{}
1464 failed to instantiate",
1465                ::core::stringify!(SystemCalculator_BattleStyleDragonCommand),
1466                ::core::stringify!(new),
1467            )
1468        });
1469        <Self as ISystemCalculator_BattleStyleDragonCommandMethods>::ctor(this);
1470        this
1471    }
1472}
1473
1474#[cfg(feature = "app-systemcalculator")]
1475pub trait ISystemCalculator_WeaponLevelDCommandMethods: ISystemCalculator_WeaponLevelDCommand {
1476    #[doc = "`get_Name()` overload"]
1477    fn get_name(self) -> ::unity::Il2CppString {
1478        unsafe {
1479            let __receiver = <SystemCalculator_WeaponLevelDCommand as ::unity::FromIlInstance>::from_il_instance(
1480                <Self as ::unity::SystemObject>::as_instance(self),
1481            );
1482            {
1483                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1484                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1485                    panic!(
1486                        "unity: virtual slot {}
1487 out of range (vtable len {}
1488) on the runtime class behind {}
1489 (method `{}
1490`)",
1491                        4usize,
1492                        __vt.len(),
1493                        <SystemCalculator_WeaponLevelDCommand as ::unity::ClassIdentity>::NAME,
1494                        "get_Name",
1495                    )
1496                });
1497                let __inner: extern "C" fn(SystemCalculator_WeaponLevelDCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1498                    ::core::mem::transmute(__vi.method_ptr);
1499                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1500                __inner(__receiver, __mi)
1501            }
1502        }
1503    }
1504    #[doc = "`Get()` overload"]
1505    fn get(self) -> f32 {
1506        unsafe {
1507            let __receiver = <SystemCalculator_WeaponLevelDCommand as ::unity::FromIlInstance>::from_il_instance(
1508                <Self as ::unity::SystemObject>::as_instance(self),
1509            );
1510            {
1511                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1512                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1513                    panic!(
1514                        "unity: virtual slot {}
1515 out of range (vtable len {}
1516) on the runtime class behind {}
1517 (method `{}
1518`)",
1519                        9usize,
1520                        __vt.len(),
1521                        <SystemCalculator_WeaponLevelDCommand as ::unity::ClassIdentity>::NAME,
1522                        "Get",
1523                    )
1524                });
1525                let __inner: extern "C" fn(SystemCalculator_WeaponLevelDCommand, ::unity::OptionalMethod) -> f32 =
1526                    ::core::mem::transmute(__vi.method_ptr);
1527                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1528                __inner(__receiver, __mi)
1529            }
1530        }
1531    }
1532    #[doc = "`.ctor()` overload"]
1533    fn ctor(self) -> () {
1534        unsafe {
1535            let __receiver = <SystemCalculator_WeaponLevelDCommand as ::unity::FromIlInstance>::from_il_instance(
1536                <Self as ::unity::SystemObject>::as_instance(self),
1537            );
1538            ::unity::il2cpp_call!((::unity::module_base()+0x21f9e30usize)as*mut u8,();
1539(SystemCalculator_WeaponLevelDCommand)__receiver)
1540        }
1541    }
1542}
1543
1544#[cfg(feature = "app-systemcalculator")]
1545impl<__T: ISystemCalculator_WeaponLevelDCommand> ISystemCalculator_WeaponLevelDCommandMethods for __T {}
1546
1547#[cfg(feature = "app-systemcalculator")]
1548impl SystemCalculator_WeaponLevelDCommand {
1549    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1550        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1551    }
1552
1553    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1554        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1555    }
1556
1557    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1558        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1559    }
1560}
1561
1562#[cfg(feature = "app-systemcalculator")]
1563impl SystemCalculator_WeaponLevelDCommand {
1564    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelDCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1565    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1566        let __mi = Self::get_name_method_info();
1567        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1568        __inner(this.into(), ::core::option::Option::None)
1569    }
1570
1571    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelDCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1572    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1573        let __mi = Self::get_method_info();
1574        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1575        __inner(this.into(), ::core::option::Option::None)
1576    }
1577}
1578
1579#[cfg(feature = "app-systemcalculator")]
1580impl SystemCalculator_WeaponLevelDCommand {
1581    #[doc = "`.ctor()` — no args"]
1582    pub fn new() -> Self {
1583        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1584            panic!(
1585                "{}
1586::{}
1587 failed to instantiate",
1588                ::core::stringify!(SystemCalculator_WeaponLevelDCommand),
1589                ::core::stringify!(new),
1590            )
1591        });
1592        <Self as ISystemCalculator_WeaponLevelDCommandMethods>::ctor(this);
1593        this
1594    }
1595}
1596
1597#[cfg(feature = "app-systemcalculator")]
1598pub trait ISystemCalculator_BattleStylePranaCommandMethods: ISystemCalculator_BattleStylePranaCommand {
1599    #[doc = "`get_Style()` overload"]
1600    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
1601        unsafe {
1602            let __receiver = <SystemCalculator_BattleStylePranaCommand as ::unity::FromIlInstance>::from_il_instance(
1603                <Self as ::unity::SystemObject>::as_instance(self),
1604            );
1605            {
1606                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1607                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1608                    panic!(
1609                        "unity: virtual slot {}
1610 out of range (vtable len {}
1611) on the runtime class behind {}
1612 (method `{}
1613`)",
1614                        30usize,
1615                        __vt.len(),
1616                        <SystemCalculator_BattleStylePranaCommand as ::unity::ClassIdentity>::NAME,
1617                        "get_Style",
1618                    )
1619                });
1620                let __inner: extern "C" fn(
1621                    SystemCalculator_BattleStylePranaCommand,
1622                    ::unity::OptionalMethod,
1623                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
1624                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1625                __inner(__receiver, __mi)
1626            }
1627        }
1628    }
1629    #[doc = "`.ctor()` overload"]
1630    fn ctor(self) -> () {
1631        unsafe {
1632            let __receiver = <SystemCalculator_BattleStylePranaCommand as ::unity::FromIlInstance>::from_il_instance(
1633                <Self as ::unity::SystemObject>::as_instance(self),
1634            );
1635            ::unity::il2cpp_call!((::unity::module_base()+0x21f8200usize)as*mut u8,();
1636(SystemCalculator_BattleStylePranaCommand)__receiver)
1637        }
1638    }
1639}
1640
1641#[cfg(feature = "app-systemcalculator")]
1642impl<__T: ISystemCalculator_BattleStylePranaCommand> ISystemCalculator_BattleStylePranaCommandMethods for __T {}
1643
1644#[cfg(feature = "app-systemcalculator")]
1645impl SystemCalculator_BattleStylePranaCommand {
1646    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1647        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1648    }
1649
1650    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1651        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1652    }
1653}
1654
1655#[cfg(feature = "app-systemcalculator")]
1656impl SystemCalculator_BattleStylePranaCommand {
1657    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStylePranaCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1658    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
1659        let __mi = Self::get_style_method_info();
1660        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
1661            ::core::mem::transmute(__mi.method_ptr);
1662        __inner(this.into(), ::core::option::Option::None)
1663    }
1664}
1665
1666#[cfg(feature = "app-systemcalculator")]
1667impl SystemCalculator_BattleStylePranaCommand {
1668    #[doc = "`.ctor()` — no args"]
1669    pub fn new() -> Self {
1670        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1671            panic!(
1672                "{}
1673::{}
1674 failed to instantiate",
1675                ::core::stringify!(SystemCalculator_BattleStylePranaCommand),
1676                ::core::stringify!(new),
1677            )
1678        });
1679        <Self as ISystemCalculator_BattleStylePranaCommandMethods>::ctor(this);
1680        this
1681    }
1682}
1683
1684#[cfg(feature = "app-systemcalculator")]
1685pub trait ISystemCalculator_RodTypeHealCommandMethods: ISystemCalculator_RodTypeHealCommand {
1686    #[doc = "`get_Name()` overload"]
1687    fn get_name(self) -> ::unity::Il2CppString {
1688        unsafe {
1689            let __receiver = <SystemCalculator_RodTypeHealCommand as ::unity::FromIlInstance>::from_il_instance(
1690                <Self as ::unity::SystemObject>::as_instance(self),
1691            );
1692            {
1693                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1694                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1695                    panic!(
1696                        "unity: virtual slot {}
1697 out of range (vtable len {}
1698) on the runtime class behind {}
1699 (method `{}
1700`)",
1701                        4usize,
1702                        __vt.len(),
1703                        <SystemCalculator_RodTypeHealCommand as ::unity::ClassIdentity>::NAME,
1704                        "get_Name",
1705                    )
1706                });
1707                let __inner: extern "C" fn(SystemCalculator_RodTypeHealCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1708                    ::core::mem::transmute(__vi.method_ptr);
1709                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1710                __inner(__receiver, __mi)
1711            }
1712        }
1713    }
1714    #[doc = "`Get()` overload"]
1715    fn get(self) -> f32 {
1716        unsafe {
1717            let __receiver = <SystemCalculator_RodTypeHealCommand as ::unity::FromIlInstance>::from_il_instance(
1718                <Self as ::unity::SystemObject>::as_instance(self),
1719            );
1720            {
1721                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1722                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1723                    panic!(
1724                        "unity: virtual slot {}
1725 out of range (vtable len {}
1726) on the runtime class behind {}
1727 (method `{}
1728`)",
1729                        9usize,
1730                        __vt.len(),
1731                        <SystemCalculator_RodTypeHealCommand as ::unity::ClassIdentity>::NAME,
1732                        "Get",
1733                    )
1734                });
1735                let __inner: extern "C" fn(SystemCalculator_RodTypeHealCommand, ::unity::OptionalMethod) -> f32 =
1736                    ::core::mem::transmute(__vi.method_ptr);
1737                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1738                __inner(__receiver, __mi)
1739            }
1740        }
1741    }
1742    #[doc = "`.ctor()` overload"]
1743    fn ctor(self) -> () {
1744        unsafe {
1745            let __receiver = <SystemCalculator_RodTypeHealCommand as ::unity::FromIlInstance>::from_il_instance(
1746                <Self as ::unity::SystemObject>::as_instance(self),
1747            );
1748            ::unity::il2cpp_call!((::unity::module_base()+0x21f9820usize)as*mut u8,();
1749(SystemCalculator_RodTypeHealCommand)__receiver)
1750        }
1751    }
1752}
1753
1754#[cfg(feature = "app-systemcalculator")]
1755impl<__T: ISystemCalculator_RodTypeHealCommand> ISystemCalculator_RodTypeHealCommandMethods for __T {}
1756
1757#[cfg(feature = "app-systemcalculator")]
1758impl SystemCalculator_RodTypeHealCommand {
1759    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1760        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1761    }
1762
1763    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1764        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1765    }
1766
1767    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1768        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1769    }
1770}
1771
1772#[cfg(feature = "app-systemcalculator")]
1773impl SystemCalculator_RodTypeHealCommand {
1774    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeHealCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1775    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1776        let __mi = Self::get_name_method_info();
1777        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1778        __inner(this.into(), ::core::option::Option::None)
1779    }
1780
1781    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeHealCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1782    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1783        let __mi = Self::get_method_info();
1784        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1785        __inner(this.into(), ::core::option::Option::None)
1786    }
1787}
1788
1789#[cfg(feature = "app-systemcalculator")]
1790impl SystemCalculator_RodTypeHealCommand {
1791    #[doc = "`.ctor()` — no args"]
1792    pub fn new() -> Self {
1793        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1794            panic!(
1795                "{}
1796::{}
1797 failed to instantiate",
1798                ::core::stringify!(SystemCalculator_RodTypeHealCommand),
1799                ::core::stringify!(new),
1800            )
1801        });
1802        <Self as ISystemCalculator_RodTypeHealCommandMethods>::ctor(this);
1803        this
1804    }
1805}
1806
1807#[cfg(feature = "app-systemcalculator")]
1808pub trait ISystemCalculatorMethods: ISystemCalculator {
1809    #[doc = "`.ctor()` overload"]
1810    fn ctor(self) -> () {
1811        unsafe {
1812            let __receiver = <SystemCalculator as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1813            ::unity::il2cpp_call!((::unity::module_base()+0x20b57e0usize)as*mut u8,();
1814(SystemCalculator)__receiver)
1815        }
1816    }
1817}
1818
1819#[cfg(feature = "app-systemcalculator")]
1820impl<__T: ISystemCalculator> ISystemCalculatorMethods for __T {}
1821
1822#[cfg(feature = "app-systemcalculator")]
1823impl SystemCalculator {
1824    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1825        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1826    }
1827}
1828
1829#[cfg(feature = "app-systemcalculator")]
1830impl SystemCalculator {
1831    #[doc = "`.ctor()` — no args"]
1832    pub fn new() -> Self {
1833        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1834            panic!(
1835                "{}
1836::{}
1837 failed to instantiate",
1838                ::core::stringify!(SystemCalculator),
1839                ::core::stringify!(new),
1840            )
1841        });
1842        <Self as ISystemCalculatorMethods>::ctor(this);
1843        this
1844    }
1845}
1846
1847#[cfg(feature = "app-systemcalculator")]
1848pub trait ISystemCalculator_ItemKindSpecialCommandMethods: ISystemCalculator_ItemKindSpecialCommand {
1849    #[doc = "`get_Name()` overload"]
1850    fn get_name(self) -> ::unity::Il2CppString {
1851        unsafe {
1852            let __receiver = <SystemCalculator_ItemKindSpecialCommand as ::unity::FromIlInstance>::from_il_instance(
1853                <Self as ::unity::SystemObject>::as_instance(self),
1854            );
1855            {
1856                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1857                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1858                    panic!(
1859                        "unity: virtual slot {}
1860 out of range (vtable len {}
1861) on the runtime class behind {}
1862 (method `{}
1863`)",
1864                        4usize,
1865                        __vt.len(),
1866                        <SystemCalculator_ItemKindSpecialCommand as ::unity::ClassIdentity>::NAME,
1867                        "get_Name",
1868                    )
1869                });
1870                let __inner: extern "C" fn(SystemCalculator_ItemKindSpecialCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1871                    ::core::mem::transmute(__vi.method_ptr);
1872                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1873                __inner(__receiver, __mi)
1874            }
1875        }
1876    }
1877    #[doc = "`Get()` overload"]
1878    fn get(self) -> f32 {
1879        unsafe {
1880            let __receiver = <SystemCalculator_ItemKindSpecialCommand as ::unity::FromIlInstance>::from_il_instance(
1881                <Self as ::unity::SystemObject>::as_instance(self),
1882            );
1883            {
1884                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1885                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1886                    panic!(
1887                        "unity: virtual slot {}
1888 out of range (vtable len {}
1889) on the runtime class behind {}
1890 (method `{}
1891`)",
1892                        9usize,
1893                        __vt.len(),
1894                        <SystemCalculator_ItemKindSpecialCommand as ::unity::ClassIdentity>::NAME,
1895                        "Get",
1896                    )
1897                });
1898                let __inner: extern "C" fn(SystemCalculator_ItemKindSpecialCommand, ::unity::OptionalMethod) -> f32 =
1899                    ::core::mem::transmute(__vi.method_ptr);
1900                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1901                __inner(__receiver, __mi)
1902            }
1903        }
1904    }
1905    #[doc = "`.ctor()` overload"]
1906    fn ctor(self) -> () {
1907        unsafe {
1908            let __receiver = <SystemCalculator_ItemKindSpecialCommand as ::unity::FromIlInstance>::from_il_instance(
1909                <Self as ::unity::SystemObject>::as_instance(self),
1910            );
1911            ::unity::il2cpp_call!((::unity::module_base()+0x21f8ec0usize)as*mut u8,();
1912(SystemCalculator_ItemKindSpecialCommand)__receiver)
1913        }
1914    }
1915}
1916
1917#[cfg(feature = "app-systemcalculator")]
1918impl<__T: ISystemCalculator_ItemKindSpecialCommand> ISystemCalculator_ItemKindSpecialCommandMethods for __T {}
1919
1920#[cfg(feature = "app-systemcalculator")]
1921impl SystemCalculator_ItemKindSpecialCommand {
1922    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1923        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1924    }
1925
1926    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1927        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1928    }
1929
1930    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1931        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1932    }
1933}
1934
1935#[cfg(feature = "app-systemcalculator")]
1936impl SystemCalculator_ItemKindSpecialCommand {
1937    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindSpecialCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1938    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1939        let __mi = Self::get_name_method_info();
1940        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1941        __inner(this.into(), ::core::option::Option::None)
1942    }
1943
1944    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindSpecialCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1945    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1946        let __mi = Self::get_method_info();
1947        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1948        __inner(this.into(), ::core::option::Option::None)
1949    }
1950}
1951
1952#[cfg(feature = "app-systemcalculator")]
1953impl SystemCalculator_ItemKindSpecialCommand {
1954    #[doc = "`.ctor()` — no args"]
1955    pub fn new() -> Self {
1956        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1957            panic!(
1958                "{}
1959::{}
1960 failed to instantiate",
1961                ::core::stringify!(SystemCalculator_ItemKindSpecialCommand),
1962                ::core::stringify!(new),
1963            )
1964        });
1965        <Self as ISystemCalculator_ItemKindSpecialCommandMethods>::ctor(this);
1966        this
1967    }
1968}
1969
1970#[cfg(feature = "app-systemcalculator")]
1971pub trait ISystemCalculator_PhaseOtherCommandMethods: ISystemCalculator_PhaseOtherCommand {
1972    #[doc = "`get_Name()` overload"]
1973    fn get_name(self) -> ::unity::Il2CppString {
1974        unsafe {
1975            let __receiver =
1976                <SystemCalculator_PhaseOtherCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1977            {
1978                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1979                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1980                    panic!(
1981                        "unity: virtual slot {}
1982 out of range (vtable len {}
1983) on the runtime class behind {}
1984 (method `{}
1985`)",
1986                        4usize,
1987                        __vt.len(),
1988                        <SystemCalculator_PhaseOtherCommand as ::unity::ClassIdentity>::NAME,
1989                        "get_Name",
1990                    )
1991                });
1992                let __inner: extern "C" fn(SystemCalculator_PhaseOtherCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1993                    ::core::mem::transmute(__vi.method_ptr);
1994                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1995                __inner(__receiver, __mi)
1996            }
1997        }
1998    }
1999    #[doc = "`Get()` overload"]
2000    fn get(self) -> f32 {
2001        unsafe {
2002            let __receiver =
2003                <SystemCalculator_PhaseOtherCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2004            {
2005                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2006                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2007                    panic!(
2008                        "unity: virtual slot {}
2009 out of range (vtable len {}
2010) on the runtime class behind {}
2011 (method `{}
2012`)",
2013                        9usize,
2014                        __vt.len(),
2015                        <SystemCalculator_PhaseOtherCommand as ::unity::ClassIdentity>::NAME,
2016                        "Get",
2017                    )
2018                });
2019                let __inner: extern "C" fn(SystemCalculator_PhaseOtherCommand, ::unity::OptionalMethod) -> f32 =
2020                    ::core::mem::transmute(__vi.method_ptr);
2021                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2022                __inner(__receiver, __mi)
2023            }
2024        }
2025    }
2026    #[doc = "`.ctor()` overload"]
2027    fn ctor(self) -> () {
2028        unsafe {
2029            let __receiver =
2030                <SystemCalculator_PhaseOtherCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2031            ::unity::il2cpp_call!((::unity::module_base()+0x21f96d0usize)as*mut u8,();
2032(SystemCalculator_PhaseOtherCommand)__receiver)
2033        }
2034    }
2035}
2036
2037#[cfg(feature = "app-systemcalculator")]
2038impl<__T: ISystemCalculator_PhaseOtherCommand> ISystemCalculator_PhaseOtherCommandMethods for __T {}
2039
2040#[cfg(feature = "app-systemcalculator")]
2041impl SystemCalculator_PhaseOtherCommand {
2042    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2043        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2044    }
2045
2046    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2047        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2048    }
2049
2050    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2051        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2052    }
2053}
2054
2055#[cfg(feature = "app-systemcalculator")]
2056impl SystemCalculator_PhaseOtherCommand {
2057    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhaseOtherCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2058    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2059        let __mi = Self::get_name_method_info();
2060        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2061        __inner(this.into(), ::core::option::Option::None)
2062    }
2063
2064    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhaseOtherCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2065    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2066        let __mi = Self::get_method_info();
2067        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2068        __inner(this.into(), ::core::option::Option::None)
2069    }
2070}
2071
2072#[cfg(feature = "app-systemcalculator")]
2073impl SystemCalculator_PhaseOtherCommand {
2074    #[doc = "`.ctor()` — no args"]
2075    pub fn new() -> Self {
2076        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2077            panic!(
2078                "{}
2079::{}
2080 failed to instantiate",
2081                ::core::stringify!(SystemCalculator_PhaseOtherCommand),
2082                ::core::stringify!(new),
2083            )
2084        });
2085        <Self as ISystemCalculator_PhaseOtherCommandMethods>::ctor(this);
2086        this
2087    }
2088}
2089
2090#[cfg(feature = "app-systemcalculator")]
2091pub trait ISystemCalculator_SkillIndexCommandMethods: ISystemCalculator_SkillIndexCommand {
2092    #[doc = "`get_Name()` overload"]
2093    fn get_name(self) -> ::unity::Il2CppString {
2094        unsafe {
2095            let __receiver =
2096                <SystemCalculator_SkillIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2097            {
2098                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2099                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2100                    panic!(
2101                        "unity: virtual slot {}
2102 out of range (vtable len {}
2103) on the runtime class behind {}
2104 (method `{}
2105`)",
2106                        4usize,
2107                        __vt.len(),
2108                        <SystemCalculator_SkillIndexCommand as ::unity::ClassIdentity>::NAME,
2109                        "get_Name",
2110                    )
2111                });
2112                let __inner: extern "C" fn(SystemCalculator_SkillIndexCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2113                    ::core::mem::transmute(__vi.method_ptr);
2114                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2115                __inner(__receiver, __mi)
2116            }
2117        }
2118    }
2119    #[doc = "`Func(::unity::Il2CppString)` overload"]
2120    fn func(self, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
2121        unsafe {
2122            let __receiver =
2123                <SystemCalculator_SkillIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2124            {
2125                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2126                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2127                    panic!(
2128                        "unity: virtual slot {}
2129 out of range (vtable len {}
2130) on the runtime class behind {}
2131 (method `{}
2132`)",
2133                        27usize,
2134                        __vt.len(),
2135                        <SystemCalculator_SkillIndexCommand as ::unity::ClassIdentity>::NAME,
2136                        "Func",
2137                    )
2138                });
2139                let __inner: extern "C" fn(SystemCalculator_SkillIndexCommand, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
2140                    ::core::mem::transmute(__vi.method_ptr);
2141                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2142                __inner(__receiver, ::core::convert::Into::into(arg), __mi)
2143            }
2144        }
2145    }
2146    #[doc = "`.ctor()` overload"]
2147    fn ctor(self) -> () {
2148        unsafe {
2149            let __receiver =
2150                <SystemCalculator_SkillIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2151            ::unity::il2cpp_call!((::unity::module_base()+0x21f99e0usize)as*mut u8,();
2152(SystemCalculator_SkillIndexCommand)__receiver)
2153        }
2154    }
2155}
2156
2157#[cfg(feature = "app-systemcalculator")]
2158impl<__T: ISystemCalculator_SkillIndexCommand> ISystemCalculator_SkillIndexCommandMethods for __T {}
2159
2160#[cfg(feature = "app-systemcalculator")]
2161impl SystemCalculator_SkillIndexCommand {
2162    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2163        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2164    }
2165
2166    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2167        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2168    }
2169
2170    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2171        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2172    }
2173}
2174
2175#[cfg(feature = "app-systemcalculator")]
2176impl SystemCalculator_SkillIndexCommand {
2177    #[doc = "Direct (non-virtual) call to `SystemCalculator_SkillIndexCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2178    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2179        let __mi = Self::get_name_method_info();
2180        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2181        __inner(this.into(), ::core::option::Option::None)
2182    }
2183
2184    #[doc = "Direct (non-virtual) call to `SystemCalculator_SkillIndexCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2185    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>, arg: ::unity::Il2CppString) -> f32 {
2186        let __mi = Self::func_method_info();
2187        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
2188            ::core::mem::transmute(__mi.method_ptr);
2189        __inner(this.into(), arg, ::core::option::Option::None)
2190    }
2191}
2192
2193#[cfg(feature = "app-systemcalculator")]
2194impl SystemCalculator_SkillIndexCommand {
2195    #[doc = "`.ctor()` — no args"]
2196    pub fn new() -> Self {
2197        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2198            panic!(
2199                "{}
2200::{}
2201 failed to instantiate",
2202                ::core::stringify!(SystemCalculator_SkillIndexCommand),
2203                ::core::stringify!(new),
2204            )
2205        });
2206        <Self as ISystemCalculator_SkillIndexCommandMethods>::ctor(this);
2207        this
2208    }
2209}
2210
2211#[cfg(feature = "app-systemcalculator")]
2212pub trait ISystemCalculator_RodTypeInterferenceCommandMethods: ISystemCalculator_RodTypeInterferenceCommand {
2213    #[doc = "`get_Name()` overload"]
2214    fn get_name(self) -> ::unity::Il2CppString {
2215        unsafe {
2216            let __receiver = <SystemCalculator_RodTypeInterferenceCommand as ::unity::FromIlInstance>::from_il_instance(
2217                <Self as ::unity::SystemObject>::as_instance(self),
2218            );
2219            {
2220                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2221                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2222                    panic!(
2223                        "unity: virtual slot {}
2224 out of range (vtable len {}
2225) on the runtime class behind {}
2226 (method `{}
2227`)",
2228                        4usize,
2229                        __vt.len(),
2230                        <SystemCalculator_RodTypeInterferenceCommand as ::unity::ClassIdentity>::NAME,
2231                        "get_Name",
2232                    )
2233                });
2234                let __inner: extern "C" fn(SystemCalculator_RodTypeInterferenceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2235                    ::core::mem::transmute(__vi.method_ptr);
2236                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2237                __inner(__receiver, __mi)
2238            }
2239        }
2240    }
2241    #[doc = "`Get()` overload"]
2242    fn get(self) -> f32 {
2243        unsafe {
2244            let __receiver = <SystemCalculator_RodTypeInterferenceCommand as ::unity::FromIlInstance>::from_il_instance(
2245                <Self as ::unity::SystemObject>::as_instance(self),
2246            );
2247            {
2248                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2249                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2250                    panic!(
2251                        "unity: virtual slot {}
2252 out of range (vtable len {}
2253) on the runtime class behind {}
2254 (method `{}
2255`)",
2256                        9usize,
2257                        __vt.len(),
2258                        <SystemCalculator_RodTypeInterferenceCommand as ::unity::ClassIdentity>::NAME,
2259                        "Get",
2260                    )
2261                });
2262                let __inner: extern "C" fn(SystemCalculator_RodTypeInterferenceCommand, ::unity::OptionalMethod) -> f32 =
2263                    ::core::mem::transmute(__vi.method_ptr);
2264                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2265                __inner(__receiver, __mi)
2266            }
2267        }
2268    }
2269    #[doc = "`.ctor()` overload"]
2270    fn ctor(self) -> () {
2271        unsafe {
2272            let __receiver = <SystemCalculator_RodTypeInterferenceCommand as ::unity::FromIlInstance>::from_il_instance(
2273                <Self as ::unity::SystemObject>::as_instance(self),
2274            );
2275            ::unity::il2cpp_call!((::unity::module_base()+0x21f9890usize)as*mut u8,();
2276(SystemCalculator_RodTypeInterferenceCommand)__receiver)
2277        }
2278    }
2279}
2280
2281#[cfg(feature = "app-systemcalculator")]
2282impl<__T: ISystemCalculator_RodTypeInterferenceCommand> ISystemCalculator_RodTypeInterferenceCommandMethods for __T {}
2283
2284#[cfg(feature = "app-systemcalculator")]
2285impl SystemCalculator_RodTypeInterferenceCommand {
2286    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2287        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2288    }
2289
2290    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2291        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2292    }
2293
2294    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2295        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2296    }
2297}
2298
2299#[cfg(feature = "app-systemcalculator")]
2300impl SystemCalculator_RodTypeInterferenceCommand {
2301    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeInterferenceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2302    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2303        let __mi = Self::get_name_method_info();
2304        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2305        __inner(this.into(), ::core::option::Option::None)
2306    }
2307
2308    #[doc = "Direct (non-virtual) call to `SystemCalculator_RodTypeInterferenceCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2309    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2310        let __mi = Self::get_method_info();
2311        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2312        __inner(this.into(), ::core::option::Option::None)
2313    }
2314}
2315
2316#[cfg(feature = "app-systemcalculator")]
2317impl SystemCalculator_RodTypeInterferenceCommand {
2318    #[doc = "`.ctor()` — no args"]
2319    pub fn new() -> Self {
2320        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2321            panic!(
2322                "{}
2323::{}
2324 failed to instantiate",
2325                ::core::stringify!(SystemCalculator_RodTypeInterferenceCommand),
2326                ::core::stringify!(new),
2327            )
2328        });
2329        <Self as ISystemCalculator_RodTypeInterferenceCommandMethods>::ctor(this);
2330        this
2331    }
2332}
2333
2334#[cfg(feature = "app-systemcalculator")]
2335pub trait ISystemCalculator_ItemKindDaggerCommandMethods: ISystemCalculator_ItemKindDaggerCommand {
2336    #[doc = "`get_Name()` overload"]
2337    fn get_name(self) -> ::unity::Il2CppString {
2338        unsafe {
2339            let __receiver = <SystemCalculator_ItemKindDaggerCommand as ::unity::FromIlInstance>::from_il_instance(
2340                <Self as ::unity::SystemObject>::as_instance(self),
2341            );
2342            {
2343                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2344                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2345                    panic!(
2346                        "unity: virtual slot {}
2347 out of range (vtable len {}
2348) on the runtime class behind {}
2349 (method `{}
2350`)",
2351                        4usize,
2352                        __vt.len(),
2353                        <SystemCalculator_ItemKindDaggerCommand as ::unity::ClassIdentity>::NAME,
2354                        "get_Name",
2355                    )
2356                });
2357                let __inner: extern "C" fn(SystemCalculator_ItemKindDaggerCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2358                    ::core::mem::transmute(__vi.method_ptr);
2359                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2360                __inner(__receiver, __mi)
2361            }
2362        }
2363    }
2364    #[doc = "`Get()` overload"]
2365    fn get(self) -> f32 {
2366        unsafe {
2367            let __receiver = <SystemCalculator_ItemKindDaggerCommand as ::unity::FromIlInstance>::from_il_instance(
2368                <Self as ::unity::SystemObject>::as_instance(self),
2369            );
2370            {
2371                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2372                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2373                    panic!(
2374                        "unity: virtual slot {}
2375 out of range (vtable len {}
2376) on the runtime class behind {}
2377 (method `{}
2378`)",
2379                        9usize,
2380                        __vt.len(),
2381                        <SystemCalculator_ItemKindDaggerCommand as ::unity::ClassIdentity>::NAME,
2382                        "Get",
2383                    )
2384                });
2385                let __inner: extern "C" fn(SystemCalculator_ItemKindDaggerCommand, ::unity::OptionalMethod) -> f32 =
2386                    ::core::mem::transmute(__vi.method_ptr);
2387                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2388                __inner(__receiver, __mi)
2389            }
2390        }
2391    }
2392    #[doc = "`.ctor()` overload"]
2393    fn ctor(self) -> () {
2394        unsafe {
2395            let __receiver = <SystemCalculator_ItemKindDaggerCommand as ::unity::FromIlInstance>::from_il_instance(
2396                <Self as ::unity::SystemObject>::as_instance(self),
2397            );
2398            ::unity::il2cpp_call!((::unity::module_base()+0x21f8c90usize)as*mut u8,();
2399(SystemCalculator_ItemKindDaggerCommand)__receiver)
2400        }
2401    }
2402}
2403
2404#[cfg(feature = "app-systemcalculator")]
2405impl<__T: ISystemCalculator_ItemKindDaggerCommand> ISystemCalculator_ItemKindDaggerCommandMethods for __T {}
2406
2407#[cfg(feature = "app-systemcalculator")]
2408impl SystemCalculator_ItemKindDaggerCommand {
2409    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2410        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2411    }
2412
2413    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2414        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2415    }
2416
2417    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2418        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2419    }
2420}
2421
2422#[cfg(feature = "app-systemcalculator")]
2423impl SystemCalculator_ItemKindDaggerCommand {
2424    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindDaggerCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2425    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2426        let __mi = Self::get_name_method_info();
2427        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2428        __inner(this.into(), ::core::option::Option::None)
2429    }
2430
2431    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindDaggerCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2432    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2433        let __mi = Self::get_method_info();
2434        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2435        __inner(this.into(), ::core::option::Option::None)
2436    }
2437}
2438
2439#[cfg(feature = "app-systemcalculator")]
2440impl SystemCalculator_ItemKindDaggerCommand {
2441    #[doc = "`.ctor()` — no args"]
2442    pub fn new() -> Self {
2443        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2444            panic!(
2445                "{}
2446::{}
2447 failed to instantiate",
2448                ::core::stringify!(SystemCalculator_ItemKindDaggerCommand),
2449                ::core::stringify!(new),
2450            )
2451        });
2452        <Self as ISystemCalculator_ItemKindDaggerCommandMethods>::ctor(this);
2453        this
2454    }
2455}
2456
2457#[cfg(feature = "app-systemcalculator")]
2458pub trait ISystemCalculator_DifficultyHardCommandMethods: ISystemCalculator_DifficultyHardCommand {
2459    #[doc = "`get_Name()` overload"]
2460    fn get_name(self) -> ::unity::Il2CppString {
2461        unsafe {
2462            let __receiver = <SystemCalculator_DifficultyHardCommand as ::unity::FromIlInstance>::from_il_instance(
2463                <Self as ::unity::SystemObject>::as_instance(self),
2464            );
2465            {
2466                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2467                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2468                    panic!(
2469                        "unity: virtual slot {}
2470 out of range (vtable len {}
2471) on the runtime class behind {}
2472 (method `{}
2473`)",
2474                        4usize,
2475                        __vt.len(),
2476                        <SystemCalculator_DifficultyHardCommand as ::unity::ClassIdentity>::NAME,
2477                        "get_Name",
2478                    )
2479                });
2480                let __inner: extern "C" fn(SystemCalculator_DifficultyHardCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2481                    ::core::mem::transmute(__vi.method_ptr);
2482                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2483                __inner(__receiver, __mi)
2484            }
2485        }
2486    }
2487    #[doc = "`Get()` overload"]
2488    fn get(self) -> f32 {
2489        unsafe {
2490            let __receiver = <SystemCalculator_DifficultyHardCommand as ::unity::FromIlInstance>::from_il_instance(
2491                <Self as ::unity::SystemObject>::as_instance(self),
2492            );
2493            {
2494                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2495                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2496                    panic!(
2497                        "unity: virtual slot {}
2498 out of range (vtable len {}
2499) on the runtime class behind {}
2500 (method `{}
2501`)",
2502                        9usize,
2503                        __vt.len(),
2504                        <SystemCalculator_DifficultyHardCommand as ::unity::ClassIdentity>::NAME,
2505                        "Get",
2506                    )
2507                });
2508                let __inner: extern "C" fn(SystemCalculator_DifficultyHardCommand, ::unity::OptionalMethod) -> f32 =
2509                    ::core::mem::transmute(__vi.method_ptr);
2510                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2511                __inner(__receiver, __mi)
2512            }
2513        }
2514    }
2515    #[doc = "`.ctor()` overload"]
2516    fn ctor(self) -> () {
2517        unsafe {
2518            let __receiver = <SystemCalculator_DifficultyHardCommand as ::unity::FromIlInstance>::from_il_instance(
2519                <Self as ::unity::SystemObject>::as_instance(self),
2520            );
2521            ::unity::il2cpp_call!((::unity::module_base()+0x21f82e0usize)as*mut u8,();
2522(SystemCalculator_DifficultyHardCommand)__receiver)
2523        }
2524    }
2525}
2526
2527#[cfg(feature = "app-systemcalculator")]
2528impl<__T: ISystemCalculator_DifficultyHardCommand> ISystemCalculator_DifficultyHardCommandMethods for __T {}
2529
2530#[cfg(feature = "app-systemcalculator")]
2531impl SystemCalculator_DifficultyHardCommand {
2532    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2533        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2534    }
2535
2536    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2537        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2538    }
2539
2540    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2541        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2542    }
2543}
2544
2545#[cfg(feature = "app-systemcalculator")]
2546impl SystemCalculator_DifficultyHardCommand {
2547    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyHardCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2548    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2549        let __mi = Self::get_name_method_info();
2550        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2551        __inner(this.into(), ::core::option::Option::None)
2552    }
2553
2554    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyHardCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2555    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2556        let __mi = Self::get_method_info();
2557        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2558        __inner(this.into(), ::core::option::Option::None)
2559    }
2560}
2561
2562#[cfg(feature = "app-systemcalculator")]
2563impl SystemCalculator_DifficultyHardCommand {
2564    #[doc = "`.ctor()` — no args"]
2565    pub fn new() -> Self {
2566        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2567            panic!(
2568                "{}
2569::{}
2570 failed to instantiate",
2571                ::core::stringify!(SystemCalculator_DifficultyHardCommand),
2572                ::core::stringify!(new),
2573            )
2574        });
2575        <Self as ISystemCalculator_DifficultyHardCommandMethods>::ctor(this);
2576        this
2577    }
2578}
2579
2580#[cfg(feature = "app-systemcalculator")]
2581pub trait ISystemCalculator_GameModeCasualCommandMethods: ISystemCalculator_GameModeCasualCommand {
2582    #[doc = "`get_Name()` overload"]
2583    fn get_name(self) -> ::unity::Il2CppString {
2584        unsafe {
2585            let __receiver = <SystemCalculator_GameModeCasualCommand as ::unity::FromIlInstance>::from_il_instance(
2586                <Self as ::unity::SystemObject>::as_instance(self),
2587            );
2588            {
2589                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2590                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2591                    panic!(
2592                        "unity: virtual slot {}
2593 out of range (vtable len {}
2594) on the runtime class behind {}
2595 (method `{}
2596`)",
2597                        4usize,
2598                        __vt.len(),
2599                        <SystemCalculator_GameModeCasualCommand as ::unity::ClassIdentity>::NAME,
2600                        "get_Name",
2601                    )
2602                });
2603                let __inner: extern "C" fn(SystemCalculator_GameModeCasualCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2604                    ::core::mem::transmute(__vi.method_ptr);
2605                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2606                __inner(__receiver, __mi)
2607            }
2608        }
2609    }
2610    #[doc = "`Get()` overload"]
2611    fn get(self) -> f32 {
2612        unsafe {
2613            let __receiver = <SystemCalculator_GameModeCasualCommand as ::unity::FromIlInstance>::from_il_instance(
2614                <Self as ::unity::SystemObject>::as_instance(self),
2615            );
2616            {
2617                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2618                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2619                    panic!(
2620                        "unity: virtual slot {}
2621 out of range (vtable len {}
2622) on the runtime class behind {}
2623 (method `{}
2624`)",
2625                        9usize,
2626                        __vt.len(),
2627                        <SystemCalculator_GameModeCasualCommand as ::unity::ClassIdentity>::NAME,
2628                        "Get",
2629                    )
2630                });
2631                let __inner: extern "C" fn(SystemCalculator_GameModeCasualCommand, ::unity::OptionalMethod) -> f32 =
2632                    ::core::mem::transmute(__vi.method_ptr);
2633                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2634                __inner(__receiver, __mi)
2635            }
2636        }
2637    }
2638    #[doc = "`.ctor()` overload"]
2639    fn ctor(self) -> () {
2640        unsafe {
2641            let __receiver = <SystemCalculator_GameModeCasualCommand as ::unity::FromIlInstance>::from_il_instance(
2642                <Self as ::unity::SystemObject>::as_instance(self),
2643            );
2644            ::unity::il2cpp_call!((::unity::module_base()+0x21f8740usize)as*mut u8,();
2645(SystemCalculator_GameModeCasualCommand)__receiver)
2646        }
2647    }
2648}
2649
2650#[cfg(feature = "app-systemcalculator")]
2651impl<__T: ISystemCalculator_GameModeCasualCommand> ISystemCalculator_GameModeCasualCommandMethods for __T {}
2652
2653#[cfg(feature = "app-systemcalculator")]
2654impl SystemCalculator_GameModeCasualCommand {
2655    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2656        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2657    }
2658
2659    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2660        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2661    }
2662
2663    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2664        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2665    }
2666}
2667
2668#[cfg(feature = "app-systemcalculator")]
2669impl SystemCalculator_GameModeCasualCommand {
2670    #[doc = "Direct (non-virtual) call to `SystemCalculator_GameModeCasualCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2671    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2672        let __mi = Self::get_name_method_info();
2673        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2674        __inner(this.into(), ::core::option::Option::None)
2675    }
2676
2677    #[doc = "Direct (non-virtual) call to `SystemCalculator_GameModeCasualCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2678    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2679        let __mi = Self::get_method_info();
2680        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2681        __inner(this.into(), ::core::option::Option::None)
2682    }
2683}
2684
2685#[cfg(feature = "app-systemcalculator")]
2686impl SystemCalculator_GameModeCasualCommand {
2687    #[doc = "`.ctor()` — no args"]
2688    pub fn new() -> Self {
2689        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2690            panic!(
2691                "{}
2692::{}
2693 failed to instantiate",
2694                ::core::stringify!(SystemCalculator_GameModeCasualCommand),
2695                ::core::stringify!(new),
2696            )
2697        });
2698        <Self as ISystemCalculator_GameModeCasualCommandMethods>::ctor(this);
2699        this
2700    }
2701}
2702
2703#[cfg(feature = "app-systemcalculator")]
2704pub trait ISystemCalculator_BattleSideChainDefenseCommandMethods: ISystemCalculator_BattleSideChainDefenseCommand {
2705    #[doc = "`get_Name()` overload"]
2706    fn get_name(self) -> ::unity::Il2CppString {
2707        unsafe {
2708            let __receiver = <SystemCalculator_BattleSideChainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
2709                <Self as ::unity::SystemObject>::as_instance(self),
2710            );
2711            {
2712                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2713                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2714                    panic!(
2715                        "unity: virtual slot {}
2716 out of range (vtable len {}
2717) on the runtime class behind {}
2718 (method `{}
2719`)",
2720                        4usize,
2721                        __vt.len(),
2722                        <SystemCalculator_BattleSideChainDefenseCommand as ::unity::ClassIdentity>::NAME,
2723                        "get_Name",
2724                    )
2725                });
2726                let __inner: extern "C" fn(SystemCalculator_BattleSideChainDefenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2727                    ::core::mem::transmute(__vi.method_ptr);
2728                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2729                __inner(__receiver, __mi)
2730            }
2731        }
2732    }
2733    #[doc = "`Get()` overload"]
2734    fn get(self) -> f32 {
2735        unsafe {
2736            let __receiver = <SystemCalculator_BattleSideChainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
2737                <Self as ::unity::SystemObject>::as_instance(self),
2738            );
2739            {
2740                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2741                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2742                    panic!(
2743                        "unity: virtual slot {}
2744 out of range (vtable len {}
2745) on the runtime class behind {}
2746 (method `{}
2747`)",
2748                        9usize,
2749                        __vt.len(),
2750                        <SystemCalculator_BattleSideChainDefenseCommand as ::unity::ClassIdentity>::NAME,
2751                        "Get",
2752                    )
2753                });
2754                let __inner: extern "C" fn(SystemCalculator_BattleSideChainDefenseCommand, ::unity::OptionalMethod) -> f32 =
2755                    ::core::mem::transmute(__vi.method_ptr);
2756                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2757                __inner(__receiver, __mi)
2758            }
2759        }
2760    }
2761    #[doc = "`.ctor()` overload"]
2762    fn ctor(self) -> () {
2763        unsafe {
2764            let __receiver = <SystemCalculator_BattleSideChainDefenseCommand as ::unity::FromIlInstance>::from_il_instance(
2765                <Self as ::unity::SystemObject>::as_instance(self),
2766            );
2767            ::unity::il2cpp_call!((::unity::module_base()+0x21f7ee0usize)as*mut u8,();
2768(SystemCalculator_BattleSideChainDefenseCommand)__receiver)
2769        }
2770    }
2771}
2772
2773#[cfg(feature = "app-systemcalculator")]
2774impl<__T: ISystemCalculator_BattleSideChainDefenseCommand> ISystemCalculator_BattleSideChainDefenseCommandMethods for __T {}
2775
2776#[cfg(feature = "app-systemcalculator")]
2777impl SystemCalculator_BattleSideChainDefenseCommand {
2778    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2779        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2780    }
2781
2782    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2783        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2784    }
2785
2786    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2787        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2788    }
2789}
2790
2791#[cfg(feature = "app-systemcalculator")]
2792impl SystemCalculator_BattleSideChainDefenseCommand {
2793    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideChainDefenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2794    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2795        let __mi = Self::get_name_method_info();
2796        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2797        __inner(this.into(), ::core::option::Option::None)
2798    }
2799
2800    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideChainDefenseCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2801    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2802        let __mi = Self::get_method_info();
2803        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2804        __inner(this.into(), ::core::option::Option::None)
2805    }
2806}
2807
2808#[cfg(feature = "app-systemcalculator")]
2809impl SystemCalculator_BattleSideChainDefenseCommand {
2810    #[doc = "`.ctor()` — no args"]
2811    pub fn new() -> Self {
2812        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2813            panic!(
2814                "{}
2815::{}
2816 failed to instantiate",
2817                ::core::stringify!(SystemCalculator_BattleSideChainDefenseCommand),
2818                ::core::stringify!(new),
2819            )
2820        });
2821        <Self as ISystemCalculator_BattleSideChainDefenseCommandMethods>::ctor(this);
2822        this
2823    }
2824}
2825
2826#[cfg(feature = "app-systemcalculator")]
2827pub trait ISystemCalculator_WeaponLevelACommandMethods: ISystemCalculator_WeaponLevelACommand {
2828    #[doc = "`get_Name()` overload"]
2829    fn get_name(self) -> ::unity::Il2CppString {
2830        unsafe {
2831            let __receiver = <SystemCalculator_WeaponLevelACommand as ::unity::FromIlInstance>::from_il_instance(
2832                <Self as ::unity::SystemObject>::as_instance(self),
2833            );
2834            {
2835                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2836                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2837                    panic!(
2838                        "unity: virtual slot {}
2839 out of range (vtable len {}
2840) on the runtime class behind {}
2841 (method `{}
2842`)",
2843                        4usize,
2844                        __vt.len(),
2845                        <SystemCalculator_WeaponLevelACommand as ::unity::ClassIdentity>::NAME,
2846                        "get_Name",
2847                    )
2848                });
2849                let __inner: extern "C" fn(SystemCalculator_WeaponLevelACommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2850                    ::core::mem::transmute(__vi.method_ptr);
2851                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2852                __inner(__receiver, __mi)
2853            }
2854        }
2855    }
2856    #[doc = "`Get()` overload"]
2857    fn get(self) -> f32 {
2858        unsafe {
2859            let __receiver = <SystemCalculator_WeaponLevelACommand as ::unity::FromIlInstance>::from_il_instance(
2860                <Self as ::unity::SystemObject>::as_instance(self),
2861            );
2862            {
2863                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2864                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2865                    panic!(
2866                        "unity: virtual slot {}
2867 out of range (vtable len {}
2868) on the runtime class behind {}
2869 (method `{}
2870`)",
2871                        9usize,
2872                        __vt.len(),
2873                        <SystemCalculator_WeaponLevelACommand as ::unity::ClassIdentity>::NAME,
2874                        "Get",
2875                    )
2876                });
2877                let __inner: extern "C" fn(SystemCalculator_WeaponLevelACommand, ::unity::OptionalMethod) -> f32 =
2878                    ::core::mem::transmute(__vi.method_ptr);
2879                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2880                __inner(__receiver, __mi)
2881            }
2882        }
2883    }
2884    #[doc = "`.ctor()` overload"]
2885    fn ctor(self) -> () {
2886        unsafe {
2887            let __receiver = <SystemCalculator_WeaponLevelACommand as ::unity::FromIlInstance>::from_il_instance(
2888                <Self as ::unity::SystemObject>::as_instance(self),
2889            );
2890            ::unity::il2cpp_call!((::unity::module_base()+0x21f9ce0usize)as*mut u8,();
2891(SystemCalculator_WeaponLevelACommand)__receiver)
2892        }
2893    }
2894}
2895
2896#[cfg(feature = "app-systemcalculator")]
2897impl<__T: ISystemCalculator_WeaponLevelACommand> ISystemCalculator_WeaponLevelACommandMethods for __T {}
2898
2899#[cfg(feature = "app-systemcalculator")]
2900impl SystemCalculator_WeaponLevelACommand {
2901    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2902        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2903    }
2904
2905    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2906        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2907    }
2908
2909    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2910        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2911    }
2912}
2913
2914#[cfg(feature = "app-systemcalculator")]
2915impl SystemCalculator_WeaponLevelACommand {
2916    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelACommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2917    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2918        let __mi = Self::get_name_method_info();
2919        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2920        __inner(this.into(), ::core::option::Option::None)
2921    }
2922
2923    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelACommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2924    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2925        let __mi = Self::get_method_info();
2926        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2927        __inner(this.into(), ::core::option::Option::None)
2928    }
2929}
2930
2931#[cfg(feature = "app-systemcalculator")]
2932impl SystemCalculator_WeaponLevelACommand {
2933    #[doc = "`.ctor()` — no args"]
2934    pub fn new() -> Self {
2935        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2936            panic!(
2937                "{}
2938::{}
2939 failed to instantiate",
2940                ::core::stringify!(SystemCalculator_WeaponLevelACommand),
2941                ::core::stringify!(new),
2942            )
2943        });
2944        <Self as ISystemCalculator_WeaponLevelACommandMethods>::ctor(this);
2945        this
2946    }
2947}
2948
2949#[cfg(feature = "app-systemcalculator")]
2950pub trait ISystemCalculator_ThunderAttributeCommandMethods: ISystemCalculator_ThunderAttributeCommand {
2951    #[doc = "`get_Name()` overload"]
2952    fn get_name(self) -> ::unity::Il2CppString {
2953        unsafe {
2954            let __receiver = <SystemCalculator_ThunderAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2955                <Self as ::unity::SystemObject>::as_instance(self),
2956            );
2957            {
2958                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2959                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2960                    panic!(
2961                        "unity: virtual slot {}
2962 out of range (vtable len {}
2963) on the runtime class behind {}
2964 (method `{}
2965`)",
2966                        4usize,
2967                        __vt.len(),
2968                        <SystemCalculator_ThunderAttributeCommand as ::unity::ClassIdentity>::NAME,
2969                        "get_Name",
2970                    )
2971                });
2972                let __inner: extern "C" fn(SystemCalculator_ThunderAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2973                    ::core::mem::transmute(__vi.method_ptr);
2974                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2975                __inner(__receiver, __mi)
2976            }
2977        }
2978    }
2979    #[doc = "`Get()` overload"]
2980    fn get(self) -> f32 {
2981        unsafe {
2982            let __receiver = <SystemCalculator_ThunderAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
2983                <Self as ::unity::SystemObject>::as_instance(self),
2984            );
2985            {
2986                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2987                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2988                    panic!(
2989                        "unity: virtual slot {}
2990 out of range (vtable len {}
2991) on the runtime class behind {}
2992 (method `{}
2993`)",
2994                        9usize,
2995                        __vt.len(),
2996                        <SystemCalculator_ThunderAttributeCommand as ::unity::ClassIdentity>::NAME,
2997                        "Get",
2998                    )
2999                });
3000                let __inner: extern "C" fn(SystemCalculator_ThunderAttributeCommand, ::unity::OptionalMethod) -> f32 =
3001                    ::core::mem::transmute(__vi.method_ptr);
3002                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3003                __inner(__receiver, __mi)
3004            }
3005        }
3006    }
3007    #[doc = "`.ctor()` overload"]
3008    fn ctor(self) -> () {
3009        unsafe {
3010            let __receiver = <SystemCalculator_ThunderAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
3011                <Self as ::unity::SystemObject>::as_instance(self),
3012            );
3013            ::unity::il2cpp_call!((::unity::module_base()+0x21f9a50usize)as*mut u8,();
3014(SystemCalculator_ThunderAttributeCommand)__receiver)
3015        }
3016    }
3017}
3018
3019#[cfg(feature = "app-systemcalculator")]
3020impl<__T: ISystemCalculator_ThunderAttributeCommand> ISystemCalculator_ThunderAttributeCommandMethods for __T {}
3021
3022#[cfg(feature = "app-systemcalculator")]
3023impl SystemCalculator_ThunderAttributeCommand {
3024    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3025        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3026    }
3027
3028    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3029        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3030    }
3031
3032    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3033        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3034    }
3035}
3036
3037#[cfg(feature = "app-systemcalculator")]
3038impl SystemCalculator_ThunderAttributeCommand {
3039    #[doc = "Direct (non-virtual) call to `SystemCalculator_ThunderAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3040    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3041        let __mi = Self::get_name_method_info();
3042        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3043        __inner(this.into(), ::core::option::Option::None)
3044    }
3045
3046    #[doc = "Direct (non-virtual) call to `SystemCalculator_ThunderAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3047    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3048        let __mi = Self::get_method_info();
3049        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3050        __inner(this.into(), ::core::option::Option::None)
3051    }
3052}
3053
3054#[cfg(feature = "app-systemcalculator")]
3055impl SystemCalculator_ThunderAttributeCommand {
3056    #[doc = "`.ctor()` — no args"]
3057    pub fn new() -> Self {
3058        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3059            panic!(
3060                "{}
3061::{}
3062 failed to instantiate",
3063                ::core::stringify!(SystemCalculator_ThunderAttributeCommand),
3064                ::core::stringify!(new),
3065            )
3066        });
3067        <Self as ISystemCalculator_ThunderAttributeCommandMethods>::ctor(this);
3068        this
3069    }
3070}
3071
3072#[cfg(feature = "app-systemcalculator")]
3073pub trait ISystemCalculator_BattleStyleMagicCommandMethods: ISystemCalculator_BattleStyleMagicCommand {
3074    #[doc = "`get_Style()` overload"]
3075    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
3076        unsafe {
3077            let __receiver = <SystemCalculator_BattleStyleMagicCommand as ::unity::FromIlInstance>::from_il_instance(
3078                <Self as ::unity::SystemObject>::as_instance(self),
3079            );
3080            {
3081                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3082                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3083                    panic!(
3084                        "unity: virtual slot {}
3085 out of range (vtable len {}
3086) on the runtime class behind {}
3087 (method `{}
3088`)",
3089                        30usize,
3090                        __vt.len(),
3091                        <SystemCalculator_BattleStyleMagicCommand as ::unity::ClassIdentity>::NAME,
3092                        "get_Style",
3093                    )
3094                });
3095                let __inner: extern "C" fn(
3096                    SystemCalculator_BattleStyleMagicCommand,
3097                    ::unity::OptionalMethod,
3098                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
3099                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3100                __inner(__receiver, __mi)
3101            }
3102        }
3103    }
3104    #[doc = "`.ctor()` overload"]
3105    fn ctor(self) -> () {
3106        unsafe {
3107            let __receiver = <SystemCalculator_BattleStyleMagicCommand as ::unity::FromIlInstance>::from_il_instance(
3108                <Self as ::unity::SystemObject>::as_instance(self),
3109            );
3110            ::unity::il2cpp_call!((::unity::module_base()+0x21f81e0usize)as*mut u8,();
3111(SystemCalculator_BattleStyleMagicCommand)__receiver)
3112        }
3113    }
3114}
3115
3116#[cfg(feature = "app-systemcalculator")]
3117impl<__T: ISystemCalculator_BattleStyleMagicCommand> ISystemCalculator_BattleStyleMagicCommandMethods for __T {}
3118
3119#[cfg(feature = "app-systemcalculator")]
3120impl SystemCalculator_BattleStyleMagicCommand {
3121    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3122        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3123    }
3124
3125    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3126        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3127    }
3128}
3129
3130#[cfg(feature = "app-systemcalculator")]
3131impl SystemCalculator_BattleStyleMagicCommand {
3132    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleMagicCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3133    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
3134        let __mi = Self::get_style_method_info();
3135        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
3136            ::core::mem::transmute(__mi.method_ptr);
3137        __inner(this.into(), ::core::option::Option::None)
3138    }
3139}
3140
3141#[cfg(feature = "app-systemcalculator")]
3142impl SystemCalculator_BattleStyleMagicCommand {
3143    #[doc = "`.ctor()` — no args"]
3144    pub fn new() -> Self {
3145        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3146            panic!(
3147                "{}
3148::{}
3149 failed to instantiate",
3150                ::core::stringify!(SystemCalculator_BattleStyleMagicCommand),
3151                ::core::stringify!(new),
3152            )
3153        });
3154        <Self as ISystemCalculator_BattleStyleMagicCommandMethods>::ctor(this);
3155        this
3156    }
3157}
3158
3159#[cfg(feature = "app-systemcalculator")]
3160pub trait ISystemCalculator_WeaponLevelCCommandMethods: ISystemCalculator_WeaponLevelCCommand {
3161    #[doc = "`get_Name()` overload"]
3162    fn get_name(self) -> ::unity::Il2CppString {
3163        unsafe {
3164            let __receiver = <SystemCalculator_WeaponLevelCCommand as ::unity::FromIlInstance>::from_il_instance(
3165                <Self as ::unity::SystemObject>::as_instance(self),
3166            );
3167            {
3168                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3169                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3170                    panic!(
3171                        "unity: virtual slot {}
3172 out of range (vtable len {}
3173) on the runtime class behind {}
3174 (method `{}
3175`)",
3176                        4usize,
3177                        __vt.len(),
3178                        <SystemCalculator_WeaponLevelCCommand as ::unity::ClassIdentity>::NAME,
3179                        "get_Name",
3180                    )
3181                });
3182                let __inner: extern "C" fn(SystemCalculator_WeaponLevelCCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3183                    ::core::mem::transmute(__vi.method_ptr);
3184                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3185                __inner(__receiver, __mi)
3186            }
3187        }
3188    }
3189    #[doc = "`Get()` overload"]
3190    fn get(self) -> f32 {
3191        unsafe {
3192            let __receiver = <SystemCalculator_WeaponLevelCCommand as ::unity::FromIlInstance>::from_il_instance(
3193                <Self as ::unity::SystemObject>::as_instance(self),
3194            );
3195            {
3196                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3197                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3198                    panic!(
3199                        "unity: virtual slot {}
3200 out of range (vtable len {}
3201) on the runtime class behind {}
3202 (method `{}
3203`)",
3204                        9usize,
3205                        __vt.len(),
3206                        <SystemCalculator_WeaponLevelCCommand as ::unity::ClassIdentity>::NAME,
3207                        "Get",
3208                    )
3209                });
3210                let __inner: extern "C" fn(SystemCalculator_WeaponLevelCCommand, ::unity::OptionalMethod) -> f32 =
3211                    ::core::mem::transmute(__vi.method_ptr);
3212                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3213                __inner(__receiver, __mi)
3214            }
3215        }
3216    }
3217    #[doc = "`.ctor()` overload"]
3218    fn ctor(self) -> () {
3219        unsafe {
3220            let __receiver = <SystemCalculator_WeaponLevelCCommand as ::unity::FromIlInstance>::from_il_instance(
3221                <Self as ::unity::SystemObject>::as_instance(self),
3222            );
3223            ::unity::il2cpp_call!((::unity::module_base()+0x21f9dc0usize)as*mut u8,();
3224(SystemCalculator_WeaponLevelCCommand)__receiver)
3225        }
3226    }
3227}
3228
3229#[cfg(feature = "app-systemcalculator")]
3230impl<__T: ISystemCalculator_WeaponLevelCCommand> ISystemCalculator_WeaponLevelCCommandMethods for __T {}
3231
3232#[cfg(feature = "app-systemcalculator")]
3233impl SystemCalculator_WeaponLevelCCommand {
3234    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3235        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3236    }
3237
3238    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3239        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3240    }
3241
3242    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3243        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3244    }
3245}
3246
3247#[cfg(feature = "app-systemcalculator")]
3248impl SystemCalculator_WeaponLevelCCommand {
3249    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelCCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3250    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3251        let __mi = Self::get_name_method_info();
3252        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3253        __inner(this.into(), ::core::option::Option::None)
3254    }
3255
3256    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelCCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3257    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3258        let __mi = Self::get_method_info();
3259        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3260        __inner(this.into(), ::core::option::Option::None)
3261    }
3262}
3263
3264#[cfg(feature = "app-systemcalculator")]
3265impl SystemCalculator_WeaponLevelCCommand {
3266    #[doc = "`.ctor()` — no args"]
3267    pub fn new() -> Self {
3268        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3269            panic!(
3270                "{}
3271::{}
3272 failed to instantiate",
3273                ::core::stringify!(SystemCalculator_WeaponLevelCCommand),
3274                ::core::stringify!(new),
3275            )
3276        });
3277        <Self as ISystemCalculator_WeaponLevelCCommandMethods>::ctor(this);
3278        this
3279    }
3280}
3281
3282#[cfg(feature = "app-systemcalculator")]
3283pub trait ISystemCalculator_BattleSideOffenseCommandMethods: ISystemCalculator_BattleSideOffenseCommand {
3284    #[doc = "`get_Name()` overload"]
3285    fn get_name(self) -> ::unity::Il2CppString {
3286        unsafe {
3287            let __receiver = <SystemCalculator_BattleSideOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
3288                <Self as ::unity::SystemObject>::as_instance(self),
3289            );
3290            {
3291                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3292                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3293                    panic!(
3294                        "unity: virtual slot {}
3295 out of range (vtable len {}
3296) on the runtime class behind {}
3297 (method `{}
3298`)",
3299                        4usize,
3300                        __vt.len(),
3301                        <SystemCalculator_BattleSideOffenseCommand as ::unity::ClassIdentity>::NAME,
3302                        "get_Name",
3303                    )
3304                });
3305                let __inner: extern "C" fn(SystemCalculator_BattleSideOffenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3306                    ::core::mem::transmute(__vi.method_ptr);
3307                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3308                __inner(__receiver, __mi)
3309            }
3310        }
3311    }
3312    #[doc = "`Get()` overload"]
3313    fn get(self) -> f32 {
3314        unsafe {
3315            let __receiver = <SystemCalculator_BattleSideOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
3316                <Self as ::unity::SystemObject>::as_instance(self),
3317            );
3318            {
3319                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3320                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3321                    panic!(
3322                        "unity: virtual slot {}
3323 out of range (vtable len {}
3324) on the runtime class behind {}
3325 (method `{}
3326`)",
3327                        9usize,
3328                        __vt.len(),
3329                        <SystemCalculator_BattleSideOffenseCommand as ::unity::ClassIdentity>::NAME,
3330                        "Get",
3331                    )
3332                });
3333                let __inner: extern "C" fn(SystemCalculator_BattleSideOffenseCommand, ::unity::OptionalMethod) -> f32 =
3334                    ::core::mem::transmute(__vi.method_ptr);
3335                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3336                __inner(__receiver, __mi)
3337            }
3338        }
3339    }
3340    #[doc = "`.ctor()` overload"]
3341    fn ctor(self) -> () {
3342        unsafe {
3343            let __receiver = <SystemCalculator_BattleSideOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
3344                <Self as ::unity::SystemObject>::as_instance(self),
3345            );
3346            ::unity::il2cpp_call!((::unity::module_base()+0x21f8030usize)as*mut u8,();
3347(SystemCalculator_BattleSideOffenseCommand)__receiver)
3348        }
3349    }
3350}
3351
3352#[cfg(feature = "app-systemcalculator")]
3353impl<__T: ISystemCalculator_BattleSideOffenseCommand> ISystemCalculator_BattleSideOffenseCommandMethods for __T {}
3354
3355#[cfg(feature = "app-systemcalculator")]
3356impl SystemCalculator_BattleSideOffenseCommand {
3357    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3358        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3359    }
3360
3361    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3362        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3363    }
3364
3365    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3366        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3367    }
3368}
3369
3370#[cfg(feature = "app-systemcalculator")]
3371impl SystemCalculator_BattleSideOffenseCommand {
3372    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideOffenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3373    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3374        let __mi = Self::get_name_method_info();
3375        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3376        __inner(this.into(), ::core::option::Option::None)
3377    }
3378
3379    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideOffenseCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3380    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3381        let __mi = Self::get_method_info();
3382        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3383        __inner(this.into(), ::core::option::Option::None)
3384    }
3385}
3386
3387#[cfg(feature = "app-systemcalculator")]
3388impl SystemCalculator_BattleSideOffenseCommand {
3389    #[doc = "`.ctor()` — no args"]
3390    pub fn new() -> Self {
3391        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3392            panic!(
3393                "{}
3394::{}
3395 failed to instantiate",
3396                ::core::stringify!(SystemCalculator_BattleSideOffenseCommand),
3397                ::core::stringify!(new),
3398            )
3399        });
3400        <Self as ISystemCalculator_BattleSideOffenseCommandMethods>::ctor(this);
3401        this
3402    }
3403}
3404
3405#[cfg(feature = "app-systemcalculator")]
3406pub trait ISystemCalculator_DarkAttributeCommandMethods: ISystemCalculator_DarkAttributeCommand {
3407    #[doc = "`get_Name()` overload"]
3408    fn get_name(self) -> ::unity::Il2CppString {
3409        unsafe {
3410            let __receiver = <SystemCalculator_DarkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
3411                <Self as ::unity::SystemObject>::as_instance(self),
3412            );
3413            {
3414                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3415                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3416                    panic!(
3417                        "unity: virtual slot {}
3418 out of range (vtable len {}
3419) on the runtime class behind {}
3420 (method `{}
3421`)",
3422                        4usize,
3423                        __vt.len(),
3424                        <SystemCalculator_DarkAttributeCommand as ::unity::ClassIdentity>::NAME,
3425                        "get_Name",
3426                    )
3427                });
3428                let __inner: extern "C" fn(SystemCalculator_DarkAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3429                    ::core::mem::transmute(__vi.method_ptr);
3430                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3431                __inner(__receiver, __mi)
3432            }
3433        }
3434    }
3435    #[doc = "`Get()` overload"]
3436    fn get(self) -> f32 {
3437        unsafe {
3438            let __receiver = <SystemCalculator_DarkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
3439                <Self as ::unity::SystemObject>::as_instance(self),
3440            );
3441            {
3442                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3443                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3444                    panic!(
3445                        "unity: virtual slot {}
3446 out of range (vtable len {}
3447) on the runtime class behind {}
3448 (method `{}
3449`)",
3450                        9usize,
3451                        __vt.len(),
3452                        <SystemCalculator_DarkAttributeCommand as ::unity::ClassIdentity>::NAME,
3453                        "Get",
3454                    )
3455                });
3456                let __inner: extern "C" fn(SystemCalculator_DarkAttributeCommand, ::unity::OptionalMethod) -> f32 =
3457                    ::core::mem::transmute(__vi.method_ptr);
3458                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3459                __inner(__receiver, __mi)
3460            }
3461        }
3462    }
3463    #[doc = "`.ctor()` overload"]
3464    fn ctor(self) -> () {
3465        unsafe {
3466            let __receiver = <SystemCalculator_DarkAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
3467                <Self as ::unity::SystemObject>::as_instance(self),
3468            );
3469            ::unity::il2cpp_call!((::unity::module_base()+0x21f8270usize)as*mut u8,();
3470(SystemCalculator_DarkAttributeCommand)__receiver)
3471        }
3472    }
3473}
3474
3475#[cfg(feature = "app-systemcalculator")]
3476impl<__T: ISystemCalculator_DarkAttributeCommand> ISystemCalculator_DarkAttributeCommandMethods for __T {}
3477
3478#[cfg(feature = "app-systemcalculator")]
3479impl SystemCalculator_DarkAttributeCommand {
3480    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3481        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3482    }
3483
3484    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3485        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3486    }
3487
3488    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3489        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3490    }
3491}
3492
3493#[cfg(feature = "app-systemcalculator")]
3494impl SystemCalculator_DarkAttributeCommand {
3495    #[doc = "Direct (non-virtual) call to `SystemCalculator_DarkAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3496    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3497        let __mi = Self::get_name_method_info();
3498        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3499        __inner(this.into(), ::core::option::Option::None)
3500    }
3501
3502    #[doc = "Direct (non-virtual) call to `SystemCalculator_DarkAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3503    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3504        let __mi = Self::get_method_info();
3505        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3506        __inner(this.into(), ::core::option::Option::None)
3507    }
3508}
3509
3510#[cfg(feature = "app-systemcalculator")]
3511impl SystemCalculator_DarkAttributeCommand {
3512    #[doc = "`.ctor()` — no args"]
3513    pub fn new() -> Self {
3514        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3515            panic!(
3516                "{}
3517::{}
3518 failed to instantiate",
3519                ::core::stringify!(SystemCalculator_DarkAttributeCommand),
3520                ::core::stringify!(new),
3521            )
3522        });
3523        <Self as ISystemCalculator_DarkAttributeCommandMethods>::ctor(this);
3524        this
3525    }
3526}
3527
3528#[cfg(feature = "app-systemcalculator")]
3529pub trait ISystemCalculator_BattleStyleCommandMethods: ISystemCalculator_BattleStyleCommand {
3530    #[doc = "`get_Style()` overload"]
3531    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
3532        unsafe {
3533            let __receiver = <SystemCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(
3534                <Self as ::unity::SystemObject>::as_instance(self),
3535            );
3536            {
3537                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3538                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
3539                    panic!(
3540                        "unity: virtual slot {}
3541 out of range (vtable len {}
3542) on the runtime class behind {}
3543 (method `{}
3544`)",
3545                        30usize,
3546                        __vt.len(),
3547                        <SystemCalculator_BattleStyleCommand as ::unity::ClassIdentity>::NAME,
3548                        "get_Style",
3549                    )
3550                });
3551                let __inner: extern "C" fn(
3552                    SystemCalculator_BattleStyleCommand,
3553                    ::unity::OptionalMethod,
3554                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
3555                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3556                __inner(__receiver, __mi)
3557            }
3558        }
3559    }
3560    #[doc = "`get_Name()` overload"]
3561    fn get_name(self) -> ::unity::Il2CppString {
3562        unsafe {
3563            let __receiver = <SystemCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(
3564                <Self as ::unity::SystemObject>::as_instance(self),
3565            );
3566            {
3567                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3568                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3569                    panic!(
3570                        "unity: virtual slot {}
3571 out of range (vtable len {}
3572) on the runtime class behind {}
3573 (method `{}
3574`)",
3575                        4usize,
3576                        __vt.len(),
3577                        <SystemCalculator_BattleStyleCommand as ::unity::ClassIdentity>::NAME,
3578                        "get_Name",
3579                    )
3580                });
3581                let __inner: extern "C" fn(SystemCalculator_BattleStyleCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3582                    ::core::mem::transmute(__vi.method_ptr);
3583                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3584                __inner(__receiver, __mi)
3585            }
3586        }
3587    }
3588    #[doc = "`Get()` overload"]
3589    fn get(self) -> f32 {
3590        unsafe {
3591            let __receiver = <SystemCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(
3592                <Self as ::unity::SystemObject>::as_instance(self),
3593            );
3594            {
3595                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3596                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3597                    panic!(
3598                        "unity: virtual slot {}
3599 out of range (vtable len {}
3600) on the runtime class behind {}
3601 (method `{}
3602`)",
3603                        9usize,
3604                        __vt.len(),
3605                        <SystemCalculator_BattleStyleCommand as ::unity::ClassIdentity>::NAME,
3606                        "Get",
3607                    )
3608                });
3609                let __inner: extern "C" fn(SystemCalculator_BattleStyleCommand, ::unity::OptionalMethod) -> f32 =
3610                    ::core::mem::transmute(__vi.method_ptr);
3611                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3612                __inner(__receiver, __mi)
3613            }
3614        }
3615    }
3616    #[doc = "`.ctor()` overload"]
3617    fn ctor(self) -> () {
3618        unsafe {
3619            let __receiver = <SystemCalculator_BattleStyleCommand as ::unity::FromIlInstance>::from_il_instance(
3620                <Self as ::unity::SystemObject>::as_instance(self),
3621            );
3622            ::unity::il2cpp_call!((::unity::module_base()+0x21f8100usize)as*mut u8,();
3623(SystemCalculator_BattleStyleCommand)__receiver)
3624        }
3625    }
3626}
3627
3628#[cfg(feature = "app-systemcalculator")]
3629impl<__T: ISystemCalculator_BattleStyleCommand> ISystemCalculator_BattleStyleCommandMethods for __T {}
3630
3631#[cfg(feature = "app-systemcalculator")]
3632impl SystemCalculator_BattleStyleCommand {
3633    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3634        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3635    }
3636
3637    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3638        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3639    }
3640
3641    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3642        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3643    }
3644
3645    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3646        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3647    }
3648}
3649
3650#[cfg(feature = "app-systemcalculator")]
3651impl SystemCalculator_BattleStyleCommand {
3652    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3653    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
3654        let __mi = Self::get_style_method_info();
3655        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
3656            ::core::mem::transmute(__mi.method_ptr);
3657        __inner(this.into(), ::core::option::Option::None)
3658    }
3659
3660    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3661    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3662        let __mi = Self::get_name_method_info();
3663        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3664        __inner(this.into(), ::core::option::Option::None)
3665    }
3666
3667    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3668    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3669        let __mi = Self::get_method_info();
3670        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3671        __inner(this.into(), ::core::option::Option::None)
3672    }
3673}
3674
3675#[cfg(feature = "app-systemcalculator")]
3676impl SystemCalculator_BattleStyleCommand {
3677    #[doc = "`.ctor()` — no args"]
3678    pub fn new() -> Self {
3679        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3680            panic!(
3681                "{}
3682::{}
3683 failed to instantiate",
3684                ::core::stringify!(SystemCalculator_BattleStyleCommand),
3685                ::core::stringify!(new),
3686            )
3687        });
3688        <Self as ISystemCalculator_BattleStyleCommandMethods>::ctor(this);
3689        this
3690    }
3691}
3692
3693#[cfg(feature = "app-systemcalculator")]
3694pub trait ISystemCalculator_WeaponLevelBCommandMethods: ISystemCalculator_WeaponLevelBCommand {
3695    #[doc = "`get_Name()` overload"]
3696    fn get_name(self) -> ::unity::Il2CppString {
3697        unsafe {
3698            let __receiver = <SystemCalculator_WeaponLevelBCommand as ::unity::FromIlInstance>::from_il_instance(
3699                <Self as ::unity::SystemObject>::as_instance(self),
3700            );
3701            {
3702                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3703                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3704                    panic!(
3705                        "unity: virtual slot {}
3706 out of range (vtable len {}
3707) on the runtime class behind {}
3708 (method `{}
3709`)",
3710                        4usize,
3711                        __vt.len(),
3712                        <SystemCalculator_WeaponLevelBCommand as ::unity::ClassIdentity>::NAME,
3713                        "get_Name",
3714                    )
3715                });
3716                let __inner: extern "C" fn(SystemCalculator_WeaponLevelBCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3717                    ::core::mem::transmute(__vi.method_ptr);
3718                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3719                __inner(__receiver, __mi)
3720            }
3721        }
3722    }
3723    #[doc = "`Get()` overload"]
3724    fn get(self) -> f32 {
3725        unsafe {
3726            let __receiver = <SystemCalculator_WeaponLevelBCommand as ::unity::FromIlInstance>::from_il_instance(
3727                <Self as ::unity::SystemObject>::as_instance(self),
3728            );
3729            {
3730                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3731                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3732                    panic!(
3733                        "unity: virtual slot {}
3734 out of range (vtable len {}
3735) on the runtime class behind {}
3736 (method `{}
3737`)",
3738                        9usize,
3739                        __vt.len(),
3740                        <SystemCalculator_WeaponLevelBCommand as ::unity::ClassIdentity>::NAME,
3741                        "Get",
3742                    )
3743                });
3744                let __inner: extern "C" fn(SystemCalculator_WeaponLevelBCommand, ::unity::OptionalMethod) -> f32 =
3745                    ::core::mem::transmute(__vi.method_ptr);
3746                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3747                __inner(__receiver, __mi)
3748            }
3749        }
3750    }
3751    #[doc = "`.ctor()` overload"]
3752    fn ctor(self) -> () {
3753        unsafe {
3754            let __receiver = <SystemCalculator_WeaponLevelBCommand as ::unity::FromIlInstance>::from_il_instance(
3755                <Self as ::unity::SystemObject>::as_instance(self),
3756            );
3757            ::unity::il2cpp_call!((::unity::module_base()+0x21f9d50usize)as*mut u8,();
3758(SystemCalculator_WeaponLevelBCommand)__receiver)
3759        }
3760    }
3761}
3762
3763#[cfg(feature = "app-systemcalculator")]
3764impl<__T: ISystemCalculator_WeaponLevelBCommand> ISystemCalculator_WeaponLevelBCommandMethods for __T {}
3765
3766#[cfg(feature = "app-systemcalculator")]
3767impl SystemCalculator_WeaponLevelBCommand {
3768    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3769        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3770    }
3771
3772    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3773        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3774    }
3775
3776    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3777        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3778    }
3779}
3780
3781#[cfg(feature = "app-systemcalculator")]
3782impl SystemCalculator_WeaponLevelBCommand {
3783    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelBCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3784    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3785        let __mi = Self::get_name_method_info();
3786        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3787        __inner(this.into(), ::core::option::Option::None)
3788    }
3789
3790    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelBCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3791    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3792        let __mi = Self::get_method_info();
3793        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3794        __inner(this.into(), ::core::option::Option::None)
3795    }
3796}
3797
3798#[cfg(feature = "app-systemcalculator")]
3799impl SystemCalculator_WeaponLevelBCommand {
3800    #[doc = "`.ctor()` — no args"]
3801    pub fn new() -> Self {
3802        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3803            panic!(
3804                "{}
3805::{}
3806 failed to instantiate",
3807                ::core::stringify!(SystemCalculator_WeaponLevelBCommand),
3808                ::core::stringify!(new),
3809            )
3810        });
3811        <Self as ISystemCalculator_WeaponLevelBCommandMethods>::ctor(this);
3812        this
3813    }
3814}
3815
3816#[cfg(feature = "app-systemcalculator")]
3817pub trait ISystemCalculator_ItemKindSwordCommandMethods: ISystemCalculator_ItemKindSwordCommand {
3818    #[doc = "`get_Name()` overload"]
3819    fn get_name(self) -> ::unity::Il2CppString {
3820        unsafe {
3821            let __receiver = <SystemCalculator_ItemKindSwordCommand as ::unity::FromIlInstance>::from_il_instance(
3822                <Self as ::unity::SystemObject>::as_instance(self),
3823            );
3824            {
3825                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3826                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3827                    panic!(
3828                        "unity: virtual slot {}
3829 out of range (vtable len {}
3830) on the runtime class behind {}
3831 (method `{}
3832`)",
3833                        4usize,
3834                        __vt.len(),
3835                        <SystemCalculator_ItemKindSwordCommand as ::unity::ClassIdentity>::NAME,
3836                        "get_Name",
3837                    )
3838                });
3839                let __inner: extern "C" fn(SystemCalculator_ItemKindSwordCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3840                    ::core::mem::transmute(__vi.method_ptr);
3841                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3842                __inner(__receiver, __mi)
3843            }
3844        }
3845    }
3846    #[doc = "`Get()` overload"]
3847    fn get(self) -> f32 {
3848        unsafe {
3849            let __receiver = <SystemCalculator_ItemKindSwordCommand as ::unity::FromIlInstance>::from_il_instance(
3850                <Self as ::unity::SystemObject>::as_instance(self),
3851            );
3852            {
3853                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3854                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3855                    panic!(
3856                        "unity: virtual slot {}
3857 out of range (vtable len {}
3858) on the runtime class behind {}
3859 (method `{}
3860`)",
3861                        9usize,
3862                        __vt.len(),
3863                        <SystemCalculator_ItemKindSwordCommand as ::unity::ClassIdentity>::NAME,
3864                        "Get",
3865                    )
3866                });
3867                let __inner: extern "C" fn(SystemCalculator_ItemKindSwordCommand, ::unity::OptionalMethod) -> f32 =
3868                    ::core::mem::transmute(__vi.method_ptr);
3869                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3870                __inner(__receiver, __mi)
3871            }
3872        }
3873    }
3874    #[doc = "`.ctor()` overload"]
3875    fn ctor(self) -> () {
3876        unsafe {
3877            let __receiver = <SystemCalculator_ItemKindSwordCommand as ::unity::FromIlInstance>::from_il_instance(
3878                <Self as ::unity::SystemObject>::as_instance(self),
3879            );
3880            ::unity::il2cpp_call!((::unity::module_base()+0x21f8f30usize)as*mut u8,();
3881(SystemCalculator_ItemKindSwordCommand)__receiver)
3882        }
3883    }
3884}
3885
3886#[cfg(feature = "app-systemcalculator")]
3887impl<__T: ISystemCalculator_ItemKindSwordCommand> ISystemCalculator_ItemKindSwordCommandMethods for __T {}
3888
3889#[cfg(feature = "app-systemcalculator")]
3890impl SystemCalculator_ItemKindSwordCommand {
3891    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3892        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3893    }
3894
3895    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3896        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3897    }
3898
3899    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3900        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3901    }
3902}
3903
3904#[cfg(feature = "app-systemcalculator")]
3905impl SystemCalculator_ItemKindSwordCommand {
3906    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindSwordCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3907    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3908        let __mi = Self::get_name_method_info();
3909        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3910        __inner(this.into(), ::core::option::Option::None)
3911    }
3912
3913    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindSwordCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3914    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3915        let __mi = Self::get_method_info();
3916        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3917        __inner(this.into(), ::core::option::Option::None)
3918    }
3919}
3920
3921#[cfg(feature = "app-systemcalculator")]
3922impl SystemCalculator_ItemKindSwordCommand {
3923    #[doc = "`.ctor()` — no args"]
3924    pub fn new() -> Self {
3925        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3926            panic!(
3927                "{}
3928::{}
3929 failed to instantiate",
3930                ::core::stringify!(SystemCalculator_ItemKindSwordCommand),
3931                ::core::stringify!(new),
3932            )
3933        });
3934        <Self as ISystemCalculator_ItemKindSwordCommandMethods>::ctor(this);
3935        this
3936    }
3937}
3938
3939#[cfg(feature = "app-systemcalculator")]
3940pub trait ISystemCalculator_ItemKindRodCommandMethods: ISystemCalculator_ItemKindRodCommand {
3941    #[doc = "`get_Name()` overload"]
3942    fn get_name(self) -> ::unity::Il2CppString {
3943        unsafe {
3944            let __receiver = <SystemCalculator_ItemKindRodCommand as ::unity::FromIlInstance>::from_il_instance(
3945                <Self as ::unity::SystemObject>::as_instance(self),
3946            );
3947            {
3948                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3949                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3950                    panic!(
3951                        "unity: virtual slot {}
3952 out of range (vtable len {}
3953) on the runtime class behind {}
3954 (method `{}
3955`)",
3956                        4usize,
3957                        __vt.len(),
3958                        <SystemCalculator_ItemKindRodCommand as ::unity::ClassIdentity>::NAME,
3959                        "get_Name",
3960                    )
3961                });
3962                let __inner: extern "C" fn(SystemCalculator_ItemKindRodCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3963                    ::core::mem::transmute(__vi.method_ptr);
3964                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3965                __inner(__receiver, __mi)
3966            }
3967        }
3968    }
3969    #[doc = "`Get()` overload"]
3970    fn get(self) -> f32 {
3971        unsafe {
3972            let __receiver = <SystemCalculator_ItemKindRodCommand as ::unity::FromIlInstance>::from_il_instance(
3973                <Self as ::unity::SystemObject>::as_instance(self),
3974            );
3975            {
3976                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3977                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3978                    panic!(
3979                        "unity: virtual slot {}
3980 out of range (vtable len {}
3981) on the runtime class behind {}
3982 (method `{}
3983`)",
3984                        9usize,
3985                        __vt.len(),
3986                        <SystemCalculator_ItemKindRodCommand as ::unity::ClassIdentity>::NAME,
3987                        "Get",
3988                    )
3989                });
3990                let __inner: extern "C" fn(SystemCalculator_ItemKindRodCommand, ::unity::OptionalMethod) -> f32 =
3991                    ::core::mem::transmute(__vi.method_ptr);
3992                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3993                __inner(__receiver, __mi)
3994            }
3995        }
3996    }
3997    #[doc = "`.ctor()` overload"]
3998    fn ctor(self) -> () {
3999        unsafe {
4000            let __receiver = <SystemCalculator_ItemKindRodCommand as ::unity::FromIlInstance>::from_il_instance(
4001                <Self as ::unity::SystemObject>::as_instance(self),
4002            );
4003            ::unity::il2cpp_call!((::unity::module_base()+0x21f8e50usize)as*mut u8,();
4004(SystemCalculator_ItemKindRodCommand)__receiver)
4005        }
4006    }
4007}
4008
4009#[cfg(feature = "app-systemcalculator")]
4010impl<__T: ISystemCalculator_ItemKindRodCommand> ISystemCalculator_ItemKindRodCommandMethods for __T {}
4011
4012#[cfg(feature = "app-systemcalculator")]
4013impl SystemCalculator_ItemKindRodCommand {
4014    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4015        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4016    }
4017
4018    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4019        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4020    }
4021
4022    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4023        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4024    }
4025}
4026
4027#[cfg(feature = "app-systemcalculator")]
4028impl SystemCalculator_ItemKindRodCommand {
4029    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindRodCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4030    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4031        let __mi = Self::get_name_method_info();
4032        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4033        __inner(this.into(), ::core::option::Option::None)
4034    }
4035
4036    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindRodCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4037    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4038        let __mi = Self::get_method_info();
4039        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4040        __inner(this.into(), ::core::option::Option::None)
4041    }
4042}
4043
4044#[cfg(feature = "app-systemcalculator")]
4045impl SystemCalculator_ItemKindRodCommand {
4046    #[doc = "`.ctor()` — no args"]
4047    pub fn new() -> Self {
4048        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4049            panic!(
4050                "{}
4051::{}
4052 failed to instantiate",
4053                ::core::stringify!(SystemCalculator_ItemKindRodCommand),
4054                ::core::stringify!(new),
4055            )
4056        });
4057        <Self as ISystemCalculator_ItemKindRodCommandMethods>::ctor(this);
4058        this
4059    }
4060}
4061
4062#[cfg(feature = "app-systemcalculator")]
4063pub trait ISystemCalculator_BattleSideChainOffenseCommandMethods: ISystemCalculator_BattleSideChainOffenseCommand {
4064    #[doc = "`get_Name()` overload"]
4065    fn get_name(self) -> ::unity::Il2CppString {
4066        unsafe {
4067            let __receiver = <SystemCalculator_BattleSideChainOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
4068                <Self as ::unity::SystemObject>::as_instance(self),
4069            );
4070            {
4071                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4072                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4073                    panic!(
4074                        "unity: virtual slot {}
4075 out of range (vtable len {}
4076) on the runtime class behind {}
4077 (method `{}
4078`)",
4079                        4usize,
4080                        __vt.len(),
4081                        <SystemCalculator_BattleSideChainOffenseCommand as ::unity::ClassIdentity>::NAME,
4082                        "get_Name",
4083                    )
4084                });
4085                let __inner: extern "C" fn(SystemCalculator_BattleSideChainOffenseCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4086                    ::core::mem::transmute(__vi.method_ptr);
4087                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4088                __inner(__receiver, __mi)
4089            }
4090        }
4091    }
4092    #[doc = "`Get()` overload"]
4093    fn get(self) -> f32 {
4094        unsafe {
4095            let __receiver = <SystemCalculator_BattleSideChainOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
4096                <Self as ::unity::SystemObject>::as_instance(self),
4097            );
4098            {
4099                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4100                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4101                    panic!(
4102                        "unity: virtual slot {}
4103 out of range (vtable len {}
4104) on the runtime class behind {}
4105 (method `{}
4106`)",
4107                        9usize,
4108                        __vt.len(),
4109                        <SystemCalculator_BattleSideChainOffenseCommand as ::unity::ClassIdentity>::NAME,
4110                        "Get",
4111                    )
4112                });
4113                let __inner: extern "C" fn(SystemCalculator_BattleSideChainOffenseCommand, ::unity::OptionalMethod) -> f32 =
4114                    ::core::mem::transmute(__vi.method_ptr);
4115                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4116                __inner(__receiver, __mi)
4117            }
4118        }
4119    }
4120    #[doc = "`.ctor()` overload"]
4121    fn ctor(self) -> () {
4122        unsafe {
4123            let __receiver = <SystemCalculator_BattleSideChainOffenseCommand as ::unity::FromIlInstance>::from_il_instance(
4124                <Self as ::unity::SystemObject>::as_instance(self),
4125            );
4126            ::unity::il2cpp_call!((::unity::module_base()+0x21f7f50usize)as*mut u8,();
4127(SystemCalculator_BattleSideChainOffenseCommand)__receiver)
4128        }
4129    }
4130}
4131
4132#[cfg(feature = "app-systemcalculator")]
4133impl<__T: ISystemCalculator_BattleSideChainOffenseCommand> ISystemCalculator_BattleSideChainOffenseCommandMethods for __T {}
4134
4135#[cfg(feature = "app-systemcalculator")]
4136impl SystemCalculator_BattleSideChainOffenseCommand {
4137    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4138        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4139    }
4140
4141    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4142        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4143    }
4144
4145    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4146        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4147    }
4148}
4149
4150#[cfg(feature = "app-systemcalculator")]
4151impl SystemCalculator_BattleSideChainOffenseCommand {
4152    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideChainOffenseCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4153    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4154        let __mi = Self::get_name_method_info();
4155        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4156        __inner(this.into(), ::core::option::Option::None)
4157    }
4158
4159    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleSideChainOffenseCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4160    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4161        let __mi = Self::get_method_info();
4162        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4163        __inner(this.into(), ::core::option::Option::None)
4164    }
4165}
4166
4167#[cfg(feature = "app-systemcalculator")]
4168impl SystemCalculator_BattleSideChainOffenseCommand {
4169    #[doc = "`.ctor()` — no args"]
4170    pub fn new() -> Self {
4171        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4172            panic!(
4173                "{}
4174::{}
4175 failed to instantiate",
4176                ::core::stringify!(SystemCalculator_BattleSideChainOffenseCommand),
4177                ::core::stringify!(new),
4178            )
4179        });
4180        <Self as ISystemCalculator_BattleSideChainOffenseCommandMethods>::ctor(this);
4181        this
4182    }
4183}
4184
4185#[cfg(feature = "app-systemcalculator")]
4186pub trait ISystemCalculator_HeavyAttributeCommandMethods: ISystemCalculator_HeavyAttributeCommand {
4187    #[doc = "`get_Name()` overload"]
4188    fn get_name(self) -> ::unity::Il2CppString {
4189        unsafe {
4190            let __receiver = <SystemCalculator_HeavyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4191                <Self as ::unity::SystemObject>::as_instance(self),
4192            );
4193            {
4194                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4195                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4196                    panic!(
4197                        "unity: virtual slot {}
4198 out of range (vtable len {}
4199) on the runtime class behind {}
4200 (method `{}
4201`)",
4202                        4usize,
4203                        __vt.len(),
4204                        <SystemCalculator_HeavyAttributeCommand as ::unity::ClassIdentity>::NAME,
4205                        "get_Name",
4206                    )
4207                });
4208                let __inner: extern "C" fn(SystemCalculator_HeavyAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4209                    ::core::mem::transmute(__vi.method_ptr);
4210                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4211                __inner(__receiver, __mi)
4212            }
4213        }
4214    }
4215    #[doc = "`Get()` overload"]
4216    fn get(self) -> f32 {
4217        unsafe {
4218            let __receiver = <SystemCalculator_HeavyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4219                <Self as ::unity::SystemObject>::as_instance(self),
4220            );
4221            {
4222                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4223                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4224                    panic!(
4225                        "unity: virtual slot {}
4226 out of range (vtable len {}
4227) on the runtime class behind {}
4228 (method `{}
4229`)",
4230                        9usize,
4231                        __vt.len(),
4232                        <SystemCalculator_HeavyAttributeCommand as ::unity::ClassIdentity>::NAME,
4233                        "Get",
4234                    )
4235                });
4236                let __inner: extern "C" fn(SystemCalculator_HeavyAttributeCommand, ::unity::OptionalMethod) -> f32 =
4237                    ::core::mem::transmute(__vi.method_ptr);
4238                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4239                __inner(__receiver, __mi)
4240            }
4241        }
4242    }
4243    #[doc = "`.ctor()` overload"]
4244    fn ctor(self) -> () {
4245        unsafe {
4246            let __receiver = <SystemCalculator_HeavyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4247                <Self as ::unity::SystemObject>::as_instance(self),
4248            );
4249            ::unity::il2cpp_call!((::unity::module_base()+0x21f8970usize)as*mut u8,();
4250(SystemCalculator_HeavyAttributeCommand)__receiver)
4251        }
4252    }
4253}
4254
4255#[cfg(feature = "app-systemcalculator")]
4256impl<__T: ISystemCalculator_HeavyAttributeCommand> ISystemCalculator_HeavyAttributeCommandMethods for __T {}
4257
4258#[cfg(feature = "app-systemcalculator")]
4259impl SystemCalculator_HeavyAttributeCommand {
4260    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4261        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4262    }
4263
4264    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4265        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4266    }
4267
4268    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4269        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4270    }
4271}
4272
4273#[cfg(feature = "app-systemcalculator")]
4274impl SystemCalculator_HeavyAttributeCommand {
4275    #[doc = "Direct (non-virtual) call to `SystemCalculator_HeavyAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4276    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4277        let __mi = Self::get_name_method_info();
4278        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4279        __inner(this.into(), ::core::option::Option::None)
4280    }
4281
4282    #[doc = "Direct (non-virtual) call to `SystemCalculator_HeavyAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4283    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4284        let __mi = Self::get_method_info();
4285        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4286        __inner(this.into(), ::core::option::Option::None)
4287    }
4288}
4289
4290#[cfg(feature = "app-systemcalculator")]
4291impl SystemCalculator_HeavyAttributeCommand {
4292    #[doc = "`.ctor()` — no args"]
4293    pub fn new() -> Self {
4294        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4295            panic!(
4296                "{}
4297::{}
4298 failed to instantiate",
4299                ::core::stringify!(SystemCalculator_HeavyAttributeCommand),
4300                ::core::stringify!(new),
4301            )
4302        });
4303        <Self as ISystemCalculator_HeavyAttributeCommandMethods>::ctor(this);
4304        this
4305    }
4306}
4307
4308#[cfg(feature = "app-systemcalculator")]
4309pub trait ISystemCalculator_BattleStyleFlyCommandMethods: ISystemCalculator_BattleStyleFlyCommand {
4310    #[doc = "`get_Style()` overload"]
4311    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
4312        unsafe {
4313            let __receiver = <SystemCalculator_BattleStyleFlyCommand as ::unity::FromIlInstance>::from_il_instance(
4314                <Self as ::unity::SystemObject>::as_instance(self),
4315            );
4316            {
4317                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4318                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4319                    panic!(
4320                        "unity: virtual slot {}
4321 out of range (vtable len {}
4322) on the runtime class behind {}
4323 (method `{}
4324`)",
4325                        30usize,
4326                        __vt.len(),
4327                        <SystemCalculator_BattleStyleFlyCommand as ::unity::ClassIdentity>::NAME,
4328                        "get_Style",
4329                    )
4330                });
4331                let __inner: extern "C" fn(
4332                    SystemCalculator_BattleStyleFlyCommand,
4333                    ::unity::OptionalMethod,
4334                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
4335                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4336                __inner(__receiver, __mi)
4337            }
4338        }
4339    }
4340    #[doc = "`.ctor()` overload"]
4341    fn ctor(self) -> () {
4342        unsafe {
4343            let __receiver = <SystemCalculator_BattleStyleFlyCommand as ::unity::FromIlInstance>::from_il_instance(
4344                <Self as ::unity::SystemObject>::as_instance(self),
4345            );
4346            ::unity::il2cpp_call!((::unity::module_base()+0x21f8180usize)as*mut u8,();
4347(SystemCalculator_BattleStyleFlyCommand)__receiver)
4348        }
4349    }
4350}
4351
4352#[cfg(feature = "app-systemcalculator")]
4353impl<__T: ISystemCalculator_BattleStyleFlyCommand> ISystemCalculator_BattleStyleFlyCommandMethods for __T {}
4354
4355#[cfg(feature = "app-systemcalculator")]
4356impl SystemCalculator_BattleStyleFlyCommand {
4357    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4358        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4359    }
4360
4361    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4362        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4363    }
4364}
4365
4366#[cfg(feature = "app-systemcalculator")]
4367impl SystemCalculator_BattleStyleFlyCommand {
4368    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleFlyCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4369    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
4370        let __mi = Self::get_style_method_info();
4371        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
4372            ::core::mem::transmute(__mi.method_ptr);
4373        __inner(this.into(), ::core::option::Option::None)
4374    }
4375}
4376
4377#[cfg(feature = "app-systemcalculator")]
4378impl SystemCalculator_BattleStyleFlyCommand {
4379    #[doc = "`.ctor()` — no args"]
4380    pub fn new() -> Self {
4381        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4382            panic!(
4383                "{}
4384::{}
4385 failed to instantiate",
4386                ::core::stringify!(SystemCalculator_BattleStyleFlyCommand),
4387                ::core::stringify!(new),
4388            )
4389        });
4390        <Self as ISystemCalculator_BattleStyleFlyCommandMethods>::ctor(this);
4391        this
4392    }
4393}
4394
4395#[cfg(feature = "app-systemcalculator")]
4396pub trait ISystemCalculator_GenderMaleCommandMethods: ISystemCalculator_GenderMaleCommand {
4397    #[doc = "`get_Name()` overload"]
4398    fn get_name(self) -> ::unity::Il2CppString {
4399        unsafe {
4400            let __receiver =
4401                <SystemCalculator_GenderMaleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4402            {
4403                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4404                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4405                    panic!(
4406                        "unity: virtual slot {}
4407 out of range (vtable len {}
4408) on the runtime class behind {}
4409 (method `{}
4410`)",
4411                        4usize,
4412                        __vt.len(),
4413                        <SystemCalculator_GenderMaleCommand as ::unity::ClassIdentity>::NAME,
4414                        "get_Name",
4415                    )
4416                });
4417                let __inner: extern "C" fn(SystemCalculator_GenderMaleCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4418                    ::core::mem::transmute(__vi.method_ptr);
4419                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4420                __inner(__receiver, __mi)
4421            }
4422        }
4423    }
4424    #[doc = "`Get()` overload"]
4425    fn get(self) -> f32 {
4426        unsafe {
4427            let __receiver =
4428                <SystemCalculator_GenderMaleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4429            {
4430                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4431                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4432                    panic!(
4433                        "unity: virtual slot {}
4434 out of range (vtable len {}
4435) on the runtime class behind {}
4436 (method `{}
4437`)",
4438                        9usize,
4439                        __vt.len(),
4440                        <SystemCalculator_GenderMaleCommand as ::unity::ClassIdentity>::NAME,
4441                        "Get",
4442                    )
4443                });
4444                let __inner: extern "C" fn(SystemCalculator_GenderMaleCommand, ::unity::OptionalMethod) -> f32 =
4445                    ::core::mem::transmute(__vi.method_ptr);
4446                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4447                __inner(__receiver, __mi)
4448            }
4449        }
4450    }
4451    #[doc = "`.ctor()` overload"]
4452    fn ctor(self) -> () {
4453        unsafe {
4454            let __receiver =
4455                <SystemCalculator_GenderMaleCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4456            ::unity::il2cpp_call!((::unity::module_base()+0x21f8890usize)as*mut u8,();
4457(SystemCalculator_GenderMaleCommand)__receiver)
4458        }
4459    }
4460}
4461
4462#[cfg(feature = "app-systemcalculator")]
4463impl<__T: ISystemCalculator_GenderMaleCommand> ISystemCalculator_GenderMaleCommandMethods for __T {}
4464
4465#[cfg(feature = "app-systemcalculator")]
4466impl SystemCalculator_GenderMaleCommand {
4467    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4468        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4469    }
4470
4471    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4472        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4473    }
4474
4475    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4476        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4477    }
4478}
4479
4480#[cfg(feature = "app-systemcalculator")]
4481impl SystemCalculator_GenderMaleCommand {
4482    #[doc = "Direct (non-virtual) call to `SystemCalculator_GenderMaleCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4483    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4484        let __mi = Self::get_name_method_info();
4485        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4486        __inner(this.into(), ::core::option::Option::None)
4487    }
4488
4489    #[doc = "Direct (non-virtual) call to `SystemCalculator_GenderMaleCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4490    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4491        let __mi = Self::get_method_info();
4492        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4493        __inner(this.into(), ::core::option::Option::None)
4494    }
4495}
4496
4497#[cfg(feature = "app-systemcalculator")]
4498impl SystemCalculator_GenderMaleCommand {
4499    #[doc = "`.ctor()` — no args"]
4500    pub fn new() -> Self {
4501        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4502            panic!(
4503                "{}
4504::{}
4505 failed to instantiate",
4506                ::core::stringify!(SystemCalculator_GenderMaleCommand),
4507                ::core::stringify!(new),
4508            )
4509        });
4510        <Self as ISystemCalculator_GenderMaleCommandMethods>::ctor(this);
4511        this
4512    }
4513}
4514
4515#[cfg(feature = "app-systemcalculator")]
4516pub trait ISystemCalculator_MagicAttributeCommandMethods: ISystemCalculator_MagicAttributeCommand {
4517    #[doc = "`get_Name()` overload"]
4518    fn get_name(self) -> ::unity::Il2CppString {
4519        unsafe {
4520            let __receiver = <SystemCalculator_MagicAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4521                <Self as ::unity::SystemObject>::as_instance(self),
4522            );
4523            {
4524                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4525                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4526                    panic!(
4527                        "unity: virtual slot {}
4528 out of range (vtable len {}
4529) on the runtime class behind {}
4530 (method `{}
4531`)",
4532                        4usize,
4533                        __vt.len(),
4534                        <SystemCalculator_MagicAttributeCommand as ::unity::ClassIdentity>::NAME,
4535                        "get_Name",
4536                    )
4537                });
4538                let __inner: extern "C" fn(SystemCalculator_MagicAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4539                    ::core::mem::transmute(__vi.method_ptr);
4540                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4541                __inner(__receiver, __mi)
4542            }
4543        }
4544    }
4545    #[doc = "`Get()` overload"]
4546    fn get(self) -> f32 {
4547        unsafe {
4548            let __receiver = <SystemCalculator_MagicAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4549                <Self as ::unity::SystemObject>::as_instance(self),
4550            );
4551            {
4552                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4553                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4554                    panic!(
4555                        "unity: virtual slot {}
4556 out of range (vtable len {}
4557) on the runtime class behind {}
4558 (method `{}
4559`)",
4560                        9usize,
4561                        __vt.len(),
4562                        <SystemCalculator_MagicAttributeCommand as ::unity::ClassIdentity>::NAME,
4563                        "Get",
4564                    )
4565                });
4566                let __inner: extern "C" fn(SystemCalculator_MagicAttributeCommand, ::unity::OptionalMethod) -> f32 =
4567                    ::core::mem::transmute(__vi.method_ptr);
4568                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4569                __inner(__receiver, __mi)
4570            }
4571        }
4572    }
4573    #[doc = "`.ctor()` overload"]
4574    fn ctor(self) -> () {
4575        unsafe {
4576            let __receiver = <SystemCalculator_MagicAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
4577                <Self as ::unity::SystemObject>::as_instance(self),
4578            );
4579            ::unity::il2cpp_call!((::unity::module_base()+0x21f91e0usize)as*mut u8,();
4580(SystemCalculator_MagicAttributeCommand)__receiver)
4581        }
4582    }
4583}
4584
4585#[cfg(feature = "app-systemcalculator")]
4586impl<__T: ISystemCalculator_MagicAttributeCommand> ISystemCalculator_MagicAttributeCommandMethods for __T {}
4587
4588#[cfg(feature = "app-systemcalculator")]
4589impl SystemCalculator_MagicAttributeCommand {
4590    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4591        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4592    }
4593
4594    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4595        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4596    }
4597
4598    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4599        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4600    }
4601}
4602
4603#[cfg(feature = "app-systemcalculator")]
4604impl SystemCalculator_MagicAttributeCommand {
4605    #[doc = "Direct (non-virtual) call to `SystemCalculator_MagicAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4606    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4607        let __mi = Self::get_name_method_info();
4608        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4609        __inner(this.into(), ::core::option::Option::None)
4610    }
4611
4612    #[doc = "Direct (non-virtual) call to `SystemCalculator_MagicAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4613    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4614        let __mi = Self::get_method_info();
4615        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4616        __inner(this.into(), ::core::option::Option::None)
4617    }
4618}
4619
4620#[cfg(feature = "app-systemcalculator")]
4621impl SystemCalculator_MagicAttributeCommand {
4622    #[doc = "`.ctor()` — no args"]
4623    pub fn new() -> Self {
4624        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4625            panic!(
4626                "{}
4627::{}
4628 failed to instantiate",
4629                ::core::stringify!(SystemCalculator_MagicAttributeCommand),
4630                ::core::stringify!(new),
4631            )
4632        });
4633        <Self as ISystemCalculator_MagicAttributeCommandMethods>::ctor(this);
4634        this
4635    }
4636}
4637
4638#[cfg(feature = "app-systemcalculator")]
4639pub trait ISystemCalculator_Force1stCommandMethods: ISystemCalculator_Force1stCommand {
4640    #[doc = "`get_Name()` overload"]
4641    fn get_name(self) -> ::unity::Il2CppString {
4642        unsafe {
4643            let __receiver =
4644                <SystemCalculator_Force1stCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4645            {
4646                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4647                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4648                    panic!(
4649                        "unity: virtual slot {}
4650 out of range (vtable len {}
4651) on the runtime class behind {}
4652 (method `{}
4653`)",
4654                        4usize,
4655                        __vt.len(),
4656                        <SystemCalculator_Force1stCommand as ::unity::ClassIdentity>::NAME,
4657                        "get_Name",
4658                    )
4659                });
4660                let __inner: extern "C" fn(SystemCalculator_Force1stCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4661                    ::core::mem::transmute(__vi.method_ptr);
4662                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4663                __inner(__receiver, __mi)
4664            }
4665        }
4666    }
4667    #[doc = "`Get()` overload"]
4668    fn get(self) -> f32 {
4669        unsafe {
4670            let __receiver =
4671                <SystemCalculator_Force1stCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4672            {
4673                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4674                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4675                    panic!(
4676                        "unity: virtual slot {}
4677 out of range (vtable len {}
4678) on the runtime class behind {}
4679 (method `{}
4680`)",
4681                        9usize,
4682                        __vt.len(),
4683                        <SystemCalculator_Force1stCommand as ::unity::ClassIdentity>::NAME,
4684                        "Get",
4685                    )
4686                });
4687                let __inner: extern "C" fn(SystemCalculator_Force1stCommand, ::unity::OptionalMethod) -> f32 =
4688                    ::core::mem::transmute(__vi.method_ptr);
4689                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4690                __inner(__receiver, __mi)
4691            }
4692        }
4693    }
4694    #[doc = "`.ctor()` overload"]
4695    fn ctor(self) -> () {
4696        unsafe {
4697            let __receiver =
4698                <SystemCalculator_Force1stCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4699            ::unity::il2cpp_call!((::unity::module_base()+0x21f85f0usize)as*mut u8,();
4700(SystemCalculator_Force1stCommand)__receiver)
4701        }
4702    }
4703}
4704
4705#[cfg(feature = "app-systemcalculator")]
4706impl<__T: ISystemCalculator_Force1stCommand> ISystemCalculator_Force1stCommandMethods for __T {}
4707
4708#[cfg(feature = "app-systemcalculator")]
4709impl SystemCalculator_Force1stCommand {
4710    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4711        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4712    }
4713
4714    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4715        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4716    }
4717
4718    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4719        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4720    }
4721}
4722
4723#[cfg(feature = "app-systemcalculator")]
4724impl SystemCalculator_Force1stCommand {
4725    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force1stCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4726    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4727        let __mi = Self::get_name_method_info();
4728        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4729        __inner(this.into(), ::core::option::Option::None)
4730    }
4731
4732    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force1stCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4733    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4734        let __mi = Self::get_method_info();
4735        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4736        __inner(this.into(), ::core::option::Option::None)
4737    }
4738}
4739
4740#[cfg(feature = "app-systemcalculator")]
4741impl SystemCalculator_Force1stCommand {
4742    #[doc = "`.ctor()` — no args"]
4743    pub fn new() -> Self {
4744        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4745            panic!(
4746                "{}
4747::{}
4748 failed to instantiate",
4749                ::core::stringify!(SystemCalculator_Force1stCommand),
4750                ::core::stringify!(new),
4751            )
4752        });
4753        <Self as ISystemCalculator_Force1stCommandMethods>::ctor(this);
4754        this
4755    }
4756}
4757
4758#[cfg(feature = "app-systemcalculator")]
4759pub trait ISystemCalculator_PhaseCurrentCommandMethods: ISystemCalculator_PhaseCurrentCommand {
4760    #[doc = "`get_Name()` overload"]
4761    fn get_name(self) -> ::unity::Il2CppString {
4762        unsafe {
4763            let __receiver = <SystemCalculator_PhaseCurrentCommand as ::unity::FromIlInstance>::from_il_instance(
4764                <Self as ::unity::SystemObject>::as_instance(self),
4765            );
4766            {
4767                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4768                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4769                    panic!(
4770                        "unity: virtual slot {}
4771 out of range (vtable len {}
4772) on the runtime class behind {}
4773 (method `{}
4774`)",
4775                        4usize,
4776                        __vt.len(),
4777                        <SystemCalculator_PhaseCurrentCommand as ::unity::ClassIdentity>::NAME,
4778                        "get_Name",
4779                    )
4780                });
4781                let __inner: extern "C" fn(SystemCalculator_PhaseCurrentCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4782                    ::core::mem::transmute(__vi.method_ptr);
4783                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4784                __inner(__receiver, __mi)
4785            }
4786        }
4787    }
4788    #[doc = "`Get()` overload"]
4789    fn get(self) -> f32 {
4790        unsafe {
4791            let __receiver = <SystemCalculator_PhaseCurrentCommand as ::unity::FromIlInstance>::from_il_instance(
4792                <Self as ::unity::SystemObject>::as_instance(self),
4793            );
4794            {
4795                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4796                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
4797                    panic!(
4798                        "unity: virtual slot {}
4799 out of range (vtable len {}
4800) on the runtime class behind {}
4801 (method `{}
4802`)",
4803                        9usize,
4804                        __vt.len(),
4805                        <SystemCalculator_PhaseCurrentCommand as ::unity::ClassIdentity>::NAME,
4806                        "Get",
4807                    )
4808                });
4809                let __inner: extern "C" fn(SystemCalculator_PhaseCurrentCommand, ::unity::OptionalMethod) -> f32 =
4810                    ::core::mem::transmute(__vi.method_ptr);
4811                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4812                __inner(__receiver, __mi)
4813            }
4814        }
4815    }
4816    #[doc = "`.ctor()` overload"]
4817    fn ctor(self) -> () {
4818        unsafe {
4819            let __receiver = <SystemCalculator_PhaseCurrentCommand as ::unity::FromIlInstance>::from_il_instance(
4820                <Self as ::unity::SystemObject>::as_instance(self),
4821            );
4822            ::unity::il2cpp_call!((::unity::module_base()+0x21f9660usize)as*mut u8,();
4823(SystemCalculator_PhaseCurrentCommand)__receiver)
4824        }
4825    }
4826}
4827
4828#[cfg(feature = "app-systemcalculator")]
4829impl<__T: ISystemCalculator_PhaseCurrentCommand> ISystemCalculator_PhaseCurrentCommandMethods for __T {}
4830
4831#[cfg(feature = "app-systemcalculator")]
4832impl SystemCalculator_PhaseCurrentCommand {
4833    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4834        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4835    }
4836
4837    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4838        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4839    }
4840
4841    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4842        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4843    }
4844}
4845
4846#[cfg(feature = "app-systemcalculator")]
4847impl SystemCalculator_PhaseCurrentCommand {
4848    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhaseCurrentCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4849    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4850        let __mi = Self::get_name_method_info();
4851        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4852        __inner(this.into(), ::core::option::Option::None)
4853    }
4854
4855    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhaseCurrentCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4856    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4857        let __mi = Self::get_method_info();
4858        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4859        __inner(this.into(), ::core::option::Option::None)
4860    }
4861}
4862
4863#[cfg(feature = "app-systemcalculator")]
4864impl SystemCalculator_PhaseCurrentCommand {
4865    #[doc = "`.ctor()` — no args"]
4866    pub fn new() -> Self {
4867        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4868            panic!(
4869                "{}
4870::{}
4871 failed to instantiate",
4872                ::core::stringify!(SystemCalculator_PhaseCurrentCommand),
4873                ::core::stringify!(new),
4874            )
4875        });
4876        <Self as ISystemCalculator_PhaseCurrentCommandMethods>::ctor(this);
4877        this
4878    }
4879}
4880
4881#[cfg(feature = "app-systemcalculator")]
4882pub trait ISystemCalculator_PersonIndexCommandMethods: ISystemCalculator_PersonIndexCommand {
4883    #[doc = "`get_Name()` overload"]
4884    fn get_name(self) -> ::unity::Il2CppString {
4885        unsafe {
4886            let __receiver = <SystemCalculator_PersonIndexCommand as ::unity::FromIlInstance>::from_il_instance(
4887                <Self as ::unity::SystemObject>::as_instance(self),
4888            );
4889            {
4890                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4891                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4892                    panic!(
4893                        "unity: virtual slot {}
4894 out of range (vtable len {}
4895) on the runtime class behind {}
4896 (method `{}
4897`)",
4898                        4usize,
4899                        __vt.len(),
4900                        <SystemCalculator_PersonIndexCommand as ::unity::ClassIdentity>::NAME,
4901                        "get_Name",
4902                    )
4903                });
4904                let __inner: extern "C" fn(SystemCalculator_PersonIndexCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4905                    ::core::mem::transmute(__vi.method_ptr);
4906                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4907                __inner(__receiver, __mi)
4908            }
4909        }
4910    }
4911    #[doc = "`Func(::unity::Il2CppString)` overload"]
4912    fn func(self, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
4913        unsafe {
4914            let __receiver = <SystemCalculator_PersonIndexCommand as ::unity::FromIlInstance>::from_il_instance(
4915                <Self as ::unity::SystemObject>::as_instance(self),
4916            );
4917            {
4918                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4919                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
4920                    panic!(
4921                        "unity: virtual slot {}
4922 out of range (vtable len {}
4923) on the runtime class behind {}
4924 (method `{}
4925`)",
4926                        27usize,
4927                        __vt.len(),
4928                        <SystemCalculator_PersonIndexCommand as ::unity::ClassIdentity>::NAME,
4929                        "Func",
4930                    )
4931                });
4932                let __inner: extern "C" fn(SystemCalculator_PersonIndexCommand, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
4933                    ::core::mem::transmute(__vi.method_ptr);
4934                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4935                __inner(__receiver, ::core::convert::Into::into(arg), __mi)
4936            }
4937        }
4938    }
4939    #[doc = "`.ctor()` overload"]
4940    fn ctor(self) -> () {
4941        unsafe {
4942            let __receiver = <SystemCalculator_PersonIndexCommand as ::unity::FromIlInstance>::from_il_instance(
4943                <Self as ::unity::SystemObject>::as_instance(self),
4944            );
4945            ::unity::il2cpp_call!((::unity::module_base()+0x21f95f0usize)as*mut u8,();
4946(SystemCalculator_PersonIndexCommand)__receiver)
4947        }
4948    }
4949}
4950
4951#[cfg(feature = "app-systemcalculator")]
4952impl<__T: ISystemCalculator_PersonIndexCommand> ISystemCalculator_PersonIndexCommandMethods for __T {}
4953
4954#[cfg(feature = "app-systemcalculator")]
4955impl SystemCalculator_PersonIndexCommand {
4956    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4957        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4958    }
4959
4960    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4961        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4962    }
4963
4964    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4965        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4966    }
4967}
4968
4969#[cfg(feature = "app-systemcalculator")]
4970impl SystemCalculator_PersonIndexCommand {
4971    #[doc = "Direct (non-virtual) call to `SystemCalculator_PersonIndexCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4972    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4973        let __mi = Self::get_name_method_info();
4974        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4975        __inner(this.into(), ::core::option::Option::None)
4976    }
4977
4978    #[doc = "Direct (non-virtual) call to `SystemCalculator_PersonIndexCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4979    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>, arg: ::unity::Il2CppString) -> f32 {
4980        let __mi = Self::func_method_info();
4981        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
4982            ::core::mem::transmute(__mi.method_ptr);
4983        __inner(this.into(), arg, ::core::option::Option::None)
4984    }
4985}
4986
4987#[cfg(feature = "app-systemcalculator")]
4988impl SystemCalculator_PersonIndexCommand {
4989    #[doc = "`.ctor()` — no args"]
4990    pub fn new() -> Self {
4991        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4992            panic!(
4993                "{}
4994::{}
4995 failed to instantiate",
4996                ::core::stringify!(SystemCalculator_PersonIndexCommand),
4997                ::core::stringify!(new),
4998            )
4999        });
5000        <Self as ISystemCalculator_PersonIndexCommandMethods>::ctor(this);
5001        this
5002    }
5003}
5004
5005#[cfg(feature = "app-systemcalculator")]
5006pub trait ISystemCalculator_JobIndexCommandMethods: ISystemCalculator_JobIndexCommand {
5007    #[doc = "`get_Name()` overload"]
5008    fn get_name(self) -> ::unity::Il2CppString {
5009        unsafe {
5010            let __receiver =
5011                <SystemCalculator_JobIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5012            {
5013                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5014                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5015                    panic!(
5016                        "unity: virtual slot {}
5017 out of range (vtable len {}
5018) on the runtime class behind {}
5019 (method `{}
5020`)",
5021                        4usize,
5022                        __vt.len(),
5023                        <SystemCalculator_JobIndexCommand as ::unity::ClassIdentity>::NAME,
5024                        "get_Name",
5025                    )
5026                });
5027                let __inner: extern "C" fn(SystemCalculator_JobIndexCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5028                    ::core::mem::transmute(__vi.method_ptr);
5029                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5030                __inner(__receiver, __mi)
5031            }
5032        }
5033    }
5034    #[doc = "`Func(::unity::Il2CppString)` overload"]
5035    fn func(self, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
5036        unsafe {
5037            let __receiver =
5038                <SystemCalculator_JobIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5039            {
5040                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5041                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
5042                    panic!(
5043                        "unity: virtual slot {}
5044 out of range (vtable len {}
5045) on the runtime class behind {}
5046 (method `{}
5047`)",
5048                        27usize,
5049                        __vt.len(),
5050                        <SystemCalculator_JobIndexCommand as ::unity::ClassIdentity>::NAME,
5051                        "Func",
5052                    )
5053                });
5054                let __inner: extern "C" fn(SystemCalculator_JobIndexCommand, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
5055                    ::core::mem::transmute(__vi.method_ptr);
5056                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5057                __inner(__receiver, ::core::convert::Into::into(arg), __mi)
5058            }
5059        }
5060    }
5061    #[doc = "`.ctor()` overload"]
5062    fn ctor(self) -> () {
5063        unsafe {
5064            let __receiver =
5065                <SystemCalculator_JobIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5066            ::unity::il2cpp_call!((::unity::module_base()+0x21f9020usize)as*mut u8,();
5067(SystemCalculator_JobIndexCommand)__receiver)
5068        }
5069    }
5070}
5071
5072#[cfg(feature = "app-systemcalculator")]
5073impl<__T: ISystemCalculator_JobIndexCommand> ISystemCalculator_JobIndexCommandMethods for __T {}
5074
5075#[cfg(feature = "app-systemcalculator")]
5076impl SystemCalculator_JobIndexCommand {
5077    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5078        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5079    }
5080
5081    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5082        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5083    }
5084
5085    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5086        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5087    }
5088}
5089
5090#[cfg(feature = "app-systemcalculator")]
5091impl SystemCalculator_JobIndexCommand {
5092    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobIndexCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5093    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5094        let __mi = Self::get_name_method_info();
5095        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5096        __inner(this.into(), ::core::option::Option::None)
5097    }
5098
5099    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobIndexCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5100    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>, arg: ::unity::Il2CppString) -> f32 {
5101        let __mi = Self::func_method_info();
5102        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
5103            ::core::mem::transmute(__mi.method_ptr);
5104        __inner(this.into(), arg, ::core::option::Option::None)
5105    }
5106}
5107
5108#[cfg(feature = "app-systemcalculator")]
5109impl SystemCalculator_JobIndexCommand {
5110    #[doc = "`.ctor()` — no args"]
5111    pub fn new() -> Self {
5112        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5113            panic!(
5114                "{}
5115::{}
5116 failed to instantiate",
5117                ::core::stringify!(SystemCalculator_JobIndexCommand),
5118                ::core::stringify!(new),
5119            )
5120        });
5121        <Self as ISystemCalculator_JobIndexCommandMethods>::ctor(this);
5122        this
5123    }
5124}
5125
5126#[cfg(feature = "app-systemcalculator")]
5127pub trait ISystemCalculator_ScreenShotCommandMethods: ISystemCalculator_ScreenShotCommand {
5128    #[doc = "`get_Name()` overload"]
5129    fn get_name(self) -> ::unity::Il2CppString {
5130        unsafe {
5131            let __receiver =
5132                <SystemCalculator_ScreenShotCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5133            {
5134                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5135                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5136                    panic!(
5137                        "unity: virtual slot {}
5138 out of range (vtable len {}
5139) on the runtime class behind {}
5140 (method `{}
5141`)",
5142                        4usize,
5143                        __vt.len(),
5144                        <SystemCalculator_ScreenShotCommand as ::unity::ClassIdentity>::NAME,
5145                        "get_Name",
5146                    )
5147                });
5148                let __inner: extern "C" fn(SystemCalculator_ScreenShotCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5149                    ::core::mem::transmute(__vi.method_ptr);
5150                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5151                __inner(__receiver, __mi)
5152            }
5153        }
5154    }
5155    #[doc = "`.ctor()` overload"]
5156    fn ctor(self) -> () {
5157        unsafe {
5158            let __receiver =
5159                <SystemCalculator_ScreenShotCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5160            ::unity::il2cpp_call!((::unity::module_base()+0x21f98f0usize)as*mut u8,();
5161(SystemCalculator_ScreenShotCommand)__receiver)
5162        }
5163    }
5164}
5165
5166#[cfg(feature = "app-systemcalculator")]
5167impl<__T: ISystemCalculator_ScreenShotCommand> ISystemCalculator_ScreenShotCommandMethods for __T {}
5168
5169#[cfg(feature = "app-systemcalculator")]
5170impl SystemCalculator_ScreenShotCommand {
5171    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5172        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5173    }
5174
5175    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5176        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5177    }
5178}
5179
5180#[cfg(feature = "app-systemcalculator")]
5181impl SystemCalculator_ScreenShotCommand {
5182    #[doc = "Direct (non-virtual) call to `SystemCalculator_ScreenShotCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5183    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5184        let __mi = Self::get_name_method_info();
5185        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5186        __inner(this.into(), ::core::option::Option::None)
5187    }
5188}
5189
5190#[cfg(feature = "app-systemcalculator")]
5191impl SystemCalculator_ScreenShotCommand {
5192    #[doc = "`.ctor()` — no args"]
5193    pub fn new() -> Self {
5194        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5195            panic!(
5196                "{}
5197::{}
5198 failed to instantiate",
5199                ::core::stringify!(SystemCalculator_ScreenShotCommand),
5200                ::core::stringify!(new),
5201            )
5202        });
5203        <Self as ISystemCalculator_ScreenShotCommandMethods>::ctor(this);
5204        this
5205    }
5206}
5207
5208#[cfg(feature = "app-systemcalculator")]
5209pub trait ISystemCalculator_ItemIndexCommandMethods: ISystemCalculator_ItemIndexCommand {
5210    #[doc = "`get_Name()` overload"]
5211    fn get_name(self) -> ::unity::Il2CppString {
5212        unsafe {
5213            let __receiver =
5214                <SystemCalculator_ItemIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5215            {
5216                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5217                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5218                    panic!(
5219                        "unity: virtual slot {}
5220 out of range (vtable len {}
5221) on the runtime class behind {}
5222 (method `{}
5223`)",
5224                        4usize,
5225                        __vt.len(),
5226                        <SystemCalculator_ItemIndexCommand as ::unity::ClassIdentity>::NAME,
5227                        "get_Name",
5228                    )
5229                });
5230                let __inner: extern "C" fn(SystemCalculator_ItemIndexCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5231                    ::core::mem::transmute(__vi.method_ptr);
5232                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5233                __inner(__receiver, __mi)
5234            }
5235        }
5236    }
5237    #[doc = "`Func(::unity::Il2CppString)` overload"]
5238    fn func(self, arg: impl ::core::convert::Into<::unity::Il2CppString>) -> f32 {
5239        unsafe {
5240            let __receiver =
5241                <SystemCalculator_ItemIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5242            {
5243                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5244                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
5245                    panic!(
5246                        "unity: virtual slot {}
5247 out of range (vtable len {}
5248) on the runtime class behind {}
5249 (method `{}
5250`)",
5251                        27usize,
5252                        __vt.len(),
5253                        <SystemCalculator_ItemIndexCommand as ::unity::ClassIdentity>::NAME,
5254                        "Func",
5255                    )
5256                });
5257                let __inner: extern "C" fn(SystemCalculator_ItemIndexCommand, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
5258                    ::core::mem::transmute(__vi.method_ptr);
5259                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5260                __inner(__receiver, ::core::convert::Into::into(arg), __mi)
5261            }
5262        }
5263    }
5264    #[doc = "`.ctor()` overload"]
5265    fn ctor(self) -> () {
5266        unsafe {
5267            let __receiver =
5268                <SystemCalculator_ItemIndexCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5269            ::unity::il2cpp_call!((::unity::module_base()+0x21f8b40usize)as*mut u8,();
5270(SystemCalculator_ItemIndexCommand)__receiver)
5271        }
5272    }
5273}
5274
5275#[cfg(feature = "app-systemcalculator")]
5276impl<__T: ISystemCalculator_ItemIndexCommand> ISystemCalculator_ItemIndexCommandMethods for __T {}
5277
5278#[cfg(feature = "app-systemcalculator")]
5279impl SystemCalculator_ItemIndexCommand {
5280    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5281        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5282    }
5283
5284    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5285        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5286    }
5287
5288    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5289        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5290    }
5291}
5292
5293#[cfg(feature = "app-systemcalculator")]
5294impl SystemCalculator_ItemIndexCommand {
5295    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemIndexCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5296    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5297        let __mi = Self::get_name_method_info();
5298        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5299        __inner(this.into(), ::core::option::Option::None)
5300    }
5301
5302    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemIndexCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5303    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>, arg: ::unity::Il2CppString) -> f32 {
5304        let __mi = Self::func_method_info();
5305        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> f32 =
5306            ::core::mem::transmute(__mi.method_ptr);
5307        __inner(this.into(), arg, ::core::option::Option::None)
5308    }
5309}
5310
5311#[cfg(feature = "app-systemcalculator")]
5312impl SystemCalculator_ItemIndexCommand {
5313    #[doc = "`.ctor()` — no args"]
5314    pub fn new() -> Self {
5315        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5316            panic!(
5317                "{}
5318::{}
5319 failed to instantiate",
5320                ::core::stringify!(SystemCalculator_ItemIndexCommand),
5321                ::core::stringify!(new),
5322            )
5323        });
5324        <Self as ISystemCalculator_ItemIndexCommandMethods>::ctor(this);
5325        this
5326    }
5327}
5328
5329#[cfg(feature = "app-systemcalculator")]
5330pub trait ISystemCalculator_JobRankHighCommandMethods: ISystemCalculator_JobRankHighCommand {
5331    #[doc = "`get_Name()` overload"]
5332    fn get_name(self) -> ::unity::Il2CppString {
5333        unsafe {
5334            let __receiver = <SystemCalculator_JobRankHighCommand as ::unity::FromIlInstance>::from_il_instance(
5335                <Self as ::unity::SystemObject>::as_instance(self),
5336            );
5337            {
5338                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5339                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5340                    panic!(
5341                        "unity: virtual slot {}
5342 out of range (vtable len {}
5343) on the runtime class behind {}
5344 (method `{}
5345`)",
5346                        4usize,
5347                        __vt.len(),
5348                        <SystemCalculator_JobRankHighCommand as ::unity::ClassIdentity>::NAME,
5349                        "get_Name",
5350                    )
5351                });
5352                let __inner: extern "C" fn(SystemCalculator_JobRankHighCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5353                    ::core::mem::transmute(__vi.method_ptr);
5354                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5355                __inner(__receiver, __mi)
5356            }
5357        }
5358    }
5359    #[doc = "`Get()` overload"]
5360    fn get(self) -> f32 {
5361        unsafe {
5362            let __receiver = <SystemCalculator_JobRankHighCommand as ::unity::FromIlInstance>::from_il_instance(
5363                <Self as ::unity::SystemObject>::as_instance(self),
5364            );
5365            {
5366                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5367                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5368                    panic!(
5369                        "unity: virtual slot {}
5370 out of range (vtable len {}
5371) on the runtime class behind {}
5372 (method `{}
5373`)",
5374                        9usize,
5375                        __vt.len(),
5376                        <SystemCalculator_JobRankHighCommand as ::unity::ClassIdentity>::NAME,
5377                        "Get",
5378                    )
5379                });
5380                let __inner: extern "C" fn(SystemCalculator_JobRankHighCommand, ::unity::OptionalMethod) -> f32 =
5381                    ::core::mem::transmute(__vi.method_ptr);
5382                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5383                __inner(__receiver, __mi)
5384            }
5385        }
5386    }
5387    #[doc = "`.ctor()` overload"]
5388    fn ctor(self) -> () {
5389        unsafe {
5390            let __receiver = <SystemCalculator_JobRankHighCommand as ::unity::FromIlInstance>::from_il_instance(
5391                <Self as ::unity::SystemObject>::as_instance(self),
5392            );
5393            ::unity::il2cpp_call!((::unity::module_base()+0x21f9090usize)as*mut u8,();
5394(SystemCalculator_JobRankHighCommand)__receiver)
5395        }
5396    }
5397}
5398
5399#[cfg(feature = "app-systemcalculator")]
5400impl<__T: ISystemCalculator_JobRankHighCommand> ISystemCalculator_JobRankHighCommandMethods for __T {}
5401
5402#[cfg(feature = "app-systemcalculator")]
5403impl SystemCalculator_JobRankHighCommand {
5404    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5405        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5406    }
5407
5408    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5409        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5410    }
5411
5412    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5413        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5414    }
5415}
5416
5417#[cfg(feature = "app-systemcalculator")]
5418impl SystemCalculator_JobRankHighCommand {
5419    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobRankHighCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5420    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5421        let __mi = Self::get_name_method_info();
5422        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5423        __inner(this.into(), ::core::option::Option::None)
5424    }
5425
5426    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobRankHighCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5427    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5428        let __mi = Self::get_method_info();
5429        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5430        __inner(this.into(), ::core::option::Option::None)
5431    }
5432}
5433
5434#[cfg(feature = "app-systemcalculator")]
5435impl SystemCalculator_JobRankHighCommand {
5436    #[doc = "`.ctor()` — no args"]
5437    pub fn new() -> Self {
5438        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5439            panic!(
5440                "{}
5441::{}
5442 failed to instantiate",
5443                ::core::stringify!(SystemCalculator_JobRankHighCommand),
5444                ::core::stringify!(new),
5445            )
5446        });
5447        <Self as ISystemCalculator_JobRankHighCommandMethods>::ctor(this);
5448        this
5449    }
5450}
5451
5452#[cfg(feature = "app-systemcalculator")]
5453pub trait ISystemCalculator_Force3rdCommandMethods: ISystemCalculator_Force3rdCommand {
5454    #[doc = "`get_Name()` overload"]
5455    fn get_name(self) -> ::unity::Il2CppString {
5456        unsafe {
5457            let __receiver =
5458                <SystemCalculator_Force3rdCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5459            {
5460                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5461                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5462                    panic!(
5463                        "unity: virtual slot {}
5464 out of range (vtable len {}
5465) on the runtime class behind {}
5466 (method `{}
5467`)",
5468                        4usize,
5469                        __vt.len(),
5470                        <SystemCalculator_Force3rdCommand as ::unity::ClassIdentity>::NAME,
5471                        "get_Name",
5472                    )
5473                });
5474                let __inner: extern "C" fn(SystemCalculator_Force3rdCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5475                    ::core::mem::transmute(__vi.method_ptr);
5476                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5477                __inner(__receiver, __mi)
5478            }
5479        }
5480    }
5481    #[doc = "`Get()` overload"]
5482    fn get(self) -> f32 {
5483        unsafe {
5484            let __receiver =
5485                <SystemCalculator_Force3rdCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5486            {
5487                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5488                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5489                    panic!(
5490                        "unity: virtual slot {}
5491 out of range (vtable len {}
5492) on the runtime class behind {}
5493 (method `{}
5494`)",
5495                        9usize,
5496                        __vt.len(),
5497                        <SystemCalculator_Force3rdCommand as ::unity::ClassIdentity>::NAME,
5498                        "Get",
5499                    )
5500                });
5501                let __inner: extern "C" fn(SystemCalculator_Force3rdCommand, ::unity::OptionalMethod) -> f32 =
5502                    ::core::mem::transmute(__vi.method_ptr);
5503                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5504                __inner(__receiver, __mi)
5505            }
5506        }
5507    }
5508    #[doc = "`.ctor()` overload"]
5509    fn ctor(self) -> () {
5510        unsafe {
5511            let __receiver =
5512                <SystemCalculator_Force3rdCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5513            ::unity::il2cpp_call!((::unity::module_base()+0x21f86d0usize)as*mut u8,();
5514(SystemCalculator_Force3rdCommand)__receiver)
5515        }
5516    }
5517}
5518
5519#[cfg(feature = "app-systemcalculator")]
5520impl<__T: ISystemCalculator_Force3rdCommand> ISystemCalculator_Force3rdCommandMethods for __T {}
5521
5522#[cfg(feature = "app-systemcalculator")]
5523impl SystemCalculator_Force3rdCommand {
5524    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5525        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5526    }
5527
5528    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5529        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5530    }
5531
5532    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5533        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5534    }
5535}
5536
5537#[cfg(feature = "app-systemcalculator")]
5538impl SystemCalculator_Force3rdCommand {
5539    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force3rdCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5540    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5541        let __mi = Self::get_name_method_info();
5542        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5543        __inner(this.into(), ::core::option::Option::None)
5544    }
5545
5546    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force3rdCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5547    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5548        let __mi = Self::get_method_info();
5549        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5550        __inner(this.into(), ::core::option::Option::None)
5551    }
5552}
5553
5554#[cfg(feature = "app-systemcalculator")]
5555impl SystemCalculator_Force3rdCommand {
5556    #[doc = "`.ctor()` — no args"]
5557    pub fn new() -> Self {
5558        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5559            panic!(
5560                "{}
5561::{}
5562 failed to instantiate",
5563                ::core::stringify!(SystemCalculator_Force3rdCommand),
5564                ::core::stringify!(new),
5565            )
5566        });
5567        <Self as ISystemCalculator_Force3rdCommandMethods>::ctor(this);
5568        this
5569    }
5570}
5571
5572#[cfg(feature = "app-systemcalculator")]
5573pub trait ISystemCalculator_DifficultyLunaticCommandMethods: ISystemCalculator_DifficultyLunaticCommand {
5574    #[doc = "`get_Name()` overload"]
5575    fn get_name(self) -> ::unity::Il2CppString {
5576        unsafe {
5577            let __receiver = <SystemCalculator_DifficultyLunaticCommand as ::unity::FromIlInstance>::from_il_instance(
5578                <Self as ::unity::SystemObject>::as_instance(self),
5579            );
5580            {
5581                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5582                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5583                    panic!(
5584                        "unity: virtual slot {}
5585 out of range (vtable len {}
5586) on the runtime class behind {}
5587 (method `{}
5588`)",
5589                        4usize,
5590                        __vt.len(),
5591                        <SystemCalculator_DifficultyLunaticCommand as ::unity::ClassIdentity>::NAME,
5592                        "get_Name",
5593                    )
5594                });
5595                let __inner: extern "C" fn(SystemCalculator_DifficultyLunaticCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5596                    ::core::mem::transmute(__vi.method_ptr);
5597                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5598                __inner(__receiver, __mi)
5599            }
5600        }
5601    }
5602    #[doc = "`Get()` overload"]
5603    fn get(self) -> f32 {
5604        unsafe {
5605            let __receiver = <SystemCalculator_DifficultyLunaticCommand as ::unity::FromIlInstance>::from_il_instance(
5606                <Self as ::unity::SystemObject>::as_instance(self),
5607            );
5608            {
5609                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5610                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5611                    panic!(
5612                        "unity: virtual slot {}
5613 out of range (vtable len {}
5614) on the runtime class behind {}
5615 (method `{}
5616`)",
5617                        9usize,
5618                        __vt.len(),
5619                        <SystemCalculator_DifficultyLunaticCommand as ::unity::ClassIdentity>::NAME,
5620                        "Get",
5621                    )
5622                });
5623                let __inner: extern "C" fn(SystemCalculator_DifficultyLunaticCommand, ::unity::OptionalMethod) -> f32 =
5624                    ::core::mem::transmute(__vi.method_ptr);
5625                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5626                __inner(__receiver, __mi)
5627            }
5628        }
5629    }
5630    #[doc = "`.ctor()` overload"]
5631    fn ctor(self) -> () {
5632        unsafe {
5633            let __receiver = <SystemCalculator_DifficultyLunaticCommand as ::unity::FromIlInstance>::from_il_instance(
5634                <Self as ::unity::SystemObject>::as_instance(self),
5635            );
5636            ::unity::il2cpp_call!((::unity::module_base()+0x21f8350usize)as*mut u8,();
5637(SystemCalculator_DifficultyLunaticCommand)__receiver)
5638        }
5639    }
5640}
5641
5642#[cfg(feature = "app-systemcalculator")]
5643impl<__T: ISystemCalculator_DifficultyLunaticCommand> ISystemCalculator_DifficultyLunaticCommandMethods for __T {}
5644
5645#[cfg(feature = "app-systemcalculator")]
5646impl SystemCalculator_DifficultyLunaticCommand {
5647    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5648        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5649    }
5650
5651    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5652        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5653    }
5654
5655    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5656        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5657    }
5658}
5659
5660#[cfg(feature = "app-systemcalculator")]
5661impl SystemCalculator_DifficultyLunaticCommand {
5662    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyLunaticCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5663    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5664        let __mi = Self::get_name_method_info();
5665        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5666        __inner(this.into(), ::core::option::Option::None)
5667    }
5668
5669    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyLunaticCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5670    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5671        let __mi = Self::get_method_info();
5672        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5673        __inner(this.into(), ::core::option::Option::None)
5674    }
5675}
5676
5677#[cfg(feature = "app-systemcalculator")]
5678impl SystemCalculator_DifficultyLunaticCommand {
5679    #[doc = "`.ctor()` — no args"]
5680    pub fn new() -> Self {
5681        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5682            panic!(
5683                "{}
5684::{}
5685 failed to instantiate",
5686                ::core::stringify!(SystemCalculator_DifficultyLunaticCommand),
5687                ::core::stringify!(new),
5688            )
5689        });
5690        <Self as ISystemCalculator_DifficultyLunaticCommandMethods>::ctor(this);
5691        this
5692    }
5693}
5694
5695#[cfg(feature = "app-systemcalculator")]
5696pub trait ISystemCalculator_NoneAttributeCommandMethods: ISystemCalculator_NoneAttributeCommand {
5697    #[doc = "`get_Name()` overload"]
5698    fn get_name(self) -> ::unity::Il2CppString {
5699        unsafe {
5700            let __receiver = <SystemCalculator_NoneAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
5701                <Self as ::unity::SystemObject>::as_instance(self),
5702            );
5703            {
5704                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5705                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5706                    panic!(
5707                        "unity: virtual slot {}
5708 out of range (vtable len {}
5709) on the runtime class behind {}
5710 (method `{}
5711`)",
5712                        4usize,
5713                        __vt.len(),
5714                        <SystemCalculator_NoneAttributeCommand as ::unity::ClassIdentity>::NAME,
5715                        "get_Name",
5716                    )
5717                });
5718                let __inner: extern "C" fn(SystemCalculator_NoneAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5719                    ::core::mem::transmute(__vi.method_ptr);
5720                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5721                __inner(__receiver, __mi)
5722            }
5723        }
5724    }
5725    #[doc = "`Get()` overload"]
5726    fn get(self) -> f32 {
5727        unsafe {
5728            let __receiver = <SystemCalculator_NoneAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
5729                <Self as ::unity::SystemObject>::as_instance(self),
5730            );
5731            {
5732                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5733                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5734                    panic!(
5735                        "unity: virtual slot {}
5736 out of range (vtable len {}
5737) on the runtime class behind {}
5738 (method `{}
5739`)",
5740                        9usize,
5741                        __vt.len(),
5742                        <SystemCalculator_NoneAttributeCommand as ::unity::ClassIdentity>::NAME,
5743                        "Get",
5744                    )
5745                });
5746                let __inner: extern "C" fn(SystemCalculator_NoneAttributeCommand, ::unity::OptionalMethod) -> f32 =
5747                    ::core::mem::transmute(__vi.method_ptr);
5748                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5749                __inner(__receiver, __mi)
5750            }
5751        }
5752    }
5753    #[doc = "`.ctor()` overload"]
5754    fn ctor(self) -> () {
5755        unsafe {
5756            let __receiver = <SystemCalculator_NoneAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
5757                <Self as ::unity::SystemObject>::as_instance(self),
5758            );
5759            ::unity::il2cpp_call!((::unity::module_base()+0x21f9500usize)as*mut u8,();
5760(SystemCalculator_NoneAttributeCommand)__receiver)
5761        }
5762    }
5763}
5764
5765#[cfg(feature = "app-systemcalculator")]
5766impl<__T: ISystemCalculator_NoneAttributeCommand> ISystemCalculator_NoneAttributeCommandMethods for __T {}
5767
5768#[cfg(feature = "app-systemcalculator")]
5769impl SystemCalculator_NoneAttributeCommand {
5770    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5771        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5772    }
5773
5774    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5775        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5776    }
5777
5778    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5779        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5780    }
5781}
5782
5783#[cfg(feature = "app-systemcalculator")]
5784impl SystemCalculator_NoneAttributeCommand {
5785    #[doc = "Direct (non-virtual) call to `SystemCalculator_NoneAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5786    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5787        let __mi = Self::get_name_method_info();
5788        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5789        __inner(this.into(), ::core::option::Option::None)
5790    }
5791
5792    #[doc = "Direct (non-virtual) call to `SystemCalculator_NoneAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5793    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5794        let __mi = Self::get_method_info();
5795        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5796        __inner(this.into(), ::core::option::Option::None)
5797    }
5798}
5799
5800#[cfg(feature = "app-systemcalculator")]
5801impl SystemCalculator_NoneAttributeCommand {
5802    #[doc = "`.ctor()` — no args"]
5803    pub fn new() -> Self {
5804        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5805            panic!(
5806                "{}
5807::{}
5808 failed to instantiate",
5809                ::core::stringify!(SystemCalculator_NoneAttributeCommand),
5810                ::core::stringify!(new),
5811            )
5812        });
5813        <Self as ISystemCalculator_NoneAttributeCommandMethods>::ctor(this);
5814        this
5815    }
5816}
5817
5818#[cfg(feature = "app-systemcalculator")]
5819pub trait ISystemCalculator_JobRankLowCommandMethods: ISystemCalculator_JobRankLowCommand {
5820    #[doc = "`get_Name()` overload"]
5821    fn get_name(self) -> ::unity::Il2CppString {
5822        unsafe {
5823            let __receiver =
5824                <SystemCalculator_JobRankLowCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5825            {
5826                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5827                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5828                    panic!(
5829                        "unity: virtual slot {}
5830 out of range (vtable len {}
5831) on the runtime class behind {}
5832 (method `{}
5833`)",
5834                        4usize,
5835                        __vt.len(),
5836                        <SystemCalculator_JobRankLowCommand as ::unity::ClassIdentity>::NAME,
5837                        "get_Name",
5838                    )
5839                });
5840                let __inner: extern "C" fn(SystemCalculator_JobRankLowCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5841                    ::core::mem::transmute(__vi.method_ptr);
5842                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5843                __inner(__receiver, __mi)
5844            }
5845        }
5846    }
5847    #[doc = "`Get()` overload"]
5848    fn get(self) -> f32 {
5849        unsafe {
5850            let __receiver =
5851                <SystemCalculator_JobRankLowCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5852            {
5853                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5854                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5855                    panic!(
5856                        "unity: virtual slot {}
5857 out of range (vtable len {}
5858) on the runtime class behind {}
5859 (method `{}
5860`)",
5861                        9usize,
5862                        __vt.len(),
5863                        <SystemCalculator_JobRankLowCommand as ::unity::ClassIdentity>::NAME,
5864                        "Get",
5865                    )
5866                });
5867                let __inner: extern "C" fn(SystemCalculator_JobRankLowCommand, ::unity::OptionalMethod) -> f32 =
5868                    ::core::mem::transmute(__vi.method_ptr);
5869                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5870                __inner(__receiver, __mi)
5871            }
5872        }
5873    }
5874    #[doc = "`.ctor()` overload"]
5875    fn ctor(self) -> () {
5876        unsafe {
5877            let __receiver =
5878                <SystemCalculator_JobRankLowCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5879            ::unity::il2cpp_call!((::unity::module_base()+0x21f9100usize)as*mut u8,();
5880(SystemCalculator_JobRankLowCommand)__receiver)
5881        }
5882    }
5883}
5884
5885#[cfg(feature = "app-systemcalculator")]
5886impl<__T: ISystemCalculator_JobRankLowCommand> ISystemCalculator_JobRankLowCommandMethods for __T {}
5887
5888#[cfg(feature = "app-systemcalculator")]
5889impl SystemCalculator_JobRankLowCommand {
5890    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5891        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5892    }
5893
5894    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5895        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5896    }
5897
5898    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5899        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5900    }
5901}
5902
5903#[cfg(feature = "app-systemcalculator")]
5904impl SystemCalculator_JobRankLowCommand {
5905    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobRankLowCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5906    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5907        let __mi = Self::get_name_method_info();
5908        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5909        __inner(this.into(), ::core::option::Option::None)
5910    }
5911
5912    #[doc = "Direct (non-virtual) call to `SystemCalculator_JobRankLowCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5913    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
5914        let __mi = Self::get_method_info();
5915        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
5916        __inner(this.into(), ::core::option::Option::None)
5917    }
5918}
5919
5920#[cfg(feature = "app-systemcalculator")]
5921impl SystemCalculator_JobRankLowCommand {
5922    #[doc = "`.ctor()` — no args"]
5923    pub fn new() -> Self {
5924        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5925            panic!(
5926                "{}
5927::{}
5928 failed to instantiate",
5929                ::core::stringify!(SystemCalculator_JobRankLowCommand),
5930                ::core::stringify!(new),
5931            )
5932        });
5933        <Self as ISystemCalculator_JobRankLowCommandMethods>::ctor(this);
5934        this
5935    }
5936}
5937
5938#[cfg(feature = "app-systemcalculator")]
5939pub trait ISystemCalculator_IceAttributeCommandMethods: ISystemCalculator_IceAttributeCommand {
5940    #[doc = "`get_Name()` overload"]
5941    fn get_name(self) -> ::unity::Il2CppString {
5942        unsafe {
5943            let __receiver = <SystemCalculator_IceAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
5944                <Self as ::unity::SystemObject>::as_instance(self),
5945            );
5946            {
5947                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5948                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5949                    panic!(
5950                        "unity: virtual slot {}
5951 out of range (vtable len {}
5952) on the runtime class behind {}
5953 (method `{}
5954`)",
5955                        4usize,
5956                        __vt.len(),
5957                        <SystemCalculator_IceAttributeCommand as ::unity::ClassIdentity>::NAME,
5958                        "get_Name",
5959                    )
5960                });
5961                let __inner: extern "C" fn(SystemCalculator_IceAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5962                    ::core::mem::transmute(__vi.method_ptr);
5963                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5964                __inner(__receiver, __mi)
5965            }
5966        }
5967    }
5968    #[doc = "`Get()` overload"]
5969    fn get(self) -> f32 {
5970        unsafe {
5971            let __receiver = <SystemCalculator_IceAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
5972                <Self as ::unity::SystemObject>::as_instance(self),
5973            );
5974            {
5975                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5976                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
5977                    panic!(
5978                        "unity: virtual slot {}
5979 out of range (vtable len {}
5980) on the runtime class behind {}
5981 (method `{}
5982`)",
5983                        9usize,
5984                        __vt.len(),
5985                        <SystemCalculator_IceAttributeCommand as ::unity::ClassIdentity>::NAME,
5986                        "Get",
5987                    )
5988                });
5989                let __inner: extern "C" fn(SystemCalculator_IceAttributeCommand, ::unity::OptionalMethod) -> f32 =
5990                    ::core::mem::transmute(__vi.method_ptr);
5991                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5992                __inner(__receiver, __mi)
5993            }
5994        }
5995    }
5996    #[doc = "`.ctor()` overload"]
5997    fn ctor(self) -> () {
5998        unsafe {
5999            let __receiver = <SystemCalculator_IceAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6000                <Self as ::unity::SystemObject>::as_instance(self),
6001            );
6002            ::unity::il2cpp_call!((::unity::module_base()+0x21f8a50usize)as*mut u8,();
6003(SystemCalculator_IceAttributeCommand)__receiver)
6004        }
6005    }
6006}
6007
6008#[cfg(feature = "app-systemcalculator")]
6009impl<__T: ISystemCalculator_IceAttributeCommand> ISystemCalculator_IceAttributeCommandMethods for __T {}
6010
6011#[cfg(feature = "app-systemcalculator")]
6012impl SystemCalculator_IceAttributeCommand {
6013    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6014        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6015    }
6016
6017    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6018        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6019    }
6020
6021    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6022        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6023    }
6024}
6025
6026#[cfg(feature = "app-systemcalculator")]
6027impl SystemCalculator_IceAttributeCommand {
6028    #[doc = "Direct (non-virtual) call to `SystemCalculator_IceAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6029    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6030        let __mi = Self::get_name_method_info();
6031        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6032        __inner(this.into(), ::core::option::Option::None)
6033    }
6034
6035    #[doc = "Direct (non-virtual) call to `SystemCalculator_IceAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6036    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6037        let __mi = Self::get_method_info();
6038        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6039        __inner(this.into(), ::core::option::Option::None)
6040    }
6041}
6042
6043#[cfg(feature = "app-systemcalculator")]
6044impl SystemCalculator_IceAttributeCommand {
6045    #[doc = "`.ctor()` — no args"]
6046    pub fn new() -> Self {
6047        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6048            panic!(
6049                "{}
6050::{}
6051 failed to instantiate",
6052                ::core::stringify!(SystemCalculator_IceAttributeCommand),
6053                ::core::stringify!(new),
6054            )
6055        });
6056        <Self as ISystemCalculator_IceAttributeCommandMethods>::ctor(this);
6057        this
6058    }
6059}
6060
6061#[cfg(feature = "app-systemcalculator")]
6062pub trait ISystemCalculator_PhysicalAttributeCommandMethods: ISystemCalculator_PhysicalAttributeCommand {
6063    #[doc = "`get_Name()` overload"]
6064    fn get_name(self) -> ::unity::Il2CppString {
6065        unsafe {
6066            let __receiver = <SystemCalculator_PhysicalAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6067                <Self as ::unity::SystemObject>::as_instance(self),
6068            );
6069            {
6070                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6071                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6072                    panic!(
6073                        "unity: virtual slot {}
6074 out of range (vtable len {}
6075) on the runtime class behind {}
6076 (method `{}
6077`)",
6078                        4usize,
6079                        __vt.len(),
6080                        <SystemCalculator_PhysicalAttributeCommand as ::unity::ClassIdentity>::NAME,
6081                        "get_Name",
6082                    )
6083                });
6084                let __inner: extern "C" fn(SystemCalculator_PhysicalAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6085                    ::core::mem::transmute(__vi.method_ptr);
6086                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6087                __inner(__receiver, __mi)
6088            }
6089        }
6090    }
6091    #[doc = "`Get()` overload"]
6092    fn get(self) -> f32 {
6093        unsafe {
6094            let __receiver = <SystemCalculator_PhysicalAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6095                <Self as ::unity::SystemObject>::as_instance(self),
6096            );
6097            {
6098                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6099                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6100                    panic!(
6101                        "unity: virtual slot {}
6102 out of range (vtable len {}
6103) on the runtime class behind {}
6104 (method `{}
6105`)",
6106                        9usize,
6107                        __vt.len(),
6108                        <SystemCalculator_PhysicalAttributeCommand as ::unity::ClassIdentity>::NAME,
6109                        "Get",
6110                    )
6111                });
6112                let __inner: extern "C" fn(SystemCalculator_PhysicalAttributeCommand, ::unity::OptionalMethod) -> f32 =
6113                    ::core::mem::transmute(__vi.method_ptr);
6114                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6115                __inner(__receiver, __mi)
6116            }
6117        }
6118    }
6119    #[doc = "`.ctor()` overload"]
6120    fn ctor(self) -> () {
6121        unsafe {
6122            let __receiver = <SystemCalculator_PhysicalAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6123                <Self as ::unity::SystemObject>::as_instance(self),
6124            );
6125            ::unity::il2cpp_call!((::unity::module_base()+0x21f9740usize)as*mut u8,();
6126(SystemCalculator_PhysicalAttributeCommand)__receiver)
6127        }
6128    }
6129}
6130
6131#[cfg(feature = "app-systemcalculator")]
6132impl<__T: ISystemCalculator_PhysicalAttributeCommand> ISystemCalculator_PhysicalAttributeCommandMethods for __T {}
6133
6134#[cfg(feature = "app-systemcalculator")]
6135impl SystemCalculator_PhysicalAttributeCommand {
6136    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6137        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6138    }
6139
6140    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6141        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6142    }
6143
6144    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6145        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6146    }
6147}
6148
6149#[cfg(feature = "app-systemcalculator")]
6150impl SystemCalculator_PhysicalAttributeCommand {
6151    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhysicalAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6152    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6153        let __mi = Self::get_name_method_info();
6154        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6155        __inner(this.into(), ::core::option::Option::None)
6156    }
6157
6158    #[doc = "Direct (non-virtual) call to `SystemCalculator_PhysicalAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6159    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6160        let __mi = Self::get_method_info();
6161        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6162        __inner(this.into(), ::core::option::Option::None)
6163    }
6164}
6165
6166#[cfg(feature = "app-systemcalculator")]
6167impl SystemCalculator_PhysicalAttributeCommand {
6168    #[doc = "`.ctor()` — no args"]
6169    pub fn new() -> Self {
6170        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6171            panic!(
6172                "{}
6173::{}
6174 failed to instantiate",
6175                ::core::stringify!(SystemCalculator_PhysicalAttributeCommand),
6176                ::core::stringify!(new),
6177            )
6178        });
6179        <Self as ISystemCalculator_PhysicalAttributeCommandMethods>::ctor(this);
6180        this
6181    }
6182}
6183
6184#[cfg(feature = "app-systemcalculator")]
6185pub trait ISystemCalculator_WindAttributeCommandMethods: ISystemCalculator_WindAttributeCommand {
6186    #[doc = "`get_Name()` overload"]
6187    fn get_name(self) -> ::unity::Il2CppString {
6188        unsafe {
6189            let __receiver = <SystemCalculator_WindAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6190                <Self as ::unity::SystemObject>::as_instance(self),
6191            );
6192            {
6193                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6194                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6195                    panic!(
6196                        "unity: virtual slot {}
6197 out of range (vtable len {}
6198) on the runtime class behind {}
6199 (method `{}
6200`)",
6201                        4usize,
6202                        __vt.len(),
6203                        <SystemCalculator_WindAttributeCommand as ::unity::ClassIdentity>::NAME,
6204                        "get_Name",
6205                    )
6206                });
6207                let __inner: extern "C" fn(SystemCalculator_WindAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6208                    ::core::mem::transmute(__vi.method_ptr);
6209                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6210                __inner(__receiver, __mi)
6211            }
6212        }
6213    }
6214    #[doc = "`Get()` overload"]
6215    fn get(self) -> f32 {
6216        unsafe {
6217            let __receiver = <SystemCalculator_WindAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6218                <Self as ::unity::SystemObject>::as_instance(self),
6219            );
6220            {
6221                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6222                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6223                    panic!(
6224                        "unity: virtual slot {}
6225 out of range (vtable len {}
6226) on the runtime class behind {}
6227 (method `{}
6228`)",
6229                        9usize,
6230                        __vt.len(),
6231                        <SystemCalculator_WindAttributeCommand as ::unity::ClassIdentity>::NAME,
6232                        "Get",
6233                    )
6234                });
6235                let __inner: extern "C" fn(SystemCalculator_WindAttributeCommand, ::unity::OptionalMethod) -> f32 =
6236                    ::core::mem::transmute(__vi.method_ptr);
6237                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6238                __inner(__receiver, __mi)
6239            }
6240        }
6241    }
6242    #[doc = "`.ctor()` overload"]
6243    fn ctor(self) -> () {
6244        unsafe {
6245            let __receiver = <SystemCalculator_WindAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6246                <Self as ::unity::SystemObject>::as_instance(self),
6247            );
6248            ::unity::il2cpp_call!((::unity::module_base()+0x21f9f10usize)as*mut u8,();
6249(SystemCalculator_WindAttributeCommand)__receiver)
6250        }
6251    }
6252}
6253
6254#[cfg(feature = "app-systemcalculator")]
6255impl<__T: ISystemCalculator_WindAttributeCommand> ISystemCalculator_WindAttributeCommandMethods for __T {}
6256
6257#[cfg(feature = "app-systemcalculator")]
6258impl SystemCalculator_WindAttributeCommand {
6259    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6260        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6261    }
6262
6263    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6264        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6265    }
6266
6267    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6268        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6269    }
6270}
6271
6272#[cfg(feature = "app-systemcalculator")]
6273impl SystemCalculator_WindAttributeCommand {
6274    #[doc = "Direct (non-virtual) call to `SystemCalculator_WindAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6275    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6276        let __mi = Self::get_name_method_info();
6277        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6278        __inner(this.into(), ::core::option::Option::None)
6279    }
6280
6281    #[doc = "Direct (non-virtual) call to `SystemCalculator_WindAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6282    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6283        let __mi = Self::get_method_info();
6284        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6285        __inner(this.into(), ::core::option::Option::None)
6286    }
6287}
6288
6289#[cfg(feature = "app-systemcalculator")]
6290impl SystemCalculator_WindAttributeCommand {
6291    #[doc = "`.ctor()` — no args"]
6292    pub fn new() -> Self {
6293        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6294            panic!(
6295                "{}
6296::{}
6297 failed to instantiate",
6298                ::core::stringify!(SystemCalculator_WindAttributeCommand),
6299                ::core::stringify!(new),
6300            )
6301        });
6302        <Self as ISystemCalculator_WindAttributeCommandMethods>::ctor(this);
6303        this
6304    }
6305}
6306
6307#[cfg(feature = "app-systemcalculator")]
6308pub trait ISystemCalculator_LightAttributeCommandMethods: ISystemCalculator_LightAttributeCommand {
6309    #[doc = "`get_Name()` overload"]
6310    fn get_name(self) -> ::unity::Il2CppString {
6311        unsafe {
6312            let __receiver = <SystemCalculator_LightAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6313                <Self as ::unity::SystemObject>::as_instance(self),
6314            );
6315            {
6316                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6317                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6318                    panic!(
6319                        "unity: virtual slot {}
6320 out of range (vtable len {}
6321) on the runtime class behind {}
6322 (method `{}
6323`)",
6324                        4usize,
6325                        __vt.len(),
6326                        <SystemCalculator_LightAttributeCommand as ::unity::ClassIdentity>::NAME,
6327                        "get_Name",
6328                    )
6329                });
6330                let __inner: extern "C" fn(SystemCalculator_LightAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6331                    ::core::mem::transmute(__vi.method_ptr);
6332                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6333                __inner(__receiver, __mi)
6334            }
6335        }
6336    }
6337    #[doc = "`Get()` overload"]
6338    fn get(self) -> f32 {
6339        unsafe {
6340            let __receiver = <SystemCalculator_LightAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6341                <Self as ::unity::SystemObject>::as_instance(self),
6342            );
6343            {
6344                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6345                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6346                    panic!(
6347                        "unity: virtual slot {}
6348 out of range (vtable len {}
6349) on the runtime class behind {}
6350 (method `{}
6351`)",
6352                        9usize,
6353                        __vt.len(),
6354                        <SystemCalculator_LightAttributeCommand as ::unity::ClassIdentity>::NAME,
6355                        "Get",
6356                    )
6357                });
6358                let __inner: extern "C" fn(SystemCalculator_LightAttributeCommand, ::unity::OptionalMethod) -> f32 =
6359                    ::core::mem::transmute(__vi.method_ptr);
6360                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6361                __inner(__receiver, __mi)
6362            }
6363        }
6364    }
6365    #[doc = "`.ctor()` overload"]
6366    fn ctor(self) -> () {
6367        unsafe {
6368            let __receiver = <SystemCalculator_LightAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6369                <Self as ::unity::SystemObject>::as_instance(self),
6370            );
6371            ::unity::il2cpp_call!((::unity::module_base()+0x21f9170usize)as*mut u8,();
6372(SystemCalculator_LightAttributeCommand)__receiver)
6373        }
6374    }
6375}
6376
6377#[cfg(feature = "app-systemcalculator")]
6378impl<__T: ISystemCalculator_LightAttributeCommand> ISystemCalculator_LightAttributeCommandMethods for __T {}
6379
6380#[cfg(feature = "app-systemcalculator")]
6381impl SystemCalculator_LightAttributeCommand {
6382    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6383        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6384    }
6385
6386    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6387        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6388    }
6389
6390    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6391        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6392    }
6393}
6394
6395#[cfg(feature = "app-systemcalculator")]
6396impl SystemCalculator_LightAttributeCommand {
6397    #[doc = "Direct (non-virtual) call to `SystemCalculator_LightAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6398    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6399        let __mi = Self::get_name_method_info();
6400        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6401        __inner(this.into(), ::core::option::Option::None)
6402    }
6403
6404    #[doc = "Direct (non-virtual) call to `SystemCalculator_LightAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6405    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6406        let __mi = Self::get_method_info();
6407        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6408        __inner(this.into(), ::core::option::Option::None)
6409    }
6410}
6411
6412#[cfg(feature = "app-systemcalculator")]
6413impl SystemCalculator_LightAttributeCommand {
6414    #[doc = "`.ctor()` — no args"]
6415    pub fn new() -> Self {
6416        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6417            panic!(
6418                "{}
6419::{}
6420 failed to instantiate",
6421                ::core::stringify!(SystemCalculator_LightAttributeCommand),
6422                ::core::stringify!(new),
6423            )
6424        });
6425        <Self as ISystemCalculator_LightAttributeCommandMethods>::ctor(this);
6426        this
6427    }
6428}
6429
6430#[cfg(feature = "app-systemcalculator")]
6431pub trait ISystemCalculator_VsyncCommandMethods: ISystemCalculator_VsyncCommand {
6432    #[doc = "`get_Name()` overload"]
6433    fn get_name(self) -> ::unity::Il2CppString {
6434        unsafe {
6435            let __receiver =
6436                <SystemCalculator_VsyncCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6437            {
6438                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6439                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6440                    panic!(
6441                        "unity: virtual slot {}
6442 out of range (vtable len {}
6443) on the runtime class behind {}
6444 (method `{}
6445`)",
6446                        4usize,
6447                        __vt.len(),
6448                        <SystemCalculator_VsyncCommand as ::unity::ClassIdentity>::NAME,
6449                        "get_Name",
6450                    )
6451                });
6452                let __inner: extern "C" fn(SystemCalculator_VsyncCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6453                    ::core::mem::transmute(__vi.method_ptr);
6454                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6455                __inner(__receiver, __mi)
6456            }
6457        }
6458    }
6459    #[doc = "`Func()` overload"]
6460    fn func(self) -> f32 {
6461        unsafe {
6462            let __receiver =
6463                <SystemCalculator_VsyncCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6464            {
6465                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6466                let __vi = *__vt.get(21usize).unwrap_or_else(|| {
6467                    panic!(
6468                        "unity: virtual slot {}
6469 out of range (vtable len {}
6470) on the runtime class behind {}
6471 (method `{}
6472`)",
6473                        21usize,
6474                        __vt.len(),
6475                        <SystemCalculator_VsyncCommand as ::unity::ClassIdentity>::NAME,
6476                        "Func",
6477                    )
6478                });
6479                let __inner: extern "C" fn(SystemCalculator_VsyncCommand, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
6480                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6481                __inner(__receiver, __mi)
6482            }
6483        }
6484    }
6485    #[doc = "`Func(crate::system::collections::generic::list_1::List_1<f32>)` overload"]
6486    fn func_2(self, args: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<f32>>) -> f32 {
6487        unsafe {
6488            let __receiver =
6489                <SystemCalculator_VsyncCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6490            {
6491                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6492                let __vi = *__vt.get(24usize).unwrap_or_else(|| {
6493                    panic!(
6494                        "unity: virtual slot {}
6495 out of range (vtable len {}
6496) on the runtime class behind {}
6497 (method `{}
6498`)",
6499                        24usize,
6500                        __vt.len(),
6501                        <SystemCalculator_VsyncCommand as ::unity::ClassIdentity>::NAME,
6502                        "Func",
6503                    )
6504                });
6505                let __inner: extern "C" fn(
6506                    SystemCalculator_VsyncCommand,
6507                    crate::system::collections::generic::list_1::List_1<f32>,
6508                    ::unity::OptionalMethod,
6509                ) -> f32 = ::core::mem::transmute(__vi.method_ptr);
6510                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6511                __inner(__receiver, ::core::convert::Into::into(args), __mi)
6512            }
6513        }
6514    }
6515    #[doc = "`.ctor()` overload"]
6516    fn ctor(self) -> () {
6517        unsafe {
6518            let __receiver =
6519                <SystemCalculator_VsyncCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6520            ::unity::il2cpp_call!((::unity::module_base()+0x21f9c00usize)as*mut u8,();
6521(SystemCalculator_VsyncCommand)__receiver)
6522        }
6523    }
6524}
6525
6526#[cfg(feature = "app-systemcalculator")]
6527impl<__T: ISystemCalculator_VsyncCommand> ISystemCalculator_VsyncCommandMethods for __T {}
6528
6529#[cfg(feature = "app-systemcalculator")]
6530impl SystemCalculator_VsyncCommand {
6531    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6532        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6533    }
6534
6535    pub fn func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6536        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6537    }
6538
6539    pub fn func_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6540        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6541    }
6542
6543    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6544        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6545    }
6546}
6547
6548#[cfg(feature = "app-systemcalculator")]
6549impl SystemCalculator_VsyncCommand {
6550    #[doc = "Direct (non-virtual) call to `SystemCalculator_VsyncCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6551    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6552        let __mi = Self::get_name_method_info();
6553        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6554        __inner(this.into(), ::core::option::Option::None)
6555    }
6556
6557    #[doc = "Direct (non-virtual) call to `SystemCalculator_VsyncCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6558    pub unsafe fn func(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6559        let __mi = Self::func_method_info();
6560        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6561        __inner(this.into(), ::core::option::Option::None)
6562    }
6563
6564    #[doc = "Direct (non-virtual) call to `SystemCalculator_VsyncCommand`'s own `Func`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6565    pub unsafe fn func_2(
6566        this: impl ::core::convert::Into<::unity::IlInstance>,
6567        args: crate::system::collections::generic::list_1::List_1<f32>,
6568    ) -> f32 {
6569        let __mi = Self::func_2_method_info();
6570        let __inner: extern "C" fn(::unity::IlInstance, crate::system::collections::generic::list_1::List_1<f32>, ::unity::OptionalMethod) -> f32 =
6571            ::core::mem::transmute(__mi.method_ptr);
6572        __inner(this.into(), args, ::core::option::Option::None)
6573    }
6574}
6575
6576#[cfg(feature = "app-systemcalculator")]
6577impl SystemCalculator_VsyncCommand {
6578    #[doc = "`.ctor()` — no args"]
6579    pub fn new() -> Self {
6580        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6581            panic!(
6582                "{}
6583::{}
6584 failed to instantiate",
6585                ::core::stringify!(SystemCalculator_VsyncCommand),
6586                ::core::stringify!(new),
6587            )
6588        });
6589        <Self as ISystemCalculator_VsyncCommandMethods>::ctor(this);
6590        this
6591    }
6592}
6593
6594#[cfg(feature = "app-systemcalculator")]
6595pub trait ISystemCalculator_BattleStyleCooperationCommandMethods: ISystemCalculator_BattleStyleCooperationCommand {
6596    #[doc = "`get_Style()` overload"]
6597    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
6598        unsafe {
6599            let __receiver = <SystemCalculator_BattleStyleCooperationCommand as ::unity::FromIlInstance>::from_il_instance(
6600                <Self as ::unity::SystemObject>::as_instance(self),
6601            );
6602            {
6603                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6604                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6605                    panic!(
6606                        "unity: virtual slot {}
6607 out of range (vtable len {}
6608) on the runtime class behind {}
6609 (method `{}
6610`)",
6611                        30usize,
6612                        __vt.len(),
6613                        <SystemCalculator_BattleStyleCooperationCommand as ::unity::ClassIdentity>::NAME,
6614                        "get_Style",
6615                    )
6616                });
6617                let __inner: extern "C" fn(
6618                    SystemCalculator_BattleStyleCooperationCommand,
6619                    ::unity::OptionalMethod,
6620                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
6621                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6622                __inner(__receiver, __mi)
6623            }
6624        }
6625    }
6626    #[doc = "`.ctor()` overload"]
6627    fn ctor(self) -> () {
6628        unsafe {
6629            let __receiver = <SystemCalculator_BattleStyleCooperationCommand as ::unity::FromIlInstance>::from_il_instance(
6630                <Self as ::unity::SystemObject>::as_instance(self),
6631            );
6632            ::unity::il2cpp_call!((::unity::module_base()+0x21f8120usize)as*mut u8,();
6633(SystemCalculator_BattleStyleCooperationCommand)__receiver)
6634        }
6635    }
6636}
6637
6638#[cfg(feature = "app-systemcalculator")]
6639impl<__T: ISystemCalculator_BattleStyleCooperationCommand> ISystemCalculator_BattleStyleCooperationCommandMethods for __T {}
6640
6641#[cfg(feature = "app-systemcalculator")]
6642impl SystemCalculator_BattleStyleCooperationCommand {
6643    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6644        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6645    }
6646
6647    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6648        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6649    }
6650}
6651
6652#[cfg(feature = "app-systemcalculator")]
6653impl SystemCalculator_BattleStyleCooperationCommand {
6654    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleCooperationCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6655    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
6656        let __mi = Self::get_style_method_info();
6657        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
6658            ::core::mem::transmute(__mi.method_ptr);
6659        __inner(this.into(), ::core::option::Option::None)
6660    }
6661}
6662
6663#[cfg(feature = "app-systemcalculator")]
6664impl SystemCalculator_BattleStyleCooperationCommand {
6665    #[doc = "`.ctor()` — no args"]
6666    pub fn new() -> Self {
6667        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6668            panic!(
6669                "{}
6670::{}
6671 failed to instantiate",
6672                ::core::stringify!(SystemCalculator_BattleStyleCooperationCommand),
6673                ::core::stringify!(new),
6674            )
6675        });
6676        <Self as ISystemCalculator_BattleStyleCooperationCommandMethods>::ctor(this);
6677        this
6678    }
6679}
6680
6681#[cfg(feature = "app-systemcalculator")]
6682pub trait ISystemCalculator_ItemKindFistCommandMethods: ISystemCalculator_ItemKindFistCommand {
6683    #[doc = "`get_Name()` overload"]
6684    fn get_name(self) -> ::unity::Il2CppString {
6685        unsafe {
6686            let __receiver = <SystemCalculator_ItemKindFistCommand as ::unity::FromIlInstance>::from_il_instance(
6687                <Self as ::unity::SystemObject>::as_instance(self),
6688            );
6689            {
6690                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6691                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6692                    panic!(
6693                        "unity: virtual slot {}
6694 out of range (vtable len {}
6695) on the runtime class behind {}
6696 (method `{}
6697`)",
6698                        4usize,
6699                        __vt.len(),
6700                        <SystemCalculator_ItemKindFistCommand as ::unity::ClassIdentity>::NAME,
6701                        "get_Name",
6702                    )
6703                });
6704                let __inner: extern "C" fn(SystemCalculator_ItemKindFistCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6705                    ::core::mem::transmute(__vi.method_ptr);
6706                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6707                __inner(__receiver, __mi)
6708            }
6709        }
6710    }
6711    #[doc = "`Get()` overload"]
6712    fn get(self) -> f32 {
6713        unsafe {
6714            let __receiver = <SystemCalculator_ItemKindFistCommand as ::unity::FromIlInstance>::from_il_instance(
6715                <Self as ::unity::SystemObject>::as_instance(self),
6716            );
6717            {
6718                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6719                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6720                    panic!(
6721                        "unity: virtual slot {}
6722 out of range (vtable len {}
6723) on the runtime class behind {}
6724 (method `{}
6725`)",
6726                        9usize,
6727                        __vt.len(),
6728                        <SystemCalculator_ItemKindFistCommand as ::unity::ClassIdentity>::NAME,
6729                        "Get",
6730                    )
6731                });
6732                let __inner: extern "C" fn(SystemCalculator_ItemKindFistCommand, ::unity::OptionalMethod) -> f32 =
6733                    ::core::mem::transmute(__vi.method_ptr);
6734                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6735                __inner(__receiver, __mi)
6736            }
6737        }
6738    }
6739    #[doc = "`.ctor()` overload"]
6740    fn ctor(self) -> () {
6741        unsafe {
6742            let __receiver = <SystemCalculator_ItemKindFistCommand as ::unity::FromIlInstance>::from_il_instance(
6743                <Self as ::unity::SystemObject>::as_instance(self),
6744            );
6745            ::unity::il2cpp_call!((::unity::module_base()+0x21f8d00usize)as*mut u8,();
6746(SystemCalculator_ItemKindFistCommand)__receiver)
6747        }
6748    }
6749}
6750
6751#[cfg(feature = "app-systemcalculator")]
6752impl<__T: ISystemCalculator_ItemKindFistCommand> ISystemCalculator_ItemKindFistCommandMethods for __T {}
6753
6754#[cfg(feature = "app-systemcalculator")]
6755impl SystemCalculator_ItemKindFistCommand {
6756    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6757        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6758    }
6759
6760    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6761        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6762    }
6763
6764    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6765        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6766    }
6767}
6768
6769#[cfg(feature = "app-systemcalculator")]
6770impl SystemCalculator_ItemKindFistCommand {
6771    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindFistCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6772    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6773        let __mi = Self::get_name_method_info();
6774        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6775        __inner(this.into(), ::core::option::Option::None)
6776    }
6777
6778    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindFistCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6779    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6780        let __mi = Self::get_method_info();
6781        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6782        __inner(this.into(), ::core::option::Option::None)
6783    }
6784}
6785
6786#[cfg(feature = "app-systemcalculator")]
6787impl SystemCalculator_ItemKindFistCommand {
6788    #[doc = "`.ctor()` — no args"]
6789    pub fn new() -> Self {
6790        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6791            panic!(
6792                "{}
6793::{}
6794 failed to instantiate",
6795                ::core::stringify!(SystemCalculator_ItemKindFistCommand),
6796                ::core::stringify!(new),
6797            )
6798        });
6799        <Self as ISystemCalculator_ItemKindFistCommandMethods>::ctor(this);
6800        this
6801    }
6802}
6803
6804#[cfg(feature = "app-systemcalculator")]
6805pub trait ISystemCalculator_ItemKindLanceCommandMethods: ISystemCalculator_ItemKindLanceCommand {
6806    #[doc = "`get_Name()` overload"]
6807    fn get_name(self) -> ::unity::Il2CppString {
6808        unsafe {
6809            let __receiver = <SystemCalculator_ItemKindLanceCommand as ::unity::FromIlInstance>::from_il_instance(
6810                <Self as ::unity::SystemObject>::as_instance(self),
6811            );
6812            {
6813                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6814                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6815                    panic!(
6816                        "unity: virtual slot {}
6817 out of range (vtable len {}
6818) on the runtime class behind {}
6819 (method `{}
6820`)",
6821                        4usize,
6822                        __vt.len(),
6823                        <SystemCalculator_ItemKindLanceCommand as ::unity::ClassIdentity>::NAME,
6824                        "get_Name",
6825                    )
6826                });
6827                let __inner: extern "C" fn(SystemCalculator_ItemKindLanceCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6828                    ::core::mem::transmute(__vi.method_ptr);
6829                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6830                __inner(__receiver, __mi)
6831            }
6832        }
6833    }
6834    #[doc = "`Get()` overload"]
6835    fn get(self) -> f32 {
6836        unsafe {
6837            let __receiver = <SystemCalculator_ItemKindLanceCommand as ::unity::FromIlInstance>::from_il_instance(
6838                <Self as ::unity::SystemObject>::as_instance(self),
6839            );
6840            {
6841                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6842                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6843                    panic!(
6844                        "unity: virtual slot {}
6845 out of range (vtable len {}
6846) on the runtime class behind {}
6847 (method `{}
6848`)",
6849                        9usize,
6850                        __vt.len(),
6851                        <SystemCalculator_ItemKindLanceCommand as ::unity::ClassIdentity>::NAME,
6852                        "Get",
6853                    )
6854                });
6855                let __inner: extern "C" fn(SystemCalculator_ItemKindLanceCommand, ::unity::OptionalMethod) -> f32 =
6856                    ::core::mem::transmute(__vi.method_ptr);
6857                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6858                __inner(__receiver, __mi)
6859            }
6860        }
6861    }
6862    #[doc = "`.ctor()` overload"]
6863    fn ctor(self) -> () {
6864        unsafe {
6865            let __receiver = <SystemCalculator_ItemKindLanceCommand as ::unity::FromIlInstance>::from_il_instance(
6866                <Self as ::unity::SystemObject>::as_instance(self),
6867            );
6868            ::unity::il2cpp_call!((::unity::module_base()+0x21f8d70usize)as*mut u8,();
6869(SystemCalculator_ItemKindLanceCommand)__receiver)
6870        }
6871    }
6872}
6873
6874#[cfg(feature = "app-systemcalculator")]
6875impl<__T: ISystemCalculator_ItemKindLanceCommand> ISystemCalculator_ItemKindLanceCommandMethods for __T {}
6876
6877#[cfg(feature = "app-systemcalculator")]
6878impl SystemCalculator_ItemKindLanceCommand {
6879    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6880        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6881    }
6882
6883    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6884        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6885    }
6886
6887    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6888        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6889    }
6890}
6891
6892#[cfg(feature = "app-systemcalculator")]
6893impl SystemCalculator_ItemKindLanceCommand {
6894    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindLanceCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6895    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6896        let __mi = Self::get_name_method_info();
6897        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6898        __inner(this.into(), ::core::option::Option::None)
6899    }
6900
6901    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindLanceCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6902    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
6903        let __mi = Self::get_method_info();
6904        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
6905        __inner(this.into(), ::core::option::Option::None)
6906    }
6907}
6908
6909#[cfg(feature = "app-systemcalculator")]
6910impl SystemCalculator_ItemKindLanceCommand {
6911    #[doc = "`.ctor()` — no args"]
6912    pub fn new() -> Self {
6913        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6914            panic!(
6915                "{}
6916::{}
6917 failed to instantiate",
6918                ::core::stringify!(SystemCalculator_ItemKindLanceCommand),
6919                ::core::stringify!(new),
6920            )
6921        });
6922        <Self as ISystemCalculator_ItemKindLanceCommandMethods>::ctor(this);
6923        this
6924    }
6925}
6926
6927#[cfg(feature = "app-systemcalculator")]
6928pub trait ISystemCalculator_MorphAttributeCommandMethods: ISystemCalculator_MorphAttributeCommand {
6929    #[doc = "`get_Name()` overload"]
6930    fn get_name(self) -> ::unity::Il2CppString {
6931        unsafe {
6932            let __receiver = <SystemCalculator_MorphAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6933                <Self as ::unity::SystemObject>::as_instance(self),
6934            );
6935            {
6936                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6937                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
6938                    panic!(
6939                        "unity: virtual slot {}
6940 out of range (vtable len {}
6941) on the runtime class behind {}
6942 (method `{}
6943`)",
6944                        4usize,
6945                        __vt.len(),
6946                        <SystemCalculator_MorphAttributeCommand as ::unity::ClassIdentity>::NAME,
6947                        "get_Name",
6948                    )
6949                });
6950                let __inner: extern "C" fn(SystemCalculator_MorphAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6951                    ::core::mem::transmute(__vi.method_ptr);
6952                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6953                __inner(__receiver, __mi)
6954            }
6955        }
6956    }
6957    #[doc = "`Get()` overload"]
6958    fn get(self) -> f32 {
6959        unsafe {
6960            let __receiver = <SystemCalculator_MorphAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6961                <Self as ::unity::SystemObject>::as_instance(self),
6962            );
6963            {
6964                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6965                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
6966                    panic!(
6967                        "unity: virtual slot {}
6968 out of range (vtable len {}
6969) on the runtime class behind {}
6970 (method `{}
6971`)",
6972                        9usize,
6973                        __vt.len(),
6974                        <SystemCalculator_MorphAttributeCommand as ::unity::ClassIdentity>::NAME,
6975                        "Get",
6976                    )
6977                });
6978                let __inner: extern "C" fn(SystemCalculator_MorphAttributeCommand, ::unity::OptionalMethod) -> f32 =
6979                    ::core::mem::transmute(__vi.method_ptr);
6980                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6981                __inner(__receiver, __mi)
6982            }
6983        }
6984    }
6985    #[doc = "`.ctor()` overload"]
6986    fn ctor(self) -> () {
6987        unsafe {
6988            let __receiver = <SystemCalculator_MorphAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
6989                <Self as ::unity::SystemObject>::as_instance(self),
6990            );
6991            ::unity::il2cpp_call!((::unity::module_base()+0x21f9250usize)as*mut u8,();
6992(SystemCalculator_MorphAttributeCommand)__receiver)
6993        }
6994    }
6995}
6996
6997#[cfg(feature = "app-systemcalculator")]
6998impl<__T: ISystemCalculator_MorphAttributeCommand> ISystemCalculator_MorphAttributeCommandMethods for __T {}
6999
7000#[cfg(feature = "app-systemcalculator")]
7001impl SystemCalculator_MorphAttributeCommand {
7002    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7003        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7004    }
7005
7006    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7007        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7008    }
7009
7010    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7011        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7012    }
7013}
7014
7015#[cfg(feature = "app-systemcalculator")]
7016impl SystemCalculator_MorphAttributeCommand {
7017    #[doc = "Direct (non-virtual) call to `SystemCalculator_MorphAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7018    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7019        let __mi = Self::get_name_method_info();
7020        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7021        __inner(this.into(), ::core::option::Option::None)
7022    }
7023
7024    #[doc = "Direct (non-virtual) call to `SystemCalculator_MorphAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7025    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7026        let __mi = Self::get_method_info();
7027        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7028        __inner(this.into(), ::core::option::Option::None)
7029    }
7030}
7031
7032#[cfg(feature = "app-systemcalculator")]
7033impl SystemCalculator_MorphAttributeCommand {
7034    #[doc = "`.ctor()` — no args"]
7035    pub fn new() -> Self {
7036        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7037            panic!(
7038                "{}
7039::{}
7040 failed to instantiate",
7041                ::core::stringify!(SystemCalculator_MorphAttributeCommand),
7042                ::core::stringify!(new),
7043            )
7044        });
7045        <Self as ISystemCalculator_MorphAttributeCommandMethods>::ctor(this);
7046        this
7047    }
7048}
7049
7050#[cfg(feature = "app-systemcalculator")]
7051pub trait ISystemCalculator_BattleStyleHeavyCommandMethods: ISystemCalculator_BattleStyleHeavyCommand {
7052    #[doc = "`get_Style()` overload"]
7053    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
7054        unsafe {
7055            let __receiver = <SystemCalculator_BattleStyleHeavyCommand as ::unity::FromIlInstance>::from_il_instance(
7056                <Self as ::unity::SystemObject>::as_instance(self),
7057            );
7058            {
7059                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7060                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7061                    panic!(
7062                        "unity: virtual slot {}
7063 out of range (vtable len {}
7064) on the runtime class behind {}
7065 (method `{}
7066`)",
7067                        30usize,
7068                        __vt.len(),
7069                        <SystemCalculator_BattleStyleHeavyCommand as ::unity::ClassIdentity>::NAME,
7070                        "get_Style",
7071                    )
7072                });
7073                let __inner: extern "C" fn(
7074                    SystemCalculator_BattleStyleHeavyCommand,
7075                    ::unity::OptionalMethod,
7076                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
7077                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7078                __inner(__receiver, __mi)
7079            }
7080        }
7081    }
7082    #[doc = "`.ctor()` overload"]
7083    fn ctor(self) -> () {
7084        unsafe {
7085            let __receiver = <SystemCalculator_BattleStyleHeavyCommand as ::unity::FromIlInstance>::from_il_instance(
7086                <Self as ::unity::SystemObject>::as_instance(self),
7087            );
7088            ::unity::il2cpp_call!((::unity::module_base()+0x21f81a0usize)as*mut u8,();
7089(SystemCalculator_BattleStyleHeavyCommand)__receiver)
7090        }
7091    }
7092}
7093
7094#[cfg(feature = "app-systemcalculator")]
7095impl<__T: ISystemCalculator_BattleStyleHeavyCommand> ISystemCalculator_BattleStyleHeavyCommandMethods for __T {}
7096
7097#[cfg(feature = "app-systemcalculator")]
7098impl SystemCalculator_BattleStyleHeavyCommand {
7099    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7100        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7101    }
7102
7103    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7104        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7105    }
7106}
7107
7108#[cfg(feature = "app-systemcalculator")]
7109impl SystemCalculator_BattleStyleHeavyCommand {
7110    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleHeavyCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7111    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
7112        let __mi = Self::get_style_method_info();
7113        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
7114            ::core::mem::transmute(__mi.method_ptr);
7115        __inner(this.into(), ::core::option::Option::None)
7116    }
7117}
7118
7119#[cfg(feature = "app-systemcalculator")]
7120impl SystemCalculator_BattleStyleHeavyCommand {
7121    #[doc = "`.ctor()` — no args"]
7122    pub fn new() -> Self {
7123        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7124            panic!(
7125                "{}
7126::{}
7127 failed to instantiate",
7128                ::core::stringify!(SystemCalculator_BattleStyleHeavyCommand),
7129                ::core::stringify!(new),
7130            )
7131        });
7132        <Self as ISystemCalculator_BattleStyleHeavyCommandMethods>::ctor(this);
7133        this
7134    }
7135}
7136
7137#[cfg(feature = "app-systemcalculator")]
7138pub trait ISystemCalculator_ItemKindBowCommandMethods: ISystemCalculator_ItemKindBowCommand {
7139    #[doc = "`get_Name()` overload"]
7140    fn get_name(self) -> ::unity::Il2CppString {
7141        unsafe {
7142            let __receiver = <SystemCalculator_ItemKindBowCommand as ::unity::FromIlInstance>::from_il_instance(
7143                <Self as ::unity::SystemObject>::as_instance(self),
7144            );
7145            {
7146                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7147                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7148                    panic!(
7149                        "unity: virtual slot {}
7150 out of range (vtable len {}
7151) on the runtime class behind {}
7152 (method `{}
7153`)",
7154                        4usize,
7155                        __vt.len(),
7156                        <SystemCalculator_ItemKindBowCommand as ::unity::ClassIdentity>::NAME,
7157                        "get_Name",
7158                    )
7159                });
7160                let __inner: extern "C" fn(SystemCalculator_ItemKindBowCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7161                    ::core::mem::transmute(__vi.method_ptr);
7162                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7163                __inner(__receiver, __mi)
7164            }
7165        }
7166    }
7167    #[doc = "`Get()` overload"]
7168    fn get(self) -> f32 {
7169        unsafe {
7170            let __receiver = <SystemCalculator_ItemKindBowCommand as ::unity::FromIlInstance>::from_il_instance(
7171                <Self as ::unity::SystemObject>::as_instance(self),
7172            );
7173            {
7174                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7175                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7176                    panic!(
7177                        "unity: virtual slot {}
7178 out of range (vtable len {}
7179) on the runtime class behind {}
7180 (method `{}
7181`)",
7182                        9usize,
7183                        __vt.len(),
7184                        <SystemCalculator_ItemKindBowCommand as ::unity::ClassIdentity>::NAME,
7185                        "Get",
7186                    )
7187                });
7188                let __inner: extern "C" fn(SystemCalculator_ItemKindBowCommand, ::unity::OptionalMethod) -> f32 =
7189                    ::core::mem::transmute(__vi.method_ptr);
7190                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7191                __inner(__receiver, __mi)
7192            }
7193        }
7194    }
7195    #[doc = "`.ctor()` overload"]
7196    fn ctor(self) -> () {
7197        unsafe {
7198            let __receiver = <SystemCalculator_ItemKindBowCommand as ::unity::FromIlInstance>::from_il_instance(
7199                <Self as ::unity::SystemObject>::as_instance(self),
7200            );
7201            ::unity::il2cpp_call!((::unity::module_base()+0x21f8c20usize)as*mut u8,();
7202(SystemCalculator_ItemKindBowCommand)__receiver)
7203        }
7204    }
7205}
7206
7207#[cfg(feature = "app-systemcalculator")]
7208impl<__T: ISystemCalculator_ItemKindBowCommand> ISystemCalculator_ItemKindBowCommandMethods for __T {}
7209
7210#[cfg(feature = "app-systemcalculator")]
7211impl SystemCalculator_ItemKindBowCommand {
7212    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7213        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7214    }
7215
7216    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7217        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7218    }
7219
7220    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7221        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7222    }
7223}
7224
7225#[cfg(feature = "app-systemcalculator")]
7226impl SystemCalculator_ItemKindBowCommand {
7227    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindBowCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7228    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7229        let __mi = Self::get_name_method_info();
7230        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7231        __inner(this.into(), ::core::option::Option::None)
7232    }
7233
7234    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindBowCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7235    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7236        let __mi = Self::get_method_info();
7237        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7238        __inner(this.into(), ::core::option::Option::None)
7239    }
7240}
7241
7242#[cfg(feature = "app-systemcalculator")]
7243impl SystemCalculator_ItemKindBowCommand {
7244    #[doc = "`.ctor()` — no args"]
7245    pub fn new() -> Self {
7246        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7247            panic!(
7248                "{}
7249::{}
7250 failed to instantiate",
7251                ::core::stringify!(SystemCalculator_ItemKindBowCommand),
7252                ::core::stringify!(new),
7253            )
7254        });
7255        <Self as ISystemCalculator_ItemKindBowCommandMethods>::ctor(this);
7256        this
7257    }
7258}
7259
7260#[cfg(feature = "app-systemcalculator")]
7261pub trait ISystemCalculator_ItemKindMagicCommandMethods: ISystemCalculator_ItemKindMagicCommand {
7262    #[doc = "`get_Name()` overload"]
7263    fn get_name(self) -> ::unity::Il2CppString {
7264        unsafe {
7265            let __receiver = <SystemCalculator_ItemKindMagicCommand as ::unity::FromIlInstance>::from_il_instance(
7266                <Self as ::unity::SystemObject>::as_instance(self),
7267            );
7268            {
7269                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7270                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7271                    panic!(
7272                        "unity: virtual slot {}
7273 out of range (vtable len {}
7274) on the runtime class behind {}
7275 (method `{}
7276`)",
7277                        4usize,
7278                        __vt.len(),
7279                        <SystemCalculator_ItemKindMagicCommand as ::unity::ClassIdentity>::NAME,
7280                        "get_Name",
7281                    )
7282                });
7283                let __inner: extern "C" fn(SystemCalculator_ItemKindMagicCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7284                    ::core::mem::transmute(__vi.method_ptr);
7285                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7286                __inner(__receiver, __mi)
7287            }
7288        }
7289    }
7290    #[doc = "`Get()` overload"]
7291    fn get(self) -> f32 {
7292        unsafe {
7293            let __receiver = <SystemCalculator_ItemKindMagicCommand as ::unity::FromIlInstance>::from_il_instance(
7294                <Self as ::unity::SystemObject>::as_instance(self),
7295            );
7296            {
7297                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7298                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7299                    panic!(
7300                        "unity: virtual slot {}
7301 out of range (vtable len {}
7302) on the runtime class behind {}
7303 (method `{}
7304`)",
7305                        9usize,
7306                        __vt.len(),
7307                        <SystemCalculator_ItemKindMagicCommand as ::unity::ClassIdentity>::NAME,
7308                        "Get",
7309                    )
7310                });
7311                let __inner: extern "C" fn(SystemCalculator_ItemKindMagicCommand, ::unity::OptionalMethod) -> f32 =
7312                    ::core::mem::transmute(__vi.method_ptr);
7313                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7314                __inner(__receiver, __mi)
7315            }
7316        }
7317    }
7318    #[doc = "`.ctor()` overload"]
7319    fn ctor(self) -> () {
7320        unsafe {
7321            let __receiver = <SystemCalculator_ItemKindMagicCommand as ::unity::FromIlInstance>::from_il_instance(
7322                <Self as ::unity::SystemObject>::as_instance(self),
7323            );
7324            ::unity::il2cpp_call!((::unity::module_base()+0x21f8de0usize)as*mut u8,();
7325(SystemCalculator_ItemKindMagicCommand)__receiver)
7326        }
7327    }
7328}
7329
7330#[cfg(feature = "app-systemcalculator")]
7331impl<__T: ISystemCalculator_ItemKindMagicCommand> ISystemCalculator_ItemKindMagicCommandMethods for __T {}
7332
7333#[cfg(feature = "app-systemcalculator")]
7334impl SystemCalculator_ItemKindMagicCommand {
7335    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7336        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7337    }
7338
7339    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7340        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7341    }
7342
7343    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7344        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7345    }
7346}
7347
7348#[cfg(feature = "app-systemcalculator")]
7349impl SystemCalculator_ItemKindMagicCommand {
7350    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindMagicCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7351    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7352        let __mi = Self::get_name_method_info();
7353        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7354        __inner(this.into(), ::core::option::Option::None)
7355    }
7356
7357    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindMagicCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7358    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7359        let __mi = Self::get_method_info();
7360        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7361        __inner(this.into(), ::core::option::Option::None)
7362    }
7363}
7364
7365#[cfg(feature = "app-systemcalculator")]
7366impl SystemCalculator_ItemKindMagicCommand {
7367    #[doc = "`.ctor()` — no args"]
7368    pub fn new() -> Self {
7369        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7370            panic!(
7371                "{}
7372::{}
7373 failed to instantiate",
7374                ::core::stringify!(SystemCalculator_ItemKindMagicCommand),
7375                ::core::stringify!(new),
7376            )
7377        });
7378        <Self as ISystemCalculator_ItemKindMagicCommandMethods>::ctor(this);
7379        this
7380    }
7381}
7382
7383#[cfg(feature = "app-systemcalculator")]
7384pub trait ISystemCalculator_FireAttributeCommandMethods: ISystemCalculator_FireAttributeCommand {
7385    #[doc = "`get_Name()` overload"]
7386    fn get_name(self) -> ::unity::Il2CppString {
7387        unsafe {
7388            let __receiver = <SystemCalculator_FireAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
7389                <Self as ::unity::SystemObject>::as_instance(self),
7390            );
7391            {
7392                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7393                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7394                    panic!(
7395                        "unity: virtual slot {}
7396 out of range (vtable len {}
7397) on the runtime class behind {}
7398 (method `{}
7399`)",
7400                        4usize,
7401                        __vt.len(),
7402                        <SystemCalculator_FireAttributeCommand as ::unity::ClassIdentity>::NAME,
7403                        "get_Name",
7404                    )
7405                });
7406                let __inner: extern "C" fn(SystemCalculator_FireAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7407                    ::core::mem::transmute(__vi.method_ptr);
7408                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7409                __inner(__receiver, __mi)
7410            }
7411        }
7412    }
7413    #[doc = "`Get()` overload"]
7414    fn get(self) -> f32 {
7415        unsafe {
7416            let __receiver = <SystemCalculator_FireAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
7417                <Self as ::unity::SystemObject>::as_instance(self),
7418            );
7419            {
7420                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7421                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7422                    panic!(
7423                        "unity: virtual slot {}
7424 out of range (vtable len {}
7425) on the runtime class behind {}
7426 (method `{}
7427`)",
7428                        9usize,
7429                        __vt.len(),
7430                        <SystemCalculator_FireAttributeCommand as ::unity::ClassIdentity>::NAME,
7431                        "Get",
7432                    )
7433                });
7434                let __inner: extern "C" fn(SystemCalculator_FireAttributeCommand, ::unity::OptionalMethod) -> f32 =
7435                    ::core::mem::transmute(__vi.method_ptr);
7436                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7437                __inner(__receiver, __mi)
7438            }
7439        }
7440    }
7441    #[doc = "`.ctor()` overload"]
7442    fn ctor(self) -> () {
7443        unsafe {
7444            let __receiver = <SystemCalculator_FireAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
7445                <Self as ::unity::SystemObject>::as_instance(self),
7446            );
7447            ::unity::il2cpp_call!((::unity::module_base()+0x21f8510usize)as*mut u8,();
7448(SystemCalculator_FireAttributeCommand)__receiver)
7449        }
7450    }
7451}
7452
7453#[cfg(feature = "app-systemcalculator")]
7454impl<__T: ISystemCalculator_FireAttributeCommand> ISystemCalculator_FireAttributeCommandMethods for __T {}
7455
7456#[cfg(feature = "app-systemcalculator")]
7457impl SystemCalculator_FireAttributeCommand {
7458    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7459        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7460    }
7461
7462    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7463        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7464    }
7465
7466    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7467        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7468    }
7469}
7470
7471#[cfg(feature = "app-systemcalculator")]
7472impl SystemCalculator_FireAttributeCommand {
7473    #[doc = "Direct (non-virtual) call to `SystemCalculator_FireAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7474    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7475        let __mi = Self::get_name_method_info();
7476        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7477        __inner(this.into(), ::core::option::Option::None)
7478    }
7479
7480    #[doc = "Direct (non-virtual) call to `SystemCalculator_FireAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7481    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7482        let __mi = Self::get_method_info();
7483        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7484        __inner(this.into(), ::core::option::Option::None)
7485    }
7486}
7487
7488#[cfg(feature = "app-systemcalculator")]
7489impl SystemCalculator_FireAttributeCommand {
7490    #[doc = "`.ctor()` — no args"]
7491    pub fn new() -> Self {
7492        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7493            panic!(
7494                "{}
7495::{}
7496 failed to instantiate",
7497                ::core::stringify!(SystemCalculator_FireAttributeCommand),
7498                ::core::stringify!(new),
7499            )
7500        });
7501        <Self as ISystemCalculator_FireAttributeCommandMethods>::ctor(this);
7502        this
7503    }
7504}
7505
7506#[cfg(feature = "app-systemcalculator")]
7507pub trait ISystemCalculator_ItemKindAxeCommandMethods: ISystemCalculator_ItemKindAxeCommand {
7508    #[doc = "`get_Name()` overload"]
7509    fn get_name(self) -> ::unity::Il2CppString {
7510        unsafe {
7511            let __receiver = <SystemCalculator_ItemKindAxeCommand as ::unity::FromIlInstance>::from_il_instance(
7512                <Self as ::unity::SystemObject>::as_instance(self),
7513            );
7514            {
7515                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7516                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7517                    panic!(
7518                        "unity: virtual slot {}
7519 out of range (vtable len {}
7520) on the runtime class behind {}
7521 (method `{}
7522`)",
7523                        4usize,
7524                        __vt.len(),
7525                        <SystemCalculator_ItemKindAxeCommand as ::unity::ClassIdentity>::NAME,
7526                        "get_Name",
7527                    )
7528                });
7529                let __inner: extern "C" fn(SystemCalculator_ItemKindAxeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7530                    ::core::mem::transmute(__vi.method_ptr);
7531                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7532                __inner(__receiver, __mi)
7533            }
7534        }
7535    }
7536    #[doc = "`Get()` overload"]
7537    fn get(self) -> f32 {
7538        unsafe {
7539            let __receiver = <SystemCalculator_ItemKindAxeCommand as ::unity::FromIlInstance>::from_il_instance(
7540                <Self as ::unity::SystemObject>::as_instance(self),
7541            );
7542            {
7543                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7544                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7545                    panic!(
7546                        "unity: virtual slot {}
7547 out of range (vtable len {}
7548) on the runtime class behind {}
7549 (method `{}
7550`)",
7551                        9usize,
7552                        __vt.len(),
7553                        <SystemCalculator_ItemKindAxeCommand as ::unity::ClassIdentity>::NAME,
7554                        "Get",
7555                    )
7556                });
7557                let __inner: extern "C" fn(SystemCalculator_ItemKindAxeCommand, ::unity::OptionalMethod) -> f32 =
7558                    ::core::mem::transmute(__vi.method_ptr);
7559                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7560                __inner(__receiver, __mi)
7561            }
7562        }
7563    }
7564    #[doc = "`.ctor()` overload"]
7565    fn ctor(self) -> () {
7566        unsafe {
7567            let __receiver = <SystemCalculator_ItemKindAxeCommand as ::unity::FromIlInstance>::from_il_instance(
7568                <Self as ::unity::SystemObject>::as_instance(self),
7569            );
7570            ::unity::il2cpp_call!((::unity::module_base()+0x21f8bb0usize)as*mut u8,();
7571(SystemCalculator_ItemKindAxeCommand)__receiver)
7572        }
7573    }
7574}
7575
7576#[cfg(feature = "app-systemcalculator")]
7577impl<__T: ISystemCalculator_ItemKindAxeCommand> ISystemCalculator_ItemKindAxeCommandMethods for __T {}
7578
7579#[cfg(feature = "app-systemcalculator")]
7580impl SystemCalculator_ItemKindAxeCommand {
7581    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7582        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7583    }
7584
7585    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7586        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7587    }
7588
7589    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7590        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7591    }
7592}
7593
7594#[cfg(feature = "app-systemcalculator")]
7595impl SystemCalculator_ItemKindAxeCommand {
7596    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindAxeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7597    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7598        let __mi = Self::get_name_method_info();
7599        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7600        __inner(this.into(), ::core::option::Option::None)
7601    }
7602
7603    #[doc = "Direct (non-virtual) call to `SystemCalculator_ItemKindAxeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7604    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7605        let __mi = Self::get_method_info();
7606        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7607        __inner(this.into(), ::core::option::Option::None)
7608    }
7609}
7610
7611#[cfg(feature = "app-systemcalculator")]
7612impl SystemCalculator_ItemKindAxeCommand {
7613    #[doc = "`.ctor()` — no args"]
7614    pub fn new() -> Self {
7615        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7616            panic!(
7617                "{}
7618::{}
7619 failed to instantiate",
7620                ::core::stringify!(SystemCalculator_ItemKindAxeCommand),
7621                ::core::stringify!(new),
7622            )
7623        });
7624        <Self as ISystemCalculator_ItemKindAxeCommandMethods>::ctor(this);
7625        this
7626    }
7627}
7628
7629#[cfg(feature = "app-systemcalculator")]
7630pub trait ISystemCalculator_DifficultyNormalCommandMethods: ISystemCalculator_DifficultyNormalCommand {
7631    #[doc = "`get_Name()` overload"]
7632    fn get_name(self) -> ::unity::Il2CppString {
7633        unsafe {
7634            let __receiver = <SystemCalculator_DifficultyNormalCommand as ::unity::FromIlInstance>::from_il_instance(
7635                <Self as ::unity::SystemObject>::as_instance(self),
7636            );
7637            {
7638                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7639                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7640                    panic!(
7641                        "unity: virtual slot {}
7642 out of range (vtable len {}
7643) on the runtime class behind {}
7644 (method `{}
7645`)",
7646                        4usize,
7647                        __vt.len(),
7648                        <SystemCalculator_DifficultyNormalCommand as ::unity::ClassIdentity>::NAME,
7649                        "get_Name",
7650                    )
7651                });
7652                let __inner: extern "C" fn(SystemCalculator_DifficultyNormalCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7653                    ::core::mem::transmute(__vi.method_ptr);
7654                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7655                __inner(__receiver, __mi)
7656            }
7657        }
7658    }
7659    #[doc = "`Get()` overload"]
7660    fn get(self) -> f32 {
7661        unsafe {
7662            let __receiver = <SystemCalculator_DifficultyNormalCommand as ::unity::FromIlInstance>::from_il_instance(
7663                <Self as ::unity::SystemObject>::as_instance(self),
7664            );
7665            {
7666                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7667                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7668                    panic!(
7669                        "unity: virtual slot {}
7670 out of range (vtable len {}
7671) on the runtime class behind {}
7672 (method `{}
7673`)",
7674                        9usize,
7675                        __vt.len(),
7676                        <SystemCalculator_DifficultyNormalCommand as ::unity::ClassIdentity>::NAME,
7677                        "Get",
7678                    )
7679                });
7680                let __inner: extern "C" fn(SystemCalculator_DifficultyNormalCommand, ::unity::OptionalMethod) -> f32 =
7681                    ::core::mem::transmute(__vi.method_ptr);
7682                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7683                __inner(__receiver, __mi)
7684            }
7685        }
7686    }
7687    #[doc = "`.ctor()` overload"]
7688    fn ctor(self) -> () {
7689        unsafe {
7690            let __receiver = <SystemCalculator_DifficultyNormalCommand as ::unity::FromIlInstance>::from_il_instance(
7691                <Self as ::unity::SystemObject>::as_instance(self),
7692            );
7693            ::unity::il2cpp_call!((::unity::module_base()+0x21f83c0usize)as*mut u8,();
7694(SystemCalculator_DifficultyNormalCommand)__receiver)
7695        }
7696    }
7697}
7698
7699#[cfg(feature = "app-systemcalculator")]
7700impl<__T: ISystemCalculator_DifficultyNormalCommand> ISystemCalculator_DifficultyNormalCommandMethods for __T {}
7701
7702#[cfg(feature = "app-systemcalculator")]
7703impl SystemCalculator_DifficultyNormalCommand {
7704    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7705        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7706    }
7707
7708    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7709        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7710    }
7711
7712    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7713        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7714    }
7715}
7716
7717#[cfg(feature = "app-systemcalculator")]
7718impl SystemCalculator_DifficultyNormalCommand {
7719    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyNormalCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7720    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7721        let __mi = Self::get_name_method_info();
7722        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7723        __inner(this.into(), ::core::option::Option::None)
7724    }
7725
7726    #[doc = "Direct (non-virtual) call to `SystemCalculator_DifficultyNormalCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7727    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7728        let __mi = Self::get_method_info();
7729        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7730        __inner(this.into(), ::core::option::Option::None)
7731    }
7732}
7733
7734#[cfg(feature = "app-systemcalculator")]
7735impl SystemCalculator_DifficultyNormalCommand {
7736    #[doc = "`.ctor()` — no args"]
7737    pub fn new() -> Self {
7738        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7739            panic!(
7740                "{}
7741::{}
7742 failed to instantiate",
7743                ::core::stringify!(SystemCalculator_DifficultyNormalCommand),
7744                ::core::stringify!(new),
7745            )
7746        });
7747        <Self as ISystemCalculator_DifficultyNormalCommandMethods>::ctor(this);
7748        this
7749    }
7750}
7751
7752#[cfg(feature = "app-systemcalculator")]
7753pub trait ISystemCalculator_GenderFemaleCommandMethods: ISystemCalculator_GenderFemaleCommand {
7754    #[doc = "`get_Name()` overload"]
7755    fn get_name(self) -> ::unity::Il2CppString {
7756        unsafe {
7757            let __receiver = <SystemCalculator_GenderFemaleCommand as ::unity::FromIlInstance>::from_il_instance(
7758                <Self as ::unity::SystemObject>::as_instance(self),
7759            );
7760            {
7761                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7762                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7763                    panic!(
7764                        "unity: virtual slot {}
7765 out of range (vtable len {}
7766) on the runtime class behind {}
7767 (method `{}
7768`)",
7769                        4usize,
7770                        __vt.len(),
7771                        <SystemCalculator_GenderFemaleCommand as ::unity::ClassIdentity>::NAME,
7772                        "get_Name",
7773                    )
7774                });
7775                let __inner: extern "C" fn(SystemCalculator_GenderFemaleCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7776                    ::core::mem::transmute(__vi.method_ptr);
7777                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7778                __inner(__receiver, __mi)
7779            }
7780        }
7781    }
7782    #[doc = "`Get()` overload"]
7783    fn get(self) -> f32 {
7784        unsafe {
7785            let __receiver = <SystemCalculator_GenderFemaleCommand as ::unity::FromIlInstance>::from_il_instance(
7786                <Self as ::unity::SystemObject>::as_instance(self),
7787            );
7788            {
7789                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7790                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7791                    panic!(
7792                        "unity: virtual slot {}
7793 out of range (vtable len {}
7794) on the runtime class behind {}
7795 (method `{}
7796`)",
7797                        9usize,
7798                        __vt.len(),
7799                        <SystemCalculator_GenderFemaleCommand as ::unity::ClassIdentity>::NAME,
7800                        "Get",
7801                    )
7802                });
7803                let __inner: extern "C" fn(SystemCalculator_GenderFemaleCommand, ::unity::OptionalMethod) -> f32 =
7804                    ::core::mem::transmute(__vi.method_ptr);
7805                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7806                __inner(__receiver, __mi)
7807            }
7808        }
7809    }
7810    #[doc = "`.ctor()` overload"]
7811    fn ctor(self) -> () {
7812        unsafe {
7813            let __receiver = <SystemCalculator_GenderFemaleCommand as ::unity::FromIlInstance>::from_il_instance(
7814                <Self as ::unity::SystemObject>::as_instance(self),
7815            );
7816            ::unity::il2cpp_call!((::unity::module_base()+0x21f8820usize)as*mut u8,();
7817(SystemCalculator_GenderFemaleCommand)__receiver)
7818        }
7819    }
7820}
7821
7822#[cfg(feature = "app-systemcalculator")]
7823impl<__T: ISystemCalculator_GenderFemaleCommand> ISystemCalculator_GenderFemaleCommandMethods for __T {}
7824
7825#[cfg(feature = "app-systemcalculator")]
7826impl SystemCalculator_GenderFemaleCommand {
7827    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7828        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7829    }
7830
7831    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7832        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7833    }
7834
7835    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7836        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
7837    }
7838}
7839
7840#[cfg(feature = "app-systemcalculator")]
7841impl SystemCalculator_GenderFemaleCommand {
7842    #[doc = "Direct (non-virtual) call to `SystemCalculator_GenderFemaleCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7843    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
7844        let __mi = Self::get_name_method_info();
7845        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
7846        __inner(this.into(), ::core::option::Option::None)
7847    }
7848
7849    #[doc = "Direct (non-virtual) call to `SystemCalculator_GenderFemaleCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7850    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
7851        let __mi = Self::get_method_info();
7852        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
7853        __inner(this.into(), ::core::option::Option::None)
7854    }
7855}
7856
7857#[cfg(feature = "app-systemcalculator")]
7858impl SystemCalculator_GenderFemaleCommand {
7859    #[doc = "`.ctor()` — no args"]
7860    pub fn new() -> Self {
7861        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7862            panic!(
7863                "{}
7864::{}
7865 failed to instantiate",
7866                ::core::stringify!(SystemCalculator_GenderFemaleCommand),
7867                ::core::stringify!(new),
7868            )
7869        });
7870        <Self as ISystemCalculator_GenderFemaleCommandMethods>::ctor(this);
7871        this
7872    }
7873}
7874
7875#[cfg(feature = "app-systemcalculator")]
7876pub trait ISystemCalculator_BattleStyleCovertCommandMethods: ISystemCalculator_BattleStyleCovertCommand {
7877    #[doc = "`get_Style()` overload"]
7878    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
7879        unsafe {
7880            let __receiver = <SystemCalculator_BattleStyleCovertCommand as ::unity::FromIlInstance>::from_il_instance(
7881                <Self as ::unity::SystemObject>::as_instance(self),
7882            );
7883            {
7884                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7885                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
7886                    panic!(
7887                        "unity: virtual slot {}
7888 out of range (vtable len {}
7889) on the runtime class behind {}
7890 (method `{}
7891`)",
7892                        30usize,
7893                        __vt.len(),
7894                        <SystemCalculator_BattleStyleCovertCommand as ::unity::ClassIdentity>::NAME,
7895                        "get_Style",
7896                    )
7897                });
7898                let __inner: extern "C" fn(
7899                    SystemCalculator_BattleStyleCovertCommand,
7900                    ::unity::OptionalMethod,
7901                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
7902                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7903                __inner(__receiver, __mi)
7904            }
7905        }
7906    }
7907    #[doc = "`.ctor()` overload"]
7908    fn ctor(self) -> () {
7909        unsafe {
7910            let __receiver = <SystemCalculator_BattleStyleCovertCommand as ::unity::FromIlInstance>::from_il_instance(
7911                <Self as ::unity::SystemObject>::as_instance(self),
7912            );
7913            ::unity::il2cpp_call!((::unity::module_base()+0x21f8140usize)as*mut u8,();
7914(SystemCalculator_BattleStyleCovertCommand)__receiver)
7915        }
7916    }
7917}
7918
7919#[cfg(feature = "app-systemcalculator")]
7920impl<__T: ISystemCalculator_BattleStyleCovertCommand> ISystemCalculator_BattleStyleCovertCommandMethods for __T {}
7921
7922#[cfg(feature = "app-systemcalculator")]
7923impl SystemCalculator_BattleStyleCovertCommand {
7924    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7925        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
7926    }
7927
7928    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
7929        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
7930    }
7931}
7932
7933#[cfg(feature = "app-systemcalculator")]
7934impl SystemCalculator_BattleStyleCovertCommand {
7935    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleCovertCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
7936    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
7937        let __mi = Self::get_style_method_info();
7938        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
7939            ::core::mem::transmute(__mi.method_ptr);
7940        __inner(this.into(), ::core::option::Option::None)
7941    }
7942}
7943
7944#[cfg(feature = "app-systemcalculator")]
7945impl SystemCalculator_BattleStyleCovertCommand {
7946    #[doc = "`.ctor()` — no args"]
7947    pub fn new() -> Self {
7948        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
7949            panic!(
7950                "{}
7951::{}
7952 failed to instantiate",
7953                ::core::stringify!(SystemCalculator_BattleStyleCovertCommand),
7954                ::core::stringify!(new),
7955            )
7956        });
7957        <Self as ISystemCalculator_BattleStyleCovertCommandMethods>::ctor(this);
7958        this
7959    }
7960}
7961
7962#[cfg(feature = "app-systemcalculator")]
7963pub trait ISystemCalculator_Force2ndCommandMethods: ISystemCalculator_Force2ndCommand {
7964    #[doc = "`get_Name()` overload"]
7965    fn get_name(self) -> ::unity::Il2CppString {
7966        unsafe {
7967            let __receiver =
7968                <SystemCalculator_Force2ndCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7969            {
7970                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7971                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
7972                    panic!(
7973                        "unity: virtual slot {}
7974 out of range (vtable len {}
7975) on the runtime class behind {}
7976 (method `{}
7977`)",
7978                        4usize,
7979                        __vt.len(),
7980                        <SystemCalculator_Force2ndCommand as ::unity::ClassIdentity>::NAME,
7981                        "get_Name",
7982                    )
7983                });
7984                let __inner: extern "C" fn(SystemCalculator_Force2ndCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
7985                    ::core::mem::transmute(__vi.method_ptr);
7986                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
7987                __inner(__receiver, __mi)
7988            }
7989        }
7990    }
7991    #[doc = "`Get()` overload"]
7992    fn get(self) -> f32 {
7993        unsafe {
7994            let __receiver =
7995                <SystemCalculator_Force2ndCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
7996            {
7997                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
7998                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
7999                    panic!(
8000                        "unity: virtual slot {}
8001 out of range (vtable len {}
8002) on the runtime class behind {}
8003 (method `{}
8004`)",
8005                        9usize,
8006                        __vt.len(),
8007                        <SystemCalculator_Force2ndCommand as ::unity::ClassIdentity>::NAME,
8008                        "Get",
8009                    )
8010                });
8011                let __inner: extern "C" fn(SystemCalculator_Force2ndCommand, ::unity::OptionalMethod) -> f32 =
8012                    ::core::mem::transmute(__vi.method_ptr);
8013                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8014                __inner(__receiver, __mi)
8015            }
8016        }
8017    }
8018    #[doc = "`.ctor()` overload"]
8019    fn ctor(self) -> () {
8020        unsafe {
8021            let __receiver =
8022                <SystemCalculator_Force2ndCommand as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
8023            ::unity::il2cpp_call!((::unity::module_base()+0x21f8660usize)as*mut u8,();
8024(SystemCalculator_Force2ndCommand)__receiver)
8025        }
8026    }
8027}
8028
8029#[cfg(feature = "app-systemcalculator")]
8030impl<__T: ISystemCalculator_Force2ndCommand> ISystemCalculator_Force2ndCommandMethods for __T {}
8031
8032#[cfg(feature = "app-systemcalculator")]
8033impl SystemCalculator_Force2ndCommand {
8034    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8035        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8036    }
8037
8038    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8039        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8040    }
8041
8042    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8043        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8044    }
8045}
8046
8047#[cfg(feature = "app-systemcalculator")]
8048impl SystemCalculator_Force2ndCommand {
8049    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force2ndCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8050    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8051        let __mi = Self::get_name_method_info();
8052        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8053        __inner(this.into(), ::core::option::Option::None)
8054    }
8055
8056    #[doc = "Direct (non-virtual) call to `SystemCalculator_Force2ndCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8057    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
8058        let __mi = Self::get_method_info();
8059        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8060        __inner(this.into(), ::core::option::Option::None)
8061    }
8062}
8063
8064#[cfg(feature = "app-systemcalculator")]
8065impl SystemCalculator_Force2ndCommand {
8066    #[doc = "`.ctor()` — no args"]
8067    pub fn new() -> Self {
8068        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8069            panic!(
8070                "{}
8071::{}
8072 failed to instantiate",
8073                ::core::stringify!(SystemCalculator_Force2ndCommand),
8074                ::core::stringify!(new),
8075            )
8076        });
8077        <Self as ISystemCalculator_Force2ndCommandMethods>::ctor(this);
8078        this
8079    }
8080}
8081
8082#[cfg(feature = "app-systemcalculator")]
8083pub trait ISystemCalculator_DragonAttributeCommandMethods: ISystemCalculator_DragonAttributeCommand {
8084    #[doc = "`get_Name()` overload"]
8085    fn get_name(self) -> ::unity::Il2CppString {
8086        unsafe {
8087            let __receiver = <SystemCalculator_DragonAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8088                <Self as ::unity::SystemObject>::as_instance(self),
8089            );
8090            {
8091                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8092                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8093                    panic!(
8094                        "unity: virtual slot {}
8095 out of range (vtable len {}
8096) on the runtime class behind {}
8097 (method `{}
8098`)",
8099                        4usize,
8100                        __vt.len(),
8101                        <SystemCalculator_DragonAttributeCommand as ::unity::ClassIdentity>::NAME,
8102                        "get_Name",
8103                    )
8104                });
8105                let __inner: extern "C" fn(SystemCalculator_DragonAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8106                    ::core::mem::transmute(__vi.method_ptr);
8107                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8108                __inner(__receiver, __mi)
8109            }
8110        }
8111    }
8112    #[doc = "`Get()` overload"]
8113    fn get(self) -> f32 {
8114        unsafe {
8115            let __receiver = <SystemCalculator_DragonAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8116                <Self as ::unity::SystemObject>::as_instance(self),
8117            );
8118            {
8119                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8120                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
8121                    panic!(
8122                        "unity: virtual slot {}
8123 out of range (vtable len {}
8124) on the runtime class behind {}
8125 (method `{}
8126`)",
8127                        9usize,
8128                        __vt.len(),
8129                        <SystemCalculator_DragonAttributeCommand as ::unity::ClassIdentity>::NAME,
8130                        "Get",
8131                    )
8132                });
8133                let __inner: extern "C" fn(SystemCalculator_DragonAttributeCommand, ::unity::OptionalMethod) -> f32 =
8134                    ::core::mem::transmute(__vi.method_ptr);
8135                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8136                __inner(__receiver, __mi)
8137            }
8138        }
8139    }
8140    #[doc = "`.ctor()` overload"]
8141    fn ctor(self) -> () {
8142        unsafe {
8143            let __receiver = <SystemCalculator_DragonAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8144                <Self as ::unity::SystemObject>::as_instance(self),
8145            );
8146            ::unity::il2cpp_call!((::unity::module_base()+0x21f8430usize)as*mut u8,();
8147(SystemCalculator_DragonAttributeCommand)__receiver)
8148        }
8149    }
8150}
8151
8152#[cfg(feature = "app-systemcalculator")]
8153impl<__T: ISystemCalculator_DragonAttributeCommand> ISystemCalculator_DragonAttributeCommandMethods for __T {}
8154
8155#[cfg(feature = "app-systemcalculator")]
8156impl SystemCalculator_DragonAttributeCommand {
8157    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8158        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8159    }
8160
8161    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8162        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8163    }
8164
8165    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8166        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8167    }
8168}
8169
8170#[cfg(feature = "app-systemcalculator")]
8171impl SystemCalculator_DragonAttributeCommand {
8172    #[doc = "Direct (non-virtual) call to `SystemCalculator_DragonAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8173    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8174        let __mi = Self::get_name_method_info();
8175        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8176        __inner(this.into(), ::core::option::Option::None)
8177    }
8178
8179    #[doc = "Direct (non-virtual) call to `SystemCalculator_DragonAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8180    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
8181        let __mi = Self::get_method_info();
8182        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8183        __inner(this.into(), ::core::option::Option::None)
8184    }
8185}
8186
8187#[cfg(feature = "app-systemcalculator")]
8188impl SystemCalculator_DragonAttributeCommand {
8189    #[doc = "`.ctor()` — no args"]
8190    pub fn new() -> Self {
8191        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8192            panic!(
8193                "{}
8194::{}
8195 failed to instantiate",
8196                ::core::stringify!(SystemCalculator_DragonAttributeCommand),
8197                ::core::stringify!(new),
8198            )
8199        });
8200        <Self as ISystemCalculator_DragonAttributeCommandMethods>::ctor(this);
8201        this
8202    }
8203}
8204
8205#[cfg(feature = "app-systemcalculator")]
8206pub trait ISystemCalculator_BattleStyleHorseCommandMethods: ISystemCalculator_BattleStyleHorseCommand {
8207    #[doc = "`get_Style()` overload"]
8208    fn get_style(self) -> crate::app::battlestyle::BattleStyle_Types {
8209        unsafe {
8210            let __receiver = <SystemCalculator_BattleStyleHorseCommand as ::unity::FromIlInstance>::from_il_instance(
8211                <Self as ::unity::SystemObject>::as_instance(self),
8212            );
8213            {
8214                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8215                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
8216                    panic!(
8217                        "unity: virtual slot {}
8218 out of range (vtable len {}
8219) on the runtime class behind {}
8220 (method `{}
8221`)",
8222                        30usize,
8223                        __vt.len(),
8224                        <SystemCalculator_BattleStyleHorseCommand as ::unity::ClassIdentity>::NAME,
8225                        "get_Style",
8226                    )
8227                });
8228                let __inner: extern "C" fn(
8229                    SystemCalculator_BattleStyleHorseCommand,
8230                    ::unity::OptionalMethod,
8231                ) -> crate::app::battlestyle::BattleStyle_Types = ::core::mem::transmute(__vi.method_ptr);
8232                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8233                __inner(__receiver, __mi)
8234            }
8235        }
8236    }
8237    #[doc = "`.ctor()` overload"]
8238    fn ctor(self) -> () {
8239        unsafe {
8240            let __receiver = <SystemCalculator_BattleStyleHorseCommand as ::unity::FromIlInstance>::from_il_instance(
8241                <Self as ::unity::SystemObject>::as_instance(self),
8242            );
8243            ::unity::il2cpp_call!((::unity::module_base()+0x21f81c0usize)as*mut u8,();
8244(SystemCalculator_BattleStyleHorseCommand)__receiver)
8245        }
8246    }
8247}
8248
8249#[cfg(feature = "app-systemcalculator")]
8250impl<__T: ISystemCalculator_BattleStyleHorseCommand> ISystemCalculator_BattleStyleHorseCommandMethods for __T {}
8251
8252#[cfg(feature = "app-systemcalculator")]
8253impl SystemCalculator_BattleStyleHorseCommand {
8254    pub fn get_style_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8255        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8256    }
8257
8258    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8259        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8260    }
8261}
8262
8263#[cfg(feature = "app-systemcalculator")]
8264impl SystemCalculator_BattleStyleHorseCommand {
8265    #[doc = "Direct (non-virtual) call to `SystemCalculator_BattleStyleHorseCommand`'s own `get_Style`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8266    pub unsafe fn get_style(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::battlestyle::BattleStyle_Types {
8267        let __mi = Self::get_style_method_info();
8268        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::battlestyle::BattleStyle_Types =
8269            ::core::mem::transmute(__mi.method_ptr);
8270        __inner(this.into(), ::core::option::Option::None)
8271    }
8272}
8273
8274#[cfg(feature = "app-systemcalculator")]
8275impl SystemCalculator_BattleStyleHorseCommand {
8276    #[doc = "`.ctor()` — no args"]
8277    pub fn new() -> Self {
8278        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8279            panic!(
8280                "{}
8281::{}
8282 failed to instantiate",
8283                ::core::stringify!(SystemCalculator_BattleStyleHorseCommand),
8284                ::core::stringify!(new),
8285            )
8286        });
8287        <Self as ISystemCalculator_BattleStyleHorseCommandMethods>::ctor(this);
8288        this
8289    }
8290}
8291
8292#[cfg(feature = "app-systemcalculator")]
8293pub trait ISystemCalculator_WeaponLevelSCommandMethods: ISystemCalculator_WeaponLevelSCommand {
8294    #[doc = "`get_Name()` overload"]
8295    fn get_name(self) -> ::unity::Il2CppString {
8296        unsafe {
8297            let __receiver = <SystemCalculator_WeaponLevelSCommand as ::unity::FromIlInstance>::from_il_instance(
8298                <Self as ::unity::SystemObject>::as_instance(self),
8299            );
8300            {
8301                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8302                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8303                    panic!(
8304                        "unity: virtual slot {}
8305 out of range (vtable len {}
8306) on the runtime class behind {}
8307 (method `{}
8308`)",
8309                        4usize,
8310                        __vt.len(),
8311                        <SystemCalculator_WeaponLevelSCommand as ::unity::ClassIdentity>::NAME,
8312                        "get_Name",
8313                    )
8314                });
8315                let __inner: extern "C" fn(SystemCalculator_WeaponLevelSCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8316                    ::core::mem::transmute(__vi.method_ptr);
8317                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8318                __inner(__receiver, __mi)
8319            }
8320        }
8321    }
8322    #[doc = "`Get()` overload"]
8323    fn get(self) -> f32 {
8324        unsafe {
8325            let __receiver = <SystemCalculator_WeaponLevelSCommand as ::unity::FromIlInstance>::from_il_instance(
8326                <Self as ::unity::SystemObject>::as_instance(self),
8327            );
8328            {
8329                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8330                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
8331                    panic!(
8332                        "unity: virtual slot {}
8333 out of range (vtable len {}
8334) on the runtime class behind {}
8335 (method `{}
8336`)",
8337                        9usize,
8338                        __vt.len(),
8339                        <SystemCalculator_WeaponLevelSCommand as ::unity::ClassIdentity>::NAME,
8340                        "Get",
8341                    )
8342                });
8343                let __inner: extern "C" fn(SystemCalculator_WeaponLevelSCommand, ::unity::OptionalMethod) -> f32 =
8344                    ::core::mem::transmute(__vi.method_ptr);
8345                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8346                __inner(__receiver, __mi)
8347            }
8348        }
8349    }
8350    #[doc = "`.ctor()` overload"]
8351    fn ctor(self) -> () {
8352        unsafe {
8353            let __receiver = <SystemCalculator_WeaponLevelSCommand as ::unity::FromIlInstance>::from_il_instance(
8354                <Self as ::unity::SystemObject>::as_instance(self),
8355            );
8356            ::unity::il2cpp_call!((::unity::module_base()+0x21f9ea0usize)as*mut u8,();
8357(SystemCalculator_WeaponLevelSCommand)__receiver)
8358        }
8359    }
8360}
8361
8362#[cfg(feature = "app-systemcalculator")]
8363impl<__T: ISystemCalculator_WeaponLevelSCommand> ISystemCalculator_WeaponLevelSCommandMethods for __T {}
8364
8365#[cfg(feature = "app-systemcalculator")]
8366impl SystemCalculator_WeaponLevelSCommand {
8367    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8368        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8369    }
8370
8371    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8372        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8373    }
8374
8375    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8376        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8377    }
8378}
8379
8380#[cfg(feature = "app-systemcalculator")]
8381impl SystemCalculator_WeaponLevelSCommand {
8382    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelSCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8383    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8384        let __mi = Self::get_name_method_info();
8385        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8386        __inner(this.into(), ::core::option::Option::None)
8387    }
8388
8389    #[doc = "Direct (non-virtual) call to `SystemCalculator_WeaponLevelSCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8390    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
8391        let __mi = Self::get_method_info();
8392        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8393        __inner(this.into(), ::core::option::Option::None)
8394    }
8395}
8396
8397#[cfg(feature = "app-systemcalculator")]
8398impl SystemCalculator_WeaponLevelSCommand {
8399    #[doc = "`.ctor()` — no args"]
8400    pub fn new() -> Self {
8401        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8402            panic!(
8403                "{}
8404::{}
8405 failed to instantiate",
8406                ::core::stringify!(SystemCalculator_WeaponLevelSCommand),
8407                ::core::stringify!(new),
8408            )
8409        });
8410        <Self as ISystemCalculator_WeaponLevelSCommandMethods>::ctor(this);
8411        this
8412    }
8413}
8414
8415#[cfg(feature = "app-systemcalculator")]
8416pub trait ISystemCalculator_GameModeClassicCommandMethods: ISystemCalculator_GameModeClassicCommand {
8417    #[doc = "`get_Name()` overload"]
8418    fn get_name(self) -> ::unity::Il2CppString {
8419        unsafe {
8420            let __receiver = <SystemCalculator_GameModeClassicCommand as ::unity::FromIlInstance>::from_il_instance(
8421                <Self as ::unity::SystemObject>::as_instance(self),
8422            );
8423            {
8424                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8425                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8426                    panic!(
8427                        "unity: virtual slot {}
8428 out of range (vtable len {}
8429) on the runtime class behind {}
8430 (method `{}
8431`)",
8432                        4usize,
8433                        __vt.len(),
8434                        <SystemCalculator_GameModeClassicCommand as ::unity::ClassIdentity>::NAME,
8435                        "get_Name",
8436                    )
8437                });
8438                let __inner: extern "C" fn(SystemCalculator_GameModeClassicCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8439                    ::core::mem::transmute(__vi.method_ptr);
8440                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8441                __inner(__receiver, __mi)
8442            }
8443        }
8444    }
8445    #[doc = "`Get()` overload"]
8446    fn get(self) -> f32 {
8447        unsafe {
8448            let __receiver = <SystemCalculator_GameModeClassicCommand as ::unity::FromIlInstance>::from_il_instance(
8449                <Self as ::unity::SystemObject>::as_instance(self),
8450            );
8451            {
8452                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8453                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
8454                    panic!(
8455                        "unity: virtual slot {}
8456 out of range (vtable len {}
8457) on the runtime class behind {}
8458 (method `{}
8459`)",
8460                        9usize,
8461                        __vt.len(),
8462                        <SystemCalculator_GameModeClassicCommand as ::unity::ClassIdentity>::NAME,
8463                        "Get",
8464                    )
8465                });
8466                let __inner: extern "C" fn(SystemCalculator_GameModeClassicCommand, ::unity::OptionalMethod) -> f32 =
8467                    ::core::mem::transmute(__vi.method_ptr);
8468                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8469                __inner(__receiver, __mi)
8470            }
8471        }
8472    }
8473    #[doc = "`.ctor()` overload"]
8474    fn ctor(self) -> () {
8475        unsafe {
8476            let __receiver = <SystemCalculator_GameModeClassicCommand as ::unity::FromIlInstance>::from_il_instance(
8477                <Self as ::unity::SystemObject>::as_instance(self),
8478            );
8479            ::unity::il2cpp_call!((::unity::module_base()+0x21f87b0usize)as*mut u8,();
8480(SystemCalculator_GameModeClassicCommand)__receiver)
8481        }
8482    }
8483}
8484
8485#[cfg(feature = "app-systemcalculator")]
8486impl<__T: ISystemCalculator_GameModeClassicCommand> ISystemCalculator_GameModeClassicCommandMethods for __T {}
8487
8488#[cfg(feature = "app-systemcalculator")]
8489impl SystemCalculator_GameModeClassicCommand {
8490    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8491        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8492    }
8493
8494    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8495        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8496    }
8497
8498    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8499        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8500    }
8501}
8502
8503#[cfg(feature = "app-systemcalculator")]
8504impl SystemCalculator_GameModeClassicCommand {
8505    #[doc = "Direct (non-virtual) call to `SystemCalculator_GameModeClassicCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8506    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8507        let __mi = Self::get_name_method_info();
8508        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8509        __inner(this.into(), ::core::option::Option::None)
8510    }
8511
8512    #[doc = "Direct (non-virtual) call to `SystemCalculator_GameModeClassicCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8513    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
8514        let __mi = Self::get_method_info();
8515        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8516        __inner(this.into(), ::core::option::Option::None)
8517    }
8518}
8519
8520#[cfg(feature = "app-systemcalculator")]
8521impl SystemCalculator_GameModeClassicCommand {
8522    #[doc = "`.ctor()` — no args"]
8523    pub fn new() -> Self {
8524        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8525            panic!(
8526                "{}
8527::{}
8528 failed to instantiate",
8529                ::core::stringify!(SystemCalculator_GameModeClassicCommand),
8530                ::core::stringify!(new),
8531            )
8532        });
8533        <Self as ISystemCalculator_GameModeClassicCommandMethods>::ctor(this);
8534        this
8535    }
8536}
8537
8538#[cfg(feature = "app-systemcalculator")]
8539pub trait ISystemCalculator_FlyAttributeCommandMethods: ISystemCalculator_FlyAttributeCommand {
8540    #[doc = "`get_Name()` overload"]
8541    fn get_name(self) -> ::unity::Il2CppString {
8542        unsafe {
8543            let __receiver = <SystemCalculator_FlyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8544                <Self as ::unity::SystemObject>::as_instance(self),
8545            );
8546            {
8547                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8548                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
8549                    panic!(
8550                        "unity: virtual slot {}
8551 out of range (vtable len {}
8552) on the runtime class behind {}
8553 (method `{}
8554`)",
8555                        4usize,
8556                        __vt.len(),
8557                        <SystemCalculator_FlyAttributeCommand as ::unity::ClassIdentity>::NAME,
8558                        "get_Name",
8559                    )
8560                });
8561                let __inner: extern "C" fn(SystemCalculator_FlyAttributeCommand, ::unity::OptionalMethod) -> ::unity::Il2CppString =
8562                    ::core::mem::transmute(__vi.method_ptr);
8563                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8564                __inner(__receiver, __mi)
8565            }
8566        }
8567    }
8568    #[doc = "`Get()` overload"]
8569    fn get(self) -> f32 {
8570        unsafe {
8571            let __receiver = <SystemCalculator_FlyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8572                <Self as ::unity::SystemObject>::as_instance(self),
8573            );
8574            {
8575                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
8576                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
8577                    panic!(
8578                        "unity: virtual slot {}
8579 out of range (vtable len {}
8580) on the runtime class behind {}
8581 (method `{}
8582`)",
8583                        9usize,
8584                        __vt.len(),
8585                        <SystemCalculator_FlyAttributeCommand as ::unity::ClassIdentity>::NAME,
8586                        "Get",
8587                    )
8588                });
8589                let __inner: extern "C" fn(SystemCalculator_FlyAttributeCommand, ::unity::OptionalMethod) -> f32 =
8590                    ::core::mem::transmute(__vi.method_ptr);
8591                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
8592                __inner(__receiver, __mi)
8593            }
8594        }
8595    }
8596    #[doc = "`.ctor()` overload"]
8597    fn ctor(self) -> () {
8598        unsafe {
8599            let __receiver = <SystemCalculator_FlyAttributeCommand as ::unity::FromIlInstance>::from_il_instance(
8600                <Self as ::unity::SystemObject>::as_instance(self),
8601            );
8602            ::unity::il2cpp_call!((::unity::module_base()+0x21f8580usize)as*mut u8,();
8603(SystemCalculator_FlyAttributeCommand)__receiver)
8604        }
8605    }
8606}
8607
8608#[cfg(feature = "app-systemcalculator")]
8609impl<__T: ISystemCalculator_FlyAttributeCommand> ISystemCalculator_FlyAttributeCommandMethods for __T {}
8610
8611#[cfg(feature = "app-systemcalculator")]
8612impl SystemCalculator_FlyAttributeCommand {
8613    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8614        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
8615    }
8616
8617    pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8618        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
8619    }
8620
8621    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
8622        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
8623    }
8624}
8625
8626#[cfg(feature = "app-systemcalculator")]
8627impl SystemCalculator_FlyAttributeCommand {
8628    #[doc = "Direct (non-virtual) call to `SystemCalculator_FlyAttributeCommand`'s own `get_Name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8629    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
8630        let __mi = Self::get_name_method_info();
8631        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
8632        __inner(this.into(), ::core::option::Option::None)
8633    }
8634
8635    #[doc = "Direct (non-virtual) call to `SystemCalculator_FlyAttributeCommand`'s own `Get`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
8636    pub unsafe fn get(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
8637        let __mi = Self::get_method_info();
8638        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
8639        __inner(this.into(), ::core::option::Option::None)
8640    }
8641}
8642
8643#[cfg(feature = "app-systemcalculator")]
8644impl SystemCalculator_FlyAttributeCommand {
8645    #[doc = "`.ctor()` — no args"]
8646    pub fn new() -> Self {
8647        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
8648            panic!(
8649                "{}
8650::{}
8651 failed to instantiate",
8652                ::core::stringify!(SystemCalculator_FlyAttributeCommand),
8653                ::core::stringify!(new),
8654            )
8655        });
8656        <Self as ISystemCalculator_FlyAttributeCommandMethods>::ctor(this);
8657        this
8658    }
8659}
8660
8661#[cfg(feature = "app-systemcalculator")]
8662#[doc(hidden)]
8663pub mod prelude {
8664    pub use super::{
8665        ISystemCalculator, ISystemCalculatorMethods, ISystemCalculator_BadCommand, ISystemCalculator_BadCommandMethods,
8666        ISystemCalculator_BattleSideChainDefenseCommand, ISystemCalculator_BattleSideChainDefenseCommandMethods,
8667        ISystemCalculator_BattleSideChainOffenseCommand, ISystemCalculator_BattleSideChainOffenseCommandMethods,
8668        ISystemCalculator_BattleSideDefenseCommand, ISystemCalculator_BattleSideDefenseCommandMethods, ISystemCalculator_BattleSideOffenseCommand,
8669        ISystemCalculator_BattleSideOffenseCommandMethods, ISystemCalculator_BattleStyleCommand, ISystemCalculator_BattleStyleCommandMethods,
8670        ISystemCalculator_BattleStyleCooperationCommand, ISystemCalculator_BattleStyleCooperationCommandMethods,
8671        ISystemCalculator_BattleStyleCovertCommand, ISystemCalculator_BattleStyleCovertCommandMethods, ISystemCalculator_BattleStyleDragonCommand,
8672        ISystemCalculator_BattleStyleDragonCommandMethods, ISystemCalculator_BattleStyleFlyCommand, ISystemCalculator_BattleStyleFlyCommandMethods,
8673        ISystemCalculator_BattleStyleHeavyCommand, ISystemCalculator_BattleStyleHeavyCommandMethods, ISystemCalculator_BattleStyleHorseCommand,
8674        ISystemCalculator_BattleStyleHorseCommandMethods, ISystemCalculator_BattleStyleMagicCommand,
8675        ISystemCalculator_BattleStyleMagicCommandMethods, ISystemCalculator_BattleStylePranaCommand,
8676        ISystemCalculator_BattleStylePranaCommandMethods, ISystemCalculator_DarkAttributeCommand, ISystemCalculator_DarkAttributeCommandMethods,
8677        ISystemCalculator_DifficultyHardCommand, ISystemCalculator_DifficultyHardCommandMethods, ISystemCalculator_DifficultyLunaticCommand,
8678        ISystemCalculator_DifficultyLunaticCommandMethods, ISystemCalculator_DifficultyNormalCommand,
8679        ISystemCalculator_DifficultyNormalCommandMethods, ISystemCalculator_DragonAttributeCommand, ISystemCalculator_DragonAttributeCommandMethods,
8680        ISystemCalculator_EvilAttributeCommand, ISystemCalculator_EvilAttributeCommandMethods, ISystemCalculator_FireAttributeCommand,
8681        ISystemCalculator_FireAttributeCommandMethods, ISystemCalculator_FlyAttributeCommand, ISystemCalculator_FlyAttributeCommandMethods,
8682        ISystemCalculator_Force1stCommand, ISystemCalculator_Force1stCommandMethods, ISystemCalculator_Force2ndCommand,
8683        ISystemCalculator_Force2ndCommandMethods, ISystemCalculator_Force3rdCommand, ISystemCalculator_Force3rdCommandMethods,
8684        ISystemCalculator_GameModeCasualCommand, ISystemCalculator_GameModeCasualCommandMethods, ISystemCalculator_GameModeClassicCommand,
8685        ISystemCalculator_GameModeClassicCommandMethods, ISystemCalculator_GenderFemaleCommand, ISystemCalculator_GenderFemaleCommandMethods,
8686        ISystemCalculator_GenderMaleCommand, ISystemCalculator_GenderMaleCommandMethods, ISystemCalculator_GoodCommand,
8687        ISystemCalculator_GoodCommandMethods, ISystemCalculator_HeavyAttributeCommand, ISystemCalculator_HeavyAttributeCommandMethods,
8688        ISystemCalculator_HorseAttributeCommand, ISystemCalculator_HorseAttributeCommandMethods, ISystemCalculator_IceAttributeCommand,
8689        ISystemCalculator_IceAttributeCommandMethods, ISystemCalculator_ItemIndexCommand, ISystemCalculator_ItemIndexCommandMethods,
8690        ISystemCalculator_ItemKindAxeCommand, ISystemCalculator_ItemKindAxeCommandMethods, ISystemCalculator_ItemKindBowCommand,
8691        ISystemCalculator_ItemKindBowCommandMethods, ISystemCalculator_ItemKindDaggerCommand, ISystemCalculator_ItemKindDaggerCommandMethods,
8692        ISystemCalculator_ItemKindFistCommand, ISystemCalculator_ItemKindFistCommandMethods, ISystemCalculator_ItemKindLanceCommand,
8693        ISystemCalculator_ItemKindLanceCommandMethods, ISystemCalculator_ItemKindMagicCommand, ISystemCalculator_ItemKindMagicCommandMethods,
8694        ISystemCalculator_ItemKindRodCommand, ISystemCalculator_ItemKindRodCommandMethods, ISystemCalculator_ItemKindSpecialCommand,
8695        ISystemCalculator_ItemKindSpecialCommandMethods, ISystemCalculator_ItemKindSwordCommand, ISystemCalculator_ItemKindSwordCommandMethods,
8696        ISystemCalculator_JobIndexCommand, ISystemCalculator_JobIndexCommandMethods, ISystemCalculator_JobRankHighCommand,
8697        ISystemCalculator_JobRankHighCommandMethods, ISystemCalculator_JobRankLowCommand, ISystemCalculator_JobRankLowCommandMethods,
8698        ISystemCalculator_LightAttributeCommand, ISystemCalculator_LightAttributeCommandMethods, ISystemCalculator_MagicAttributeCommand,
8699        ISystemCalculator_MagicAttributeCommandMethods, ISystemCalculator_MorphAttributeCommand, ISystemCalculator_MorphAttributeCommandMethods,
8700        ISystemCalculator_MoveCostCommand, ISystemCalculator_MoveCostCommandMethods, ISystemCalculator_NoneAttributeCommand,
8701        ISystemCalculator_NoneAttributeCommandMethods, ISystemCalculator_PersonIndexCommand, ISystemCalculator_PersonIndexCommandMethods,
8702        ISystemCalculator_PhaseCurrentCommand, ISystemCalculator_PhaseCurrentCommandMethods, ISystemCalculator_PhaseOtherCommand,
8703        ISystemCalculator_PhaseOtherCommandMethods, ISystemCalculator_PhysicalAttributeCommand, ISystemCalculator_PhysicalAttributeCommandMethods,
8704        ISystemCalculator_RodTypeBasicCommand, ISystemCalculator_RodTypeBasicCommandMethods, ISystemCalculator_RodTypeHealCommand,
8705        ISystemCalculator_RodTypeHealCommandMethods, ISystemCalculator_RodTypeInterferenceCommand,
8706        ISystemCalculator_RodTypeInterferenceCommandMethods, ISystemCalculator_ScreenShotCommand, ISystemCalculator_ScreenShotCommandMethods,
8707        ISystemCalculator_SkillIndexCommand, ISystemCalculator_SkillIndexCommandMethods, ISystemCalculator_ThunderAttributeCommand,
8708        ISystemCalculator_ThunderAttributeCommandMethods, ISystemCalculator_VsyncCommand, ISystemCalculator_VsyncCommandMethods,
8709        ISystemCalculator_WalkAttributeCommand, ISystemCalculator_WalkAttributeCommandMethods, ISystemCalculator_WeaponLevelACommand,
8710        ISystemCalculator_WeaponLevelACommandMethods, ISystemCalculator_WeaponLevelBCommand, ISystemCalculator_WeaponLevelBCommandMethods,
8711        ISystemCalculator_WeaponLevelCCommand, ISystemCalculator_WeaponLevelCCommandMethods, ISystemCalculator_WeaponLevelDCommand,
8712        ISystemCalculator_WeaponLevelDCommandMethods, ISystemCalculator_WeaponLevelSCommand, ISystemCalculator_WeaponLevelSCommandMethods,
8713        ISystemCalculator_WindAttributeCommand, ISystemCalculator_WindAttributeCommandMethods, SystemCalculator, SystemCalculator_BadCommand,
8714        SystemCalculator_BattleSideChainDefenseCommand, SystemCalculator_BattleSideChainOffenseCommand, SystemCalculator_BattleSideDefenseCommand,
8715        SystemCalculator_BattleSideOffenseCommand, SystemCalculator_BattleStyleCommand, SystemCalculator_BattleStyleCooperationCommand,
8716        SystemCalculator_BattleStyleCovertCommand, SystemCalculator_BattleStyleDragonCommand, SystemCalculator_BattleStyleFlyCommand,
8717        SystemCalculator_BattleStyleHeavyCommand, SystemCalculator_BattleStyleHorseCommand, SystemCalculator_BattleStyleMagicCommand,
8718        SystemCalculator_BattleStylePranaCommand, SystemCalculator_DarkAttributeCommand, SystemCalculator_DifficultyHardCommand,
8719        SystemCalculator_DifficultyLunaticCommand, SystemCalculator_DifficultyNormalCommand, SystemCalculator_DragonAttributeCommand,
8720        SystemCalculator_EvilAttributeCommand, SystemCalculator_FireAttributeCommand, SystemCalculator_FlyAttributeCommand,
8721        SystemCalculator_Force1stCommand, SystemCalculator_Force2ndCommand, SystemCalculator_Force3rdCommand, SystemCalculator_GameModeCasualCommand,
8722        SystemCalculator_GameModeClassicCommand, SystemCalculator_GenderFemaleCommand, SystemCalculator_GenderMaleCommand,
8723        SystemCalculator_GoodCommand, SystemCalculator_HeavyAttributeCommand, SystemCalculator_HorseAttributeCommand,
8724        SystemCalculator_IceAttributeCommand, SystemCalculator_ItemIndexCommand, SystemCalculator_ItemKindAxeCommand,
8725        SystemCalculator_ItemKindBowCommand, SystemCalculator_ItemKindDaggerCommand, SystemCalculator_ItemKindFistCommand,
8726        SystemCalculator_ItemKindLanceCommand, SystemCalculator_ItemKindMagicCommand, SystemCalculator_ItemKindRodCommand,
8727        SystemCalculator_ItemKindSpecialCommand, SystemCalculator_ItemKindSwordCommand, SystemCalculator_JobIndexCommand,
8728        SystemCalculator_JobRankHighCommand, SystemCalculator_JobRankLowCommand, SystemCalculator_LightAttributeCommand,
8729        SystemCalculator_MagicAttributeCommand, SystemCalculator_MorphAttributeCommand, SystemCalculator_MoveCostCommand,
8730        SystemCalculator_NoneAttributeCommand, SystemCalculator_PersonIndexCommand, SystemCalculator_PhaseCurrentCommand,
8731        SystemCalculator_PhaseOtherCommand, SystemCalculator_PhysicalAttributeCommand, SystemCalculator_RodTypeBasicCommand,
8732        SystemCalculator_RodTypeHealCommand, SystemCalculator_RodTypeInterferenceCommand, SystemCalculator_ScreenShotCommand,
8733        SystemCalculator_SkillIndexCommand, SystemCalculator_ThunderAttributeCommand, SystemCalculator_VsyncCommand,
8734        SystemCalculator_WalkAttributeCommand, SystemCalculator_WeaponLevelACommand, SystemCalculator_WeaponLevelBCommand,
8735        SystemCalculator_WeaponLevelCCommand, SystemCalculator_WeaponLevelDCommand, SystemCalculator_WeaponLevelSCommand,
8736        SystemCalculator_WindAttributeCommand,
8737    };
8738    #[cfg(feature = "app-calculatorcommand")]
8739    pub use crate::app::calculatorcommand::ICalculatorCommandMethods;
8740    #[cfg(feature = "app-calculatormanager")]
8741    pub use crate::app::calculatormanager::ICalculatorManagerMethods;
8742    #[cfg(feature = "app-calculatorutil")]
8743    pub use crate::app::calculatorutil::ICalculatorUtilMethods;
8744    #[cfg(feature = "app-gamecalculatorcommand")]
8745    pub use crate::app::gamecalculatorcommand::IGameCalculatorCommandMethods;
8746    #[cfg(feature = "system-object")]
8747    pub use crate::system::object::IObjectMethods;
8748    pub use crate::{
8749        app::{
8750            calculatorcommand::ICalculatorCommand, calculatormanager::ICalculatorManager, calculatorutil::ICalculatorUtil,
8751            gamecalculatorcommand::IGameCalculatorCommand,
8752        },
8753        system::object::IObject,
8754    };
8755}
engage/generated/app/systemcalculator.rs

engage/generated/app/
systemcalculator.rs
