Rust · Decryptions

Rust Decryptions

decryptions.h ·build 24614784 ·dumped 2026-08-17 12:18:15 AM UTC+1 ·462 lines ·17.4 KB ·Aug 16, 2026 latest
Raw Download All dumps
sha256 f13a5fd8e2267c9e016e3005cb680b5c0ee85eebafa765ed96c1c74f27f57458
462 lines
  1. 1// Dumped by amexofficial on discord
  2. 2// amexware.cc
  3. 3 
  4. 4#pragma once
  5. 5#include <cstdint>
  6. 6#include <bit>
  7. 7 
  8. 8namespace offsets
  9. 9{
  10. 10 
  11. 11 namespace decryption
  12. 12 {
  13. 13 
  14. 14 inline std::uintptr_t client_entities(std::uintptr_t hv_value)
  15. 15 {
  16. 16 std::uintptr_t rax = hv_value;
  17. 17 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  18. 18 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  19. 19 std::uint32_t v = *rdx;
  20. 20 v = (v << 31) | (v >> 1);
  21. 21 v += 0x8F7F58E3u;
  22. 22 v = (v << 31) | (v >> 1);
  23. 23 v ^= 0x64DE867Fu;
  24. 24 *rdx = v;
  25. 25 ++rdx;
  26. 26 }
  27. 27 return rax;
  28. 28 }
  29. 29 
  30. 30 inline std::uintptr_t entity_list(std::uintptr_t hv_value)
  31. 31 {
  32. 32 std::uintptr_t rax = hv_value;
  33. 33 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  34. 34 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  35. 35 std::uint32_t v = *rdx;
  36. 36 v += 0x0374D4FAu;
  37. 37 v = (v << 27) | (v >> 5);
  38. 38 v ^= 0x5DD1D7B5u;
  39. 39 v -= 0x10D77418u;
  40. 40 *rdx = v;
  41. 41 ++rdx;
  42. 42 }
  43. 43 return rax;
  44. 44 }
  45. 45 
  46. 46 inline std::uint32_t encrypt_fov(float input)
  47. 47 {
  48. 48 std::uint32_t v = std::bit_cast<std::uint32_t>(input);
  49. 49 v ^= 0x7DCF10AFu;
  50. 50 v = (v << 10) | (v >> 22);
  51. 51 v += 0x06258F02u;
  52. 52 return v;
  53. 53 }
  54. 54 
  55. 55 inline std::uint32_t encrypt_PlayerWalkMovement_groundAngleNew_off_0x108(float value)
  56. 56 {
  57. 57 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  58. 58 v = (v << 10) | (v >> 22);
  59. 59 v -= 0x75B6E603u;
  60. 60 v ^= 0x883CD959u;
  61. 61 v += 0x5EF50FCAu;
  62. 62 return v;
  63. 63 }
  64. 64 
  65. 65 inline std::uint32_t encrypt_PlayerWalkMovement_groundTime_off_0x110(float value)
  66. 66 {
  67. 67 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  68. 68 v += 0x340B5115u;
  69. 69 v = (v << 25) | (v >> 7);
  70. 70 v ^= 0x8D984D53u;
  71. 71 return v;
  72. 72 }
  73. 73 
  74. 74 inline std::uint32_t encrypt_PlayerWalkMovement_jumpTime_off_0x118(float value)
  75. 75 {
  76. 76 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  77. 77 v += 0x5ED8266Au;
  78. 78 v = (v << 24) | (v >> 8);
  79. 79 v ^= 0x975CE3D8u;
  80. 80 v = (v << 22) | (v >> 10);
  81. 81 return v;
  82. 82 }
  83. 83 
  84. 84 inline std::uint32_t encrypt_PlayerWalkMovement_landTime_off_0x120(float value)
  85. 85 {
  86. 86 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  87. 87 v = (v << 7) | (v >> 25);
  88. 88 v -= 0x075CBAD0u;
  89. 89 v = (v << 7) | (v >> 25);
  90. 90 return v;
  91. 91 }
  92. 92 
  93. 93 inline std::uint32_t encrypt_PlayerWalkMovement_velocity_off_0x128(float value)
  94. 94 {
  95. 95 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  96. 96 v ^= 0x5D22278Eu;
  97. 97 v = (v << 14) | (v >> 18);
  98. 98 v -= 0x10EB2F11u;
  99. 99 v = (v << 23) | (v >> 9);
  100. 100 return v;
  101. 101 }
  102. 102 
  103. 103 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x130(float value)
  104. 104 {
  105. 105 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  106. 106 v -= 0x081A6F73u;
  107. 107 v = (v << 9) | (v >> 23);
  108. 108 v += 0x5904CE26u;
  109. 109 return v;
  110. 110 }
  111. 111 
  112. 112 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x140(float value)
  113. 113 {
  114. 114 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  115. 115 v = (v << 23) | (v >> 9);
  116. 116 v -= 0x3A39AD4Bu;
  117. 117 v ^= 0x9FB2FEABu;
  118. 118 v = (v << 8) | (v >> 24);
  119. 119 return v;
  120. 120 }
  121. 121 
  122. 122 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x150(float value)
  123. 123 {
  124. 124 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  125. 125 v -= 0x799233B9u;
  126. 126 v = (v << 19) | (v >> 13);
  127. 127 v ^= 0x3149B54Eu;
  128. 128 v = (v << 13) | (v >> 19);
  129. 129 return v;
  130. 130 }
  131. 131 
  132. 132 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x160(float value)
  133. 133 {
  134. 134 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  135. 135 v = (v << 24) | (v >> 8);
  136. 136 v += 0x7BFB3B67u;
  137. 137 v ^= 0xF96FC5FFu;
  138. 138 return v;
  139. 139 }
  140. 140 
  141. 141 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x170(float value)
  142. 142 {
  143. 143 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  144. 144 v ^= 0x4C3CC5A2u;
  145. 145 v = (v << 7) | (v >> 25);
  146. 146 v ^= 0x776AC171u;
  147. 147 return v;
  148. 148 }
  149. 149 
  150. 150 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x180(float value)
  151. 151 {
  152. 152 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  153. 153 v = (v << 9) | (v >> 23);
  154. 154 v += 0x4100991Du;
  155. 155 v = (v << 30) | (v >> 2);
  156. 156 v ^= 0x36B7B7C8u;
  157. 157 return v;
  158. 158 }
  159. 159 
  160. 160 inline std::uint32_t encrypt_PlayerWalkMovement_off_0x190(float value)
  161. 161 {
  162. 162 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  163. 163 v = (v << 26) | (v >> 6);
  164. 164 v ^= 0x970EA115u;
  165. 165 v += 0x5CC489D8u;
  166. 166 return v;
  167. 167 }
  168. 168 
  169. 169 inline std::uint32_t encrypt_PlayerWalkMovement_lastSprintTime_off_0x1A0(float value)
  170. 170 {
  171. 171 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  172. 172 v ^= 0x86B1EA65u;
  173. 173 v += 0x15E2ED57u;
  174. 174 v = (v << 6) | (v >> 26);
  175. 175 v += 0x0D6BF47Du;
  176. 176 return v;
  177. 177 }
  178. 178 
  179. 179 inline std::uint32_t encrypt_PlayerWalkMovement_sprintForced_off_0x1A8(float value)
  180. 180 {
  181. 181 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  182. 182 v -= 0x49823E40u;
  183. 183 v ^= 0x66ECADA2u;
  184. 184 v -= 0x379EE2C7u;
  185. 185 return v;
  186. 186 }
  187. 187 
  188. 188 inline std::uintptr_t encrypt_PlayerWalkMovement_modify_off_0x1B8(std::uintptr_t ptr)
  189. 189 {
  190. 190 std::uintptr_t rax = ptr;
  191. 191 std::uint32_t* lane = reinterpret_cast<std::uint32_t*>(&rax);
  192. 192 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  193. 193 std::uint32_t v = *lane;
  194. 194 v ^= 0x3A757ECFu;
  195. 195 v = (v << 22) | (v >> 10);
  196. 196 v += 0x0B33D012u;
  197. 197 *lane = v;
  198. 198 ++lane;
  199. 199 }
  200. 200 return rax;
  201. 201 }
  202. 202 
  203. 203 inline std::uint32_t encrypt_PlayerWalkMovement_wasGrounded_off_0x1C4(bool value)
  204. 204 {
  205. 205 std::uint32_t v = value ? 1u : 0u;
  206. 206 v ^= 0x4E950628u;
  207. 207 v += 0x5025DDFAu;
  208. 208 v ^= 0xE0887AA0u;
  209. 209 v -= 0x69094678u;
  210. 210 return v;
  211. 211 }
  212. 212 
  213. 213 inline std::uint32_t encrypt_PlayerWalkMovement_climbing_off_0x1CC(bool value)
  214. 214 {
  215. 215 std::uint32_t v = value ? 1u : 0u;
  216. 216 v = (v << 27) | (v >> 5);
  217. 217 v ^= 0x9F320C62u;
  218. 218 v -= 0x5FE4A4CCu;
  219. 219 return v;
  220. 220 }
  221. 221 
  222. 222 inline std::uint32_t encrypt_PlayerWalkMovement_wasClimbing_off_0x1D4(bool value)
  223. 223 {
  224. 224 std::uint32_t v = value ? 1u : 0u;
  225. 225 v ^= 0x2F349C2Au;
  226. 226 v += 0x0D7F8388u;
  227. 227 v = (v << 9) | (v >> 23);
  228. 228 v -= 0x6A8FBC86u;
  229. 229 return v;
  230. 230 }
  231. 231 
  232. 232 inline std::uint32_t encrypt_PlayerWalkMovement_sliding_off_0x1DC(bool value)
  233. 233 {
  234. 234 std::uint32_t v = value ? 1u : 0u;
  235. 235 v ^= 0xD0BC2C1Eu;
  236. 236 v -= 0x29EA2CE6u;
  237. 237 v = (v << 2) | (v >> 30);
  238. 238 return v;
  239. 239 }
  240. 240 
  241. 241 inline std::uint32_t encrypt_PlayerWalkMovement_wasSliding_off_0x1E4(bool value)
  242. 242 {
  243. 243 std::uint32_t v = value ? 1u : 0u;
  244. 244 v = (v << 27) | (v >> 5);
  245. 245 v -= 0x262402E2u;
  246. 246 v = (v << 20) | (v >> 12);
  247. 247 return v;
  248. 248 }
  249. 249 
  250. 250 inline std::uint32_t encrypt_PlayerWalkMovement_wasSwimming_off_0x1F4(bool value)
  251. 251 {
  252. 252 std::uint32_t v = value ? 1u : 0u;
  253. 253 v = (v << 11) | (v >> 21);
  254. 254 v ^= 0x9CD3AFD8u;
  255. 255 v = (v << 19) | (v >> 13);
  256. 256 return v;
  257. 257 }
  258. 258 
  259. 259 inline std::uint32_t encrypt_PlayerWalkMovement_jumping_off_0x1FC(bool value)
  260. 260 {
  261. 261 std::uint32_t v = value ? 1u : 0u;
  262. 262 v = (v << 7) | (v >> 25);
  263. 263 v += 0x3DAD2B0Au;
  264. 264 v = (v << 17) | (v >> 15);
  265. 265 return v;
  266. 266 }
  267. 267 
  268. 268 inline std::uint32_t encrypt_PlayerWalkMovement_flying_off_0x204(bool value)
  269. 269 {
  270. 270 std::uint32_t v = value ? 1u : 0u;
  271. 271 v += 0x5544E2B8u;
  272. 272 v = (v << 12) | (v >> 20);
  273. 273 v += 0x4557C79Au;
  274. 274 return v;
  275. 275 }
  276. 276 
  277. 277 inline std::uint32_t encrypt_PlayerWalkMovement_falling_off_0x20C(bool value)
  278. 278 {
  279. 279 std::uint32_t v = value ? 1u : 0u;
  280. 280 v ^= 0x83D7F656u;
  281. 281 v = (v << 2) | (v >> 30);
  282. 282 v ^= 0x9A985892u;
  283. 283 return v;
  284. 284 }
  285. 285 
  286. 286 inline std::uint32_t encrypt_PlayerWalkMovement_forcedDuckDelta_off_0x214(bool value)
  287. 287 {
  288. 288 std::uint32_t v = value ? 1u : 0u;
  289. 289 v -= 0x6256D92Cu;
  290. 290 v ^= 0x9DFE7614u;
  291. 291 v = (v << 16) | (v >> 16);
  292. 292 return v;
  293. 293 }
  294. 294 
  295. 295 inline std::uint32_t encrypt_PlayerInput_off_0x80(float value)
  296. 296 {
  297. 297 std::uint32_t v = std::bit_cast<std::uint32_t>(value);
  298. 298 v ^= 0x469CA23Du;
  299. 299 v -= 0x5DF22303u;
  300. 300 v = (v << 3) | (v >> 29);
  301. 301 v += 0x2DD1863Au;
  302. 302 return v;
  303. 303 }
  304. 304 
  305. 305 inline std::uintptr_t player_inventory__fb65c5e1ca75f4c0af3e48d3edc840a5314df547(std::uintptr_t hv_value)
  306. 306 {
  307. 307 std::uintptr_t rax = hv_value;
  308. 308 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  309. 309 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  310. 310 std::uint32_t v = *rdx;
  311. 311 v = (v << 14) | (v >> 18);
  312. 312 v ^= 0xFBEB4E79u;
  313. 313 v = (v << 17) | (v >> 15);
  314. 314 v -= 0x167A6378u;
  315. 315 *rdx = v;
  316. 316 ++rdx;
  317. 317 }
  318. 318 return rax;
  319. 319 }
  320. 320 
  321. 321 inline std::uintptr_t player_inventory__2d2726cb267ea1b790847f3dfcbb25b49a7e2732(std::uintptr_t hv_value)
  322. 322 {
  323. 323 std::uintptr_t rax = hv_value;
  324. 324 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  325. 325 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  326. 326 std::uint32_t v = *rdx;
  327. 327 v = (v << 12) | (v >> 20);
  328. 328 v += 0xD06D4709u;
  329. 329 v = (v << 21) | (v >> 11);
  330. 330 *rdx = v;
  331. 331 ++rdx;
  332. 332 }
  333. 333 return rax;
  334. 334 }
  335. 335 
  336. 336 inline std::uintptr_t player_eyes__0617f8e0e10b3469945f5ed5746fe9efa6687fbe(std::uintptr_t hv_value)
  337. 337 {
  338. 338 std::uintptr_t rax = hv_value;
  339. 339 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  340. 340 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  341. 341 std::uint32_t v = *rdx;
  342. 342 v ^= 0xBA83296Eu;
  343. 343 v = (v << 19) | (v >> 13);
  344. 344 v += 0xCAD99CFBu;
  345. 345 v = (v << 22) | (v >> 10);
  346. 346 *rdx = v;
  347. 347 ++rdx;
  348. 348 }
  349. 349 return rax;
  350. 350 }
  351. 351 
  352. 352 inline std::uintptr_t player_eyes__ceb97a5693abd4b37b2b26b24c531e9d861e30d9(std::uintptr_t hv_value)
  353. 353 {
  354. 354 std::uintptr_t rax = hv_value;
  355. 355 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  356. 356 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  357. 357 std::uint32_t v = *rdx;
  358. 358 v += 0x45CC7567u;
  359. 359 v = (v << 8) | (v >> 24);
  360. 360 v += 0x3443CA46u;
  361. 361 *rdx = v;
  362. 362 ++rdx;
  363. 363 }
  364. 364 return rax;
  365. 365 }
  366. 366 
  367. 367 inline std::uintptr_t cl_active_item__f075f5c85087e5cb0407f8ff6b52745969388a44(std::uintptr_t hv_value)
  368. 368 {
  369. 369 std::uintptr_t rax = hv_value;
  370. 370 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  371. 371 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  372. 372 std::uint32_t v = *rdx;
  373. 373 v ^= 0xC7F486D7u;
  374. 374 v += 0x021AB371u;
  375. 375 v = (v << 11) | (v >> 21);
  376. 376 v += 0x70077F50u;
  377. 377 *rdx = v;
  378. 378 ++rdx;
  379. 379 }
  380. 380 return rax;
  381. 381 }
  382. 382 
  383. 383 inline std::uintptr_t cl_active_item__8572d52613e2b1042f439a76301bec77bede63f6(std::uintptr_t hv_value)
  384. 384 {
  385. 385 std::uintptr_t rax = hv_value;
  386. 386 std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
  387. 387 for (std::uint32_t _i = 0; _i < 2; ++_i) {
  388. 388 std::uint32_t v = *rdx;
  389. 389 v = (v << 27) | (v >> 5);
  390. 390 v ^= 0xBF1B783Du;
  391. 391 v = (v << 30) | (v >> 2);
  392. 392 *rdx = v;
  393. 393 ++rdx;
  394. 394 }
  395. 395 return rax;
  396. 396 }
  397. 397 
  398. 398 #ifndef PWM_WRITE_U32
  399. 399 #define PWM_WRITE_U32(addr, v) driver->Write<uint32_t>((addr), (v))
  400. 400 #endif
  401. 401 #define PWM_WRITE(NAME, BODY) \
  402. 402 inline void write_PWM_##NAME(uint64_t addr, float value) { \
  403. 403 uint32_t v = std::bit_cast<uint32_t>(value); \
  404. 404 BODY \
  405. 405 PWM_WRITE_U32(addr, v); \
  406. 406 }
  407. 407 #define PWM_WRITE_BOOL(NAME, BODY) \
  408. 408 inline void write_PWM_##NAME(uint64_t addr, float value) { \
  409. 409 uint32_t v = (value != 0.f) ? 1u : 0u; \
  410. 410 BODY \
  411. 411 PWM_WRITE_U32(addr, v); \
  412. 412 }
  413. 413 PWM_WRITE(GroundAngleNew, v = (v << 0xAu) | (v >> 0x16u); v -= 0x75B6E603u; v ^= 0x883CD959u; v += 0x5EF50FCAu; )
  414. 414 PWM_WRITE(GroundTime, v += 0x340B5115u; v = (v << 0x19u) | (v >> 0x7u); v ^= 0x8D984D53u; )
  415. 415 PWM_WRITE(JumpTime, v += 0x5ED8266Au; v = (v << 0x18u) | (v >> 0x8u); v ^= 0x975CE3D8u; v = (v << 0x16u) | (v >> 0xAu); )
  416. 416 PWM_WRITE(LandTime, v = (v << 0x7u) | (v >> 0x19u); v -= 0x75CBAD0u; v = (v << 0x7u) | (v >> 0x19u); )
  417. 417 PWM_WRITE(Velocity, v ^= 0x5D22278Eu; v = (v << 0xEu) | (v >> 0x12u); v -= 0x10EB2F11u; v = (v << 0x17u) | (v >> 0x9u); )
  418. 418 PWM_WRITE(Off_0x130, v -= 0x81A6F73u; v = (v << 0x9u) | (v >> 0x17u); v += 0x5904CE26u; )
  419. 419 PWM_WRITE(Off_0x140, v = (v << 0x17u) | (v >> 0x9u); v -= 0x3A39AD4Bu; v ^= 0x9FB2FEABu; v = (v << 0x8u) | (v >> 0x18u); )
  420. 420 PWM_WRITE(Off_0x150, v -= 0x799233B9u; v = (v << 0x13u) | (v >> 0xDu); v ^= 0x3149B54Eu; v = (v << 0xDu) | (v >> 0x13u); )
  421. 421 PWM_WRITE(Off_0x160, v = (v << 0x18u) | (v >> 0x8u); v += 0x7BFB3B67u; v ^= 0xF96FC5FFu; )
  422. 422 PWM_WRITE(Off_0x170, v ^= 0x4C3CC5A2u; v = (v << 0x7u) | (v >> 0x19u); v ^= 0x776AC171u; )
  423. 423 PWM_WRITE(Off_0x180, v = (v << 0x9u) | (v >> 0x17u); v += 0x4100991Du; v = (v << 0x1Eu) | (v >> 0x2u); v ^= 0x36B7B7C8u; )
  424. 424 PWM_WRITE(Off_0x190, v = (v << 0x1Au) | (v >> 0x6u); v ^= 0x970EA115u; v += 0x5CC489D8u; )
  425. 425 PWM_WRITE(LastSprintTime, v ^= 0x86B1EA65u; v += 0x15E2ED57u; v = (v << 0x6u) | (v >> 0x1Au); v += 0xD6BF47Du; )
  426. 426 PWM_WRITE(SprintForced, v -= 0x49823E40u; v ^= 0x66ECADA2u; v -= 0x379EE2C7u; )
  427. 427 PWM_WRITE_BOOL(WasGrounded, v ^= 0x4E950628u; v += 0x5025DDFAu; v ^= 0xE0887AA0u; v -= 0x69094678u; )
  428. 428 PWM_WRITE_BOOL(Climbing, v = (v << 0x1Bu) | (v >> 0x5u); v ^= 0x9F320C62u; v -= 0x5FE4A4CCu; )
  429. 429 PWM_WRITE_BOOL(WasClimbing, v ^= 0x2F349C2Au; v += 0xD7F8388u; v = (v << 0x9u) | (v >> 0x17u); v -= 0x6A8FBC86u; )
  430. 430 PWM_WRITE_BOOL(Sliding, v ^= 0xD0BC2C1Eu; v -= 0x29EA2CE6u; v = (v << 0x2u) | (v >> 0x1Eu); )
  431. 431 PWM_WRITE_BOOL(WasSliding, v = (v << 0x1Bu) | (v >> 0x5u); v -= 0x262402E2u; v = (v << 0x14u) | (v >> 0xCu); )
  432. 432 PWM_WRITE_BOOL(WasSwimming, v = (v << 0xBu) | (v >> 0x15u); v ^= 0x9CD3AFD8u; v = (v << 0x13u) | (v >> 0xDu); )
  433. 433 PWM_WRITE_BOOL(Jumping, v = (v << 0x7u) | (v >> 0x19u); v += 0x3DAD2B0Au; v = (v << 0x11u) | (v >> 0xFu); )
  434. 434 PWM_WRITE_BOOL(Flying, v += 0x5544E2B8u; v = (v << 0xCu) | (v >> 0x14u); v += 0x4557C79Au; )
  435. 435 PWM_WRITE_BOOL(Falling, v ^= 0x83D7F656u; v = (v << 0x2u) | (v >> 0x1Eu); v ^= 0x9A985892u; )
  436. 436 PWM_WRITE_BOOL(ForcedDuckDelta, v -= 0x6256D92Cu; v ^= 0x9DFE7614u; v = (v << 0x10u) | (v >> 0x10u); )
  437. 437 PWM_WRITE_BOOL(Off_0x20, v = (v << 0x9u) | (v >> 0x17u); v += 0x10EB2F11u; v = (v << 0x12u) | (v >> 0xEu); v ^= 0x5D22278Eu; )
  438. 438 #undef PWM_WRITE
  439. 439 #undef PWM_WRITE_BOOL
  440. 440 
  441. 441 inline void write_PWM_CapsuleCenter(uint64_t, float) {}
  442. 442 inline void write_PWM_CapsuleHeightDucked(uint64_t, float) {}
  443. 443 inline void write_PWM_CapsuleCenterDucked(uint64_t, float) {}
  444. 444 inline void write_PWM_CapsuleRadius(uint64_t, float) {}
  445. 445 inline void write_PWM_GravityTestRadius(uint64_t, float) {}
  446. 446 inline void write_PWM_MaxStepHeight(uint64_t, float) {}
  447. 447 inline void write_PWM_GravityMultiplier(uint64_t, float) {}
  448. 448 inline void write_PWM_GravityMultiplierSwimming(uint64_t, float) {}
  449. 449 inline void write_PWM_Off_0xB8(uint64_t, float) {}
  450. 450 inline void write_PWM_Off_0xC0(uint64_t, float) {}
  451. 451 inline void write_PWM_Off_0xC8(uint64_t, float) {}
  452. 452 inline void write_PWM_Off_0xD0(uint64_t, float) {}
  453. 453 inline void write_PWM_Ladder(uint64_t, float) {}
  454. 454 inline void write_PWM_GroundAngle(uint64_t, float) {}
  455. 455 inline void write_PWM_AttemptedMountTime(uint64_t, float) {}
  456. 456 inline void write_PWM_Swimming(uint64_t, float) {}
  457. 457 inline void write_PWM_Off_0x21C(uint64_t, float) {}
  458. 458 inline void write_PWM_Off_0x28(uint64_t, float) {}
  459. 459 
  460. 460 }
  461. 461 
  462. 462}