API tools faq
paste
Guest User

Untitled

a guest
Jul 29th, 2014
341
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 107.77 KB | None | 0 0
raw download clone embed print report
  1. --- /dev/null 2014-07-27 17:46:41.073281280 -0400
  2. +++ feeds/oldpackages/net/umurmur/patches/001-configure
  3. @@ -0,0 +1,18 @@
  4. +--- a/configure
  5. ++++ b/configure
  6. +@@ -4434,15 +4434,9 @@
  7. + /* Override any GCC internal prototype to avoid an error.
  8. + Use char because int might match the return type of a GCC
  9. + builtin and then its argument prototype would still apply. */
  10. +-#ifdef __cplusplus
  11. +-extern "C"
  12. +-#endif
  13. +-char protobuf_c_data_buffer_init ();
  14. + int
  15. + main ()
  16. + {
  17. +-return protobuf_c_data_buffer_init ();
  18. +- ;
  19. + return 0;
  20. + }
  21. + _ACEOF
  22. --- /dev/null 2014-07-27 17:46:41.073281280 -0400
  23. +++ feeds/oldpackages/net/umurmur/patches/002-typedef
  24. @@ -0,0 +1,20 @@
  25. +--- a/src/Mumble.pb-c.h
  26. ++++ b/src/Mumble.pb-c.h
  27. +@@ -5,9 +5,6 @@
  28. +
  29. + #include <google/protobuf-c/protobuf-c.h>
  30. +
  31. +-PROTOBUF_C_BEGIN_DECLS
  32. +-
  33. +-
  34. + typedef struct _MumbleProto__Version MumbleProto__Version;
  35. + typedef struct _MumbleProto__UDPTunnel MumbleProto__UDPTunnel;
  36. + typedef struct _MumbleProto__Authenticate MumbleProto__Authenticate;
  37. +@@ -1304,7 +1301,4 @@
  38. + extern const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor;
  39. + extern const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor;
  40. +
  41. +-PROTOBUF_C_END_DECLS
  42. +-
  43. +-
  44. + #endif /* PROTOBUF_Mumble_2eproto__INCLUDED */
  45. --- /dev/null 2014-07-27 17:46:41.073281280 -0400
  46. +++ feeds/oldpackages/net/umurmur/patches/003-offsetof
  47. @@ -0,0 +1,1711 @@
  48. +--- a/src/Mumble.pb-c.c
  49. ++++ b/src/Mumble.pb-c.c
  50. +@@ -1167,8 +1167,8 @@
  51. + 1,
  52. + PROTOBUF_C_LABEL_OPTIONAL,
  53. + PROTOBUF_C_TYPE_UINT32,
  54. +- PROTOBUF_C_OFFSETOF(MumbleProto__Version, has_version),
  55. +- PROTOBUF_C_OFFSETOF(MumbleProto__Version, version),
  56. ++ offsetof(MumbleProto__Version, has_version),
  57. ++ offsetof(MumbleProto__Version, version),
  58. + NULL,
  59. + NULL,
  60. + 0, /* packed */
  61. +@@ -1180,7 +1180,7 @@
  62. + PROTOBUF_C_LABEL_OPTIONAL,
  63. + PROTOBUF_C_TYPE_STRING,
  64. + 0, /* quantifier_offset */
  65. +- PROTOBUF_C_OFFSETOF(MumbleProto__Version, release),
  66. ++ offsetof(MumbleProto__Version, release),
  67. + NULL,
  68. + NULL,
  69. + 0, /* packed */
  70. +@@ -1192,7 +1192,7 @@
  71. + PROTOBUF_C_LABEL_OPTIONAL,
  72. + PROTOBUF_C_TYPE_STRING,
  73. + 0, /* quantifier_offset */
  74. +- PROTOBUF_C_OFFSETOF(MumbleProto__Version, os),
  75. ++ offsetof(MumbleProto__Version, os),
  76. + NULL,
  77. + NULL,
  78. + 0, /* packed */
  79. +@@ -1204,7 +1204,7 @@
  80. + PROTOBUF_C_LABEL_OPTIONAL,
  81. + PROTOBUF_C_TYPE_STRING,
  82. + 0, /* quantifier_offset */
  83. +- PROTOBUF_C_OFFSETOF(MumbleProto__Version, os_version),
  84. ++ offsetof(MumbleProto__Version, os_version),
  85. + NULL,
  86. + NULL,
  87. + 0, /* packed */
  88. +@@ -1245,7 +1245,7 @@
  89. + PROTOBUF_C_LABEL_REQUIRED,
  90. + PROTOBUF_C_TYPE_BYTES,
  91. + 0, /* quantifier_offset */
  92. +- PROTOBUF_C_OFFSETOF(MumbleProto__UDPTunnel, packet),
  93. ++ offsetof(MumbleProto__UDPTunnel, packet),
  94. + NULL,
  95. + NULL,
  96. + 0, /* packed */
  97. +@@ -1284,7 +1284,7 @@
  98. + PROTOBUF_C_LABEL_OPTIONAL,
  99. + PROTOBUF_C_TYPE_STRING,
  100. + 0, /* quantifier_offset */
  101. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, username),
  102. ++ offsetof(MumbleProto__Authenticate, username),
  103. + NULL,
  104. + NULL,
  105. + 0, /* packed */
  106. +@@ -1296,7 +1296,7 @@
  107. + PROTOBUF_C_LABEL_OPTIONAL,
  108. + PROTOBUF_C_TYPE_STRING,
  109. + 0, /* quantifier_offset */
  110. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, password),
  111. ++ offsetof(MumbleProto__Authenticate, password),
  112. + NULL,
  113. + NULL,
  114. + 0, /* packed */
  115. +@@ -1307,8 +1307,8 @@
  116. + 3,
  117. + PROTOBUF_C_LABEL_REPEATED,
  118. + PROTOBUF_C_TYPE_STRING,
  119. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_tokens),
  120. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, tokens),
  121. ++ offsetof(MumbleProto__Authenticate, n_tokens),
  122. ++ offsetof(MumbleProto__Authenticate, tokens),
  123. + NULL,
  124. + NULL,
  125. + 0, /* packed */
  126. +@@ -1319,8 +1319,8 @@
  127. + 4,
  128. + PROTOBUF_C_LABEL_REPEATED,
  129. + PROTOBUF_C_TYPE_INT32,
  130. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_celt_versions),
  131. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, celt_versions),
  132. ++ offsetof(MumbleProto__Authenticate, n_celt_versions),
  133. ++ offsetof(MumbleProto__Authenticate, celt_versions),
  134. + NULL,
  135. + NULL,
  136. + 0, /* packed */
  137. +@@ -1331,8 +1331,8 @@
  138. + 5,
  139. + PROTOBUF_C_LABEL_OPTIONAL,
  140. + PROTOBUF_C_TYPE_BOOL,
  141. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, has_opus),
  142. +- PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, opus),
  143. ++ offsetof(MumbleProto__Authenticate, has_opus),
  144. ++ offsetof(MumbleProto__Authenticate, opus),
  145. + NULL,
  146. + &mumble_proto__authenticate__opus__default_value,
  147. + 0, /* packed */
  148. +@@ -1373,8 +1373,8 @@
  149. + 1,
  150. + PROTOBUF_C_LABEL_OPTIONAL,
  151. + PROTOBUF_C_TYPE_UINT64,
  152. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_timestamp),
  153. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, timestamp),
  154. ++ offsetof(MumbleProto__Ping, has_timestamp),
  155. ++ offsetof(MumbleProto__Ping, timestamp),
  156. + NULL,
  157. + NULL,
  158. + 0, /* packed */
  159. +@@ -1385,8 +1385,8 @@
  160. + 2,
  161. + PROTOBUF_C_LABEL_OPTIONAL,
  162. + PROTOBUF_C_TYPE_UINT32,
  163. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_good),
  164. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, good),
  165. ++ offsetof(MumbleProto__Ping, has_good),
  166. ++ offsetof(MumbleProto__Ping, good),
  167. + NULL,
  168. + NULL,
  169. + 0, /* packed */
  170. +@@ -1397,8 +1397,8 @@
  171. + 3,
  172. + PROTOBUF_C_LABEL_OPTIONAL,
  173. + PROTOBUF_C_TYPE_UINT32,
  174. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_late),
  175. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, late),
  176. ++ offsetof(MumbleProto__Ping, has_late),
  177. ++ offsetof(MumbleProto__Ping, late),
  178. + NULL,
  179. + NULL,
  180. + 0, /* packed */
  181. +@@ -1409,8 +1409,8 @@
  182. + 4,
  183. + PROTOBUF_C_LABEL_OPTIONAL,
  184. + PROTOBUF_C_TYPE_UINT32,
  185. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_lost),
  186. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, lost),
  187. ++ offsetof(MumbleProto__Ping, has_lost),
  188. ++ offsetof(MumbleProto__Ping, lost),
  189. + NULL,
  190. + NULL,
  191. + 0, /* packed */
  192. +@@ -1421,8 +1421,8 @@
  193. + 5,
  194. + PROTOBUF_C_LABEL_OPTIONAL,
  195. + PROTOBUF_C_TYPE_UINT32,
  196. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_resync),
  197. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, resync),
  198. ++ offsetof(MumbleProto__Ping, has_resync),
  199. ++ offsetof(MumbleProto__Ping, resync),
  200. + NULL,
  201. + NULL,
  202. + 0, /* packed */
  203. +@@ -1433,8 +1433,8 @@
  204. + 6,
  205. + PROTOBUF_C_LABEL_OPTIONAL,
  206. + PROTOBUF_C_TYPE_UINT32,
  207. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_packets),
  208. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_packets),
  209. ++ offsetof(MumbleProto__Ping, has_udp_packets),
  210. ++ offsetof(MumbleProto__Ping, udp_packets),
  211. + NULL,
  212. + NULL,
  213. + 0, /* packed */
  214. +@@ -1445,8 +1445,8 @@
  215. + 7,
  216. + PROTOBUF_C_LABEL_OPTIONAL,
  217. + PROTOBUF_C_TYPE_UINT32,
  218. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_packets),
  219. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_packets),
  220. ++ offsetof(MumbleProto__Ping, has_tcp_packets),
  221. ++ offsetof(MumbleProto__Ping, tcp_packets),
  222. + NULL,
  223. + NULL,
  224. + 0, /* packed */
  225. +@@ -1457,8 +1457,8 @@
  226. + 8,
  227. + PROTOBUF_C_LABEL_OPTIONAL,
  228. + PROTOBUF_C_TYPE_FLOAT,
  229. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_avg),
  230. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_avg),
  231. ++ offsetof(MumbleProto__Ping, has_udp_ping_avg),
  232. ++ offsetof(MumbleProto__Ping, udp_ping_avg),
  233. + NULL,
  234. + NULL,
  235. + 0, /* packed */
  236. +@@ -1469,8 +1469,8 @@
  237. + 9,
  238. + PROTOBUF_C_LABEL_OPTIONAL,
  239. + PROTOBUF_C_TYPE_FLOAT,
  240. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_var),
  241. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_var),
  242. ++ offsetof(MumbleProto__Ping, has_udp_ping_var),
  243. ++ offsetof(MumbleProto__Ping, udp_ping_var),
  244. + NULL,
  245. + NULL,
  246. + 0, /* packed */
  247. +@@ -1481,8 +1481,8 @@
  248. + 10,
  249. + PROTOBUF_C_LABEL_OPTIONAL,
  250. + PROTOBUF_C_TYPE_FLOAT,
  251. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_avg),
  252. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_avg),
  253. ++ offsetof(MumbleProto__Ping, has_tcp_ping_avg),
  254. ++ offsetof(MumbleProto__Ping, tcp_ping_avg),
  255. + NULL,
  256. + NULL,
  257. + 0, /* packed */
  258. +@@ -1493,8 +1493,8 @@
  259. + 11,
  260. + PROTOBUF_C_LABEL_OPTIONAL,
  261. + PROTOBUF_C_TYPE_FLOAT,
  262. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_var),
  263. +- PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_var),
  264. ++ offsetof(MumbleProto__Ping, has_tcp_ping_var),
  265. ++ offsetof(MumbleProto__Ping, tcp_ping_var),
  266. + NULL,
  267. + NULL,
  268. + 0, /* packed */
  269. +@@ -1581,8 +1581,8 @@
  270. + 1,
  271. + PROTOBUF_C_LABEL_OPTIONAL,
  272. + PROTOBUF_C_TYPE_ENUM,
  273. +- PROTOBUF_C_OFFSETOF(MumbleProto__Reject, has_type),
  274. +- PROTOBUF_C_OFFSETOF(MumbleProto__Reject, type),
  275. ++ offsetof(MumbleProto__Reject, has_type),
  276. ++ offsetof(MumbleProto__Reject, type),
  277. + &mumble_proto__reject__reject_type__descriptor,
  278. + NULL,
  279. + 0, /* packed */
  280. +@@ -1594,7 +1594,7 @@
  281. + PROTOBUF_C_LABEL_OPTIONAL,
  282. + PROTOBUF_C_TYPE_STRING,
  283. + 0, /* quantifier_offset */
  284. +- PROTOBUF_C_OFFSETOF(MumbleProto__Reject, reason),
  285. ++ offsetof(MumbleProto__Reject, reason),
  286. + NULL,
  287. + NULL,
  288. + 0, /* packed */
  289. +@@ -1632,8 +1632,8 @@
  290. + 1,
  291. + PROTOBUF_C_LABEL_OPTIONAL,
  292. + PROTOBUF_C_TYPE_UINT32,
  293. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_max_bandwidth),
  294. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, max_bandwidth),
  295. ++ offsetof(MumbleProto__ServerConfig, has_max_bandwidth),
  296. ++ offsetof(MumbleProto__ServerConfig, max_bandwidth),
  297. + NULL,
  298. + NULL,
  299. + 0, /* packed */
  300. +@@ -1645,7 +1645,7 @@
  301. + PROTOBUF_C_LABEL_OPTIONAL,
  302. + PROTOBUF_C_TYPE_STRING,
  303. + 0, /* quantifier_offset */
  304. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, welcome_text),
  305. ++ offsetof(MumbleProto__ServerConfig, welcome_text),
  306. + NULL,
  307. + NULL,
  308. + 0, /* packed */
  309. +@@ -1656,8 +1656,8 @@
  310. + 3,
  311. + PROTOBUF_C_LABEL_OPTIONAL,
  312. + PROTOBUF_C_TYPE_BOOL,
  313. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_allow_html),
  314. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, allow_html),
  315. ++ offsetof(MumbleProto__ServerConfig, has_allow_html),
  316. ++ offsetof(MumbleProto__ServerConfig, allow_html),
  317. + NULL,
  318. + NULL,
  319. + 0, /* packed */
  320. +@@ -1668,8 +1668,8 @@
  321. + 4,
  322. + PROTOBUF_C_LABEL_OPTIONAL,
  323. + PROTOBUF_C_TYPE_UINT32,
  324. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_message_length),
  325. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, message_length),
  326. ++ offsetof(MumbleProto__ServerConfig, has_message_length),
  327. ++ offsetof(MumbleProto__ServerConfig, message_length),
  328. + NULL,
  329. + NULL,
  330. + 0, /* packed */
  331. +@@ -1680,8 +1680,8 @@
  332. + 5,
  333. + PROTOBUF_C_LABEL_OPTIONAL,
  334. + PROTOBUF_C_TYPE_UINT32,
  335. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_image_message_length),
  336. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, image_message_length),
  337. ++ offsetof(MumbleProto__ServerConfig, has_image_message_length),
  338. ++ offsetof(MumbleProto__ServerConfig, image_message_length),
  339. + NULL,
  340. + NULL,
  341. + 0, /* packed */
  342. +@@ -1722,8 +1722,8 @@
  343. + 1,
  344. + PROTOBUF_C_LABEL_OPTIONAL,
  345. + PROTOBUF_C_TYPE_UINT32,
  346. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_session),
  347. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, session),
  348. ++ offsetof(MumbleProto__ServerSync, has_session),
  349. ++ offsetof(MumbleProto__ServerSync, session),
  350. + NULL,
  351. + NULL,
  352. + 0, /* packed */
  353. +@@ -1734,8 +1734,8 @@
  354. + 2,
  355. + PROTOBUF_C_LABEL_OPTIONAL,
  356. + PROTOBUF_C_TYPE_UINT32,
  357. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_max_bandwidth),
  358. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, max_bandwidth),
  359. ++ offsetof(MumbleProto__ServerSync, has_max_bandwidth),
  360. ++ offsetof(MumbleProto__ServerSync, max_bandwidth),
  361. + NULL,
  362. + NULL,
  363. + 0, /* packed */
  364. +@@ -1747,7 +1747,7 @@
  365. + PROTOBUF_C_LABEL_OPTIONAL,
  366. + PROTOBUF_C_TYPE_STRING,
  367. + 0, /* quantifier_offset */
  368. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, welcome_text),
  369. ++ offsetof(MumbleProto__ServerSync, welcome_text),
  370. + NULL,
  371. + NULL,
  372. + 0, /* packed */
  373. +@@ -1758,8 +1758,8 @@
  374. + 4,
  375. + PROTOBUF_C_LABEL_OPTIONAL,
  376. + PROTOBUF_C_TYPE_UINT64,
  377. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_permissions),
  378. +- PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, permissions),
  379. ++ offsetof(MumbleProto__ServerSync, has_permissions),
  380. ++ offsetof(MumbleProto__ServerSync, permissions),
  381. + NULL,
  382. + NULL,
  383. + 0, /* packed */
  384. +@@ -1800,7 +1800,7 @@
  385. + PROTOBUF_C_LABEL_REQUIRED,
  386. + PROTOBUF_C_TYPE_UINT32,
  387. + 0, /* quantifier_offset */
  388. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelRemove, channel_id),
  389. ++ offsetof(MumbleProto__ChannelRemove, channel_id),
  390. + NULL,
  391. + NULL,
  392. + 0, /* packed */
  393. +@@ -1839,8 +1839,8 @@
  394. + 1,
  395. + PROTOBUF_C_LABEL_OPTIONAL,
  396. + PROTOBUF_C_TYPE_UINT32,
  397. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_channel_id),
  398. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, channel_id),
  399. ++ offsetof(MumbleProto__ChannelState, has_channel_id),
  400. ++ offsetof(MumbleProto__ChannelState, channel_id),
  401. + NULL,
  402. + NULL,
  403. + 0, /* packed */
  404. +@@ -1851,8 +1851,8 @@
  405. + 2,
  406. + PROTOBUF_C_LABEL_OPTIONAL,
  407. + PROTOBUF_C_TYPE_UINT32,
  408. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_parent),
  409. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, parent),
  410. ++ offsetof(MumbleProto__ChannelState, has_parent),
  411. ++ offsetof(MumbleProto__ChannelState, parent),
  412. + NULL,
  413. + NULL,
  414. + 0, /* packed */
  415. +@@ -1864,7 +1864,7 @@
  416. + PROTOBUF_C_LABEL_OPTIONAL,
  417. + PROTOBUF_C_TYPE_STRING,
  418. + 0, /* quantifier_offset */
  419. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, name),
  420. ++ offsetof(MumbleProto__ChannelState, name),
  421. + NULL,
  422. + NULL,
  423. + 0, /* packed */
  424. +@@ -1875,8 +1875,8 @@
  425. + 4,
  426. + PROTOBUF_C_LABEL_REPEATED,
  427. + PROTOBUF_C_TYPE_UINT32,
  428. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links),
  429. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links),
  430. ++ offsetof(MumbleProto__ChannelState, n_links),
  431. ++ offsetof(MumbleProto__ChannelState, links),
  432. + NULL,
  433. + NULL,
  434. + 0, /* packed */
  435. +@@ -1888,7 +1888,7 @@
  436. + PROTOBUF_C_LABEL_OPTIONAL,
  437. + PROTOBUF_C_TYPE_STRING,
  438. + 0, /* quantifier_offset */
  439. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description),
  440. ++ offsetof(MumbleProto__ChannelState, description),
  441. + NULL,
  442. + NULL,
  443. + 0, /* packed */
  444. +@@ -1899,8 +1899,8 @@
  445. + 6,
  446. + PROTOBUF_C_LABEL_REPEATED,
  447. + PROTOBUF_C_TYPE_UINT32,
  448. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_add),
  449. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_add),
  450. ++ offsetof(MumbleProto__ChannelState, n_links_add),
  451. ++ offsetof(MumbleProto__ChannelState, links_add),
  452. + NULL,
  453. + NULL,
  454. + 0, /* packed */
  455. +@@ -1911,8 +1911,8 @@
  456. + 7,
  457. + PROTOBUF_C_LABEL_REPEATED,
  458. + PROTOBUF_C_TYPE_UINT32,
  459. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_remove),
  460. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_remove),
  461. ++ offsetof(MumbleProto__ChannelState, n_links_remove),
  462. ++ offsetof(MumbleProto__ChannelState, links_remove),
  463. + NULL,
  464. + NULL,
  465. + 0, /* packed */
  466. +@@ -1923,8 +1923,8 @@
  467. + 8,
  468. + PROTOBUF_C_LABEL_OPTIONAL,
  469. + PROTOBUF_C_TYPE_BOOL,
  470. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_temporary),
  471. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, temporary),
  472. ++ offsetof(MumbleProto__ChannelState, has_temporary),
  473. ++ offsetof(MumbleProto__ChannelState, temporary),
  474. + NULL,
  475. + &mumble_proto__channel_state__temporary__default_value,
  476. + 0, /* packed */
  477. +@@ -1935,8 +1935,8 @@
  478. + 9,
  479. + PROTOBUF_C_LABEL_OPTIONAL,
  480. + PROTOBUF_C_TYPE_INT32,
  481. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_position),
  482. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, position),
  483. ++ offsetof(MumbleProto__ChannelState, has_position),
  484. ++ offsetof(MumbleProto__ChannelState, position),
  485. + NULL,
  486. + &mumble_proto__channel_state__position__default_value,
  487. + 0, /* packed */
  488. +@@ -1947,8 +1947,8 @@
  489. + 10,
  490. + PROTOBUF_C_LABEL_OPTIONAL,
  491. + PROTOBUF_C_TYPE_BYTES,
  492. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_description_hash),
  493. +- PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description_hash),
  494. ++ offsetof(MumbleProto__ChannelState, has_description_hash),
  495. ++ offsetof(MumbleProto__ChannelState, description_hash),
  496. + NULL,
  497. + NULL,
  498. + 0, /* packed */
  499. +@@ -1995,7 +1995,7 @@
  500. + PROTOBUF_C_LABEL_REQUIRED,
  501. + PROTOBUF_C_TYPE_UINT32,
  502. + 0, /* quantifier_offset */
  503. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, session),
  504. ++ offsetof(MumbleProto__UserRemove, session),
  505. + NULL,
  506. + NULL,
  507. + 0, /* packed */
  508. +@@ -2006,8 +2006,8 @@
  509. + 2,
  510. + PROTOBUF_C_LABEL_OPTIONAL,
  511. + PROTOBUF_C_TYPE_UINT32,
  512. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_actor),
  513. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, actor),
  514. ++ offsetof(MumbleProto__UserRemove, has_actor),
  515. ++ offsetof(MumbleProto__UserRemove, actor),
  516. + NULL,
  517. + NULL,
  518. + 0, /* packed */
  519. +@@ -2019,7 +2019,7 @@
  520. + PROTOBUF_C_LABEL_OPTIONAL,
  521. + PROTOBUF_C_TYPE_STRING,
  522. + 0, /* quantifier_offset */
  523. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, reason),
  524. ++ offsetof(MumbleProto__UserRemove, reason),
  525. + NULL,
  526. + NULL,
  527. + 0, /* packed */
  528. +@@ -2030,8 +2030,8 @@
  529. + 4,
  530. + PROTOBUF_C_LABEL_OPTIONAL,
  531. + PROTOBUF_C_TYPE_BOOL,
  532. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_ban),
  533. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, ban),
  534. ++ offsetof(MumbleProto__UserRemove, has_ban),
  535. ++ offsetof(MumbleProto__UserRemove, ban),
  536. + NULL,
  537. + NULL,
  538. + 0, /* packed */
  539. +@@ -2071,8 +2071,8 @@
  540. + 1,
  541. + PROTOBUF_C_LABEL_OPTIONAL,
  542. + PROTOBUF_C_TYPE_UINT32,
  543. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_session),
  544. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, session),
  545. ++ offsetof(MumbleProto__UserState, has_session),
  546. ++ offsetof(MumbleProto__UserState, session),
  547. + NULL,
  548. + NULL,
  549. + 0, /* packed */
  550. +@@ -2083,8 +2083,8 @@
  551. + 2,
  552. + PROTOBUF_C_LABEL_OPTIONAL,
  553. + PROTOBUF_C_TYPE_UINT32,
  554. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_actor),
  555. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, actor),
  556. ++ offsetof(MumbleProto__UserState, has_actor),
  557. ++ offsetof(MumbleProto__UserState, actor),
  558. + NULL,
  559. + NULL,
  560. + 0, /* packed */
  561. +@@ -2096,7 +2096,7 @@
  562. + PROTOBUF_C_LABEL_OPTIONAL,
  563. + PROTOBUF_C_TYPE_STRING,
  564. + 0, /* quantifier_offset */
  565. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, name),
  566. ++ offsetof(MumbleProto__UserState, name),
  567. + NULL,
  568. + NULL,
  569. + 0, /* packed */
  570. +@@ -2107,8 +2107,8 @@
  571. + 4,
  572. + PROTOBUF_C_LABEL_OPTIONAL,
  573. + PROTOBUF_C_TYPE_UINT32,
  574. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_user_id),
  575. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, user_id),
  576. ++ offsetof(MumbleProto__UserState, has_user_id),
  577. ++ offsetof(MumbleProto__UserState, user_id),
  578. + NULL,
  579. + NULL,
  580. + 0, /* packed */
  581. +@@ -2119,8 +2119,8 @@
  582. + 5,
  583. + PROTOBUF_C_LABEL_OPTIONAL,
  584. + PROTOBUF_C_TYPE_UINT32,
  585. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_channel_id),
  586. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, channel_id),
  587. ++ offsetof(MumbleProto__UserState, has_channel_id),
  588. ++ offsetof(MumbleProto__UserState, channel_id),
  589. + NULL,
  590. + NULL,
  591. + 0, /* packed */
  592. +@@ -2131,8 +2131,8 @@
  593. + 6,
  594. + PROTOBUF_C_LABEL_OPTIONAL,
  595. + PROTOBUF_C_TYPE_BOOL,
  596. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_mute),
  597. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, mute),
  598. ++ offsetof(MumbleProto__UserState, has_mute),
  599. ++ offsetof(MumbleProto__UserState, mute),
  600. + NULL,
  601. + NULL,
  602. + 0, /* packed */
  603. +@@ -2143,8 +2143,8 @@
  604. + 7,
  605. + PROTOBUF_C_LABEL_OPTIONAL,
  606. + PROTOBUF_C_TYPE_BOOL,
  607. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_deaf),
  608. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, deaf),
  609. ++ offsetof(MumbleProto__UserState, has_deaf),
  610. ++ offsetof(MumbleProto__UserState, deaf),
  611. + NULL,
  612. + NULL,
  613. + 0, /* packed */
  614. +@@ -2155,8 +2155,8 @@
  615. + 8,
  616. + PROTOBUF_C_LABEL_OPTIONAL,
  617. + PROTOBUF_C_TYPE_BOOL,
  618. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_suppress),
  619. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, suppress),
  620. ++ offsetof(MumbleProto__UserState, has_suppress),
  621. ++ offsetof(MumbleProto__UserState, suppress),
  622. + NULL,
  623. + NULL,
  624. + 0, /* packed */
  625. +@@ -2167,8 +2167,8 @@
  626. + 9,
  627. + PROTOBUF_C_LABEL_OPTIONAL,
  628. + PROTOBUF_C_TYPE_BOOL,
  629. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_mute),
  630. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_mute),
  631. ++ offsetof(MumbleProto__UserState, has_self_mute),
  632. ++ offsetof(MumbleProto__UserState, self_mute),
  633. + NULL,
  634. + NULL,
  635. + 0, /* packed */
  636. +@@ -2179,8 +2179,8 @@
  637. + 10,
  638. + PROTOBUF_C_LABEL_OPTIONAL,
  639. + PROTOBUF_C_TYPE_BOOL,
  640. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_deaf),
  641. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_deaf),
  642. ++ offsetof(MumbleProto__UserState, has_self_deaf),
  643. ++ offsetof(MumbleProto__UserState, self_deaf),
  644. + NULL,
  645. + NULL,
  646. + 0, /* packed */
  647. +@@ -2191,8 +2191,8 @@
  648. + 11,
  649. + PROTOBUF_C_LABEL_OPTIONAL,
  650. + PROTOBUF_C_TYPE_BYTES,
  651. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture),
  652. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture),
  653. ++ offsetof(MumbleProto__UserState, has_texture),
  654. ++ offsetof(MumbleProto__UserState, texture),
  655. + NULL,
  656. + NULL,
  657. + 0, /* packed */
  658. +@@ -2203,8 +2203,8 @@
  659. + 12,
  660. + PROTOBUF_C_LABEL_OPTIONAL,
  661. + PROTOBUF_C_TYPE_BYTES,
  662. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_plugin_context),
  663. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_context),
  664. ++ offsetof(MumbleProto__UserState, has_plugin_context),
  665. ++ offsetof(MumbleProto__UserState, plugin_context),
  666. + NULL,
  667. + NULL,
  668. + 0, /* packed */
  669. +@@ -2216,7 +2216,7 @@
  670. + PROTOBUF_C_LABEL_OPTIONAL,
  671. + PROTOBUF_C_TYPE_STRING,
  672. + 0, /* quantifier_offset */
  673. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_identity),
  674. ++ offsetof(MumbleProto__UserState, plugin_identity),
  675. + NULL,
  676. + NULL,
  677. + 0, /* packed */
  678. +@@ -2228,7 +2228,7 @@
  679. + PROTOBUF_C_LABEL_OPTIONAL,
  680. + PROTOBUF_C_TYPE_STRING,
  681. + 0, /* quantifier_offset */
  682. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment),
  683. ++ offsetof(MumbleProto__UserState, comment),
  684. + NULL,
  685. + NULL,
  686. + 0, /* packed */
  687. +@@ -2240,7 +2240,7 @@
  688. + PROTOBUF_C_LABEL_OPTIONAL,
  689. + PROTOBUF_C_TYPE_STRING,
  690. + 0, /* quantifier_offset */
  691. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, hash),
  692. ++ offsetof(MumbleProto__UserState, hash),
  693. + NULL,
  694. + NULL,
  695. + 0, /* packed */
  696. +@@ -2251,8 +2251,8 @@
  697. + 16,
  698. + PROTOBUF_C_LABEL_OPTIONAL,
  699. + PROTOBUF_C_TYPE_BYTES,
  700. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_comment_hash),
  701. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment_hash),
  702. ++ offsetof(MumbleProto__UserState, has_comment_hash),
  703. ++ offsetof(MumbleProto__UserState, comment_hash),
  704. + NULL,
  705. + NULL,
  706. + 0, /* packed */
  707. +@@ -2263,8 +2263,8 @@
  708. + 17,
  709. + PROTOBUF_C_LABEL_OPTIONAL,
  710. + PROTOBUF_C_TYPE_BYTES,
  711. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture_hash),
  712. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture_hash),
  713. ++ offsetof(MumbleProto__UserState, has_texture_hash),
  714. ++ offsetof(MumbleProto__UserState, texture_hash),
  715. + NULL,
  716. + NULL,
  717. + 0, /* packed */
  718. +@@ -2275,8 +2275,8 @@
  719. + 18,
  720. + PROTOBUF_C_LABEL_OPTIONAL,
  721. + PROTOBUF_C_TYPE_BOOL,
  722. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_priority_speaker),
  723. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, priority_speaker),
  724. ++ offsetof(MumbleProto__UserState, has_priority_speaker),
  725. ++ offsetof(MumbleProto__UserState, priority_speaker),
  726. + NULL,
  727. + NULL,
  728. + 0, /* packed */
  729. +@@ -2287,8 +2287,8 @@
  730. + 19,
  731. + PROTOBUF_C_LABEL_OPTIONAL,
  732. + PROTOBUF_C_TYPE_BOOL,
  733. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_recording),
  734. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserState, recording),
  735. ++ offsetof(MumbleProto__UserState, has_recording),
  736. ++ offsetof(MumbleProto__UserState, recording),
  737. + NULL,
  738. + NULL,
  739. + 0, /* packed */
  740. +@@ -2344,7 +2344,7 @@
  741. + PROTOBUF_C_LABEL_REQUIRED,
  742. + PROTOBUF_C_TYPE_BYTES,
  743. + 0, /* quantifier_offset */
  744. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, address),
  745. ++ offsetof(MumbleProto__BanList__BanEntry, address),
  746. + NULL,
  747. + NULL,
  748. + 0, /* packed */
  749. +@@ -2356,7 +2356,7 @@
  750. + PROTOBUF_C_LABEL_REQUIRED,
  751. + PROTOBUF_C_TYPE_UINT32,
  752. + 0, /* quantifier_offset */
  753. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, mask),
  754. ++ offsetof(MumbleProto__BanList__BanEntry, mask),
  755. + NULL,
  756. + NULL,
  757. + 0, /* packed */
  758. +@@ -2368,7 +2368,7 @@
  759. + PROTOBUF_C_LABEL_OPTIONAL,
  760. + PROTOBUF_C_TYPE_STRING,
  761. + 0, /* quantifier_offset */
  762. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, name),
  763. ++ offsetof(MumbleProto__BanList__BanEntry, name),
  764. + NULL,
  765. + NULL,
  766. + 0, /* packed */
  767. +@@ -2380,7 +2380,7 @@
  768. + PROTOBUF_C_LABEL_OPTIONAL,
  769. + PROTOBUF_C_TYPE_STRING,
  770. + 0, /* quantifier_offset */
  771. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, hash),
  772. ++ offsetof(MumbleProto__BanList__BanEntry, hash),
  773. + NULL,
  774. + NULL,
  775. + 0, /* packed */
  776. +@@ -2392,7 +2392,7 @@
  777. + PROTOBUF_C_LABEL_OPTIONAL,
  778. + PROTOBUF_C_TYPE_STRING,
  779. + 0, /* quantifier_offset */
  780. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, reason),
  781. ++ offsetof(MumbleProto__BanList__BanEntry, reason),
  782. + NULL,
  783. + NULL,
  784. + 0, /* packed */
  785. +@@ -2404,7 +2404,7 @@
  786. + PROTOBUF_C_LABEL_OPTIONAL,
  787. + PROTOBUF_C_TYPE_STRING,
  788. + 0, /* quantifier_offset */
  789. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, start),
  790. ++ offsetof(MumbleProto__BanList__BanEntry, start),
  791. + NULL,
  792. + NULL,
  793. + 0, /* packed */
  794. +@@ -2415,8 +2415,8 @@
  795. + 7,
  796. + PROTOBUF_C_LABEL_OPTIONAL,
  797. + PROTOBUF_C_TYPE_UINT32,
  798. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, has_duration),
  799. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, duration),
  800. ++ offsetof(MumbleProto__BanList__BanEntry, has_duration),
  801. ++ offsetof(MumbleProto__BanList__BanEntry, duration),
  802. + NULL,
  803. + NULL,
  804. + 0, /* packed */
  805. +@@ -2460,8 +2460,8 @@
  806. + 1,
  807. + PROTOBUF_C_LABEL_REPEATED,
  808. + PROTOBUF_C_TYPE_MESSAGE,
  809. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList, n_bans),
  810. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList, bans),
  811. ++ offsetof(MumbleProto__BanList, n_bans),
  812. ++ offsetof(MumbleProto__BanList, bans),
  813. + &mumble_proto__ban_list__ban_entry__descriptor,
  814. + NULL,
  815. + 0, /* packed */
  816. +@@ -2472,8 +2472,8 @@
  817. + 2,
  818. + PROTOBUF_C_LABEL_OPTIONAL,
  819. + PROTOBUF_C_TYPE_BOOL,
  820. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList, has_query),
  821. +- PROTOBUF_C_OFFSETOF(MumbleProto__BanList, query),
  822. ++ offsetof(MumbleProto__BanList, has_query),
  823. ++ offsetof(MumbleProto__BanList, query),
  824. + NULL,
  825. + &mumble_proto__ban_list__query__default_value,
  826. + 0, /* packed */
  827. +@@ -2511,8 +2511,8 @@
  828. + 1,
  829. + PROTOBUF_C_LABEL_OPTIONAL,
  830. + PROTOBUF_C_TYPE_UINT32,
  831. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, has_actor),
  832. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, actor),
  833. ++ offsetof(MumbleProto__TextMessage, has_actor),
  834. ++ offsetof(MumbleProto__TextMessage, actor),
  835. + NULL,
  836. + NULL,
  837. + 0, /* packed */
  838. +@@ -2523,8 +2523,8 @@
  839. + 2,
  840. + PROTOBUF_C_LABEL_REPEATED,
  841. + PROTOBUF_C_TYPE_UINT32,
  842. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_session),
  843. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, session),
  844. ++ offsetof(MumbleProto__TextMessage, n_session),
  845. ++ offsetof(MumbleProto__TextMessage, session),
  846. + NULL,
  847. + NULL,
  848. + 0, /* packed */
  849. +@@ -2535,8 +2535,8 @@
  850. + 3,
  851. + PROTOBUF_C_LABEL_REPEATED,
  852. + PROTOBUF_C_TYPE_UINT32,
  853. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_channel_id),
  854. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, channel_id),
  855. ++ offsetof(MumbleProto__TextMessage, n_channel_id),
  856. ++ offsetof(MumbleProto__TextMessage, channel_id),
  857. + NULL,
  858. + NULL,
  859. + 0, /* packed */
  860. +@@ -2547,8 +2547,8 @@
  861. + 4,
  862. + PROTOBUF_C_LABEL_REPEATED,
  863. + PROTOBUF_C_TYPE_UINT32,
  864. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_tree_id),
  865. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, tree_id),
  866. ++ offsetof(MumbleProto__TextMessage, n_tree_id),
  867. ++ offsetof(MumbleProto__TextMessage, tree_id),
  868. + NULL,
  869. + NULL,
  870. + 0, /* packed */
  871. +@@ -2560,7 +2560,7 @@
  872. + PROTOBUF_C_LABEL_REQUIRED,
  873. + PROTOBUF_C_TYPE_STRING,
  874. + 0, /* quantifier_offset */
  875. +- PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, message),
  876. ++ offsetof(MumbleProto__TextMessage, message),
  877. + NULL,
  878. + NULL,
  879. + 0, /* packed */
  880. +@@ -2647,8 +2647,8 @@
  881. + 1,
  882. + PROTOBUF_C_LABEL_OPTIONAL,
  883. + PROTOBUF_C_TYPE_UINT32,
  884. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_permission),
  885. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, permission),
  886. ++ offsetof(MumbleProto__PermissionDenied, has_permission),
  887. ++ offsetof(MumbleProto__PermissionDenied, permission),
  888. + NULL,
  889. + NULL,
  890. + 0, /* packed */
  891. +@@ -2659,8 +2659,8 @@
  892. + 2,
  893. + PROTOBUF_C_LABEL_OPTIONAL,
  894. + PROTOBUF_C_TYPE_UINT32,
  895. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_channel_id),
  896. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, channel_id),
  897. ++ offsetof(MumbleProto__PermissionDenied, has_channel_id),
  898. ++ offsetof(MumbleProto__PermissionDenied, channel_id),
  899. + NULL,
  900. + NULL,
  901. + 0, /* packed */
  902. +@@ -2671,8 +2671,8 @@
  903. + 3,
  904. + PROTOBUF_C_LABEL_OPTIONAL,
  905. + PROTOBUF_C_TYPE_UINT32,
  906. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_session),
  907. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, session),
  908. ++ offsetof(MumbleProto__PermissionDenied, has_session),
  909. ++ offsetof(MumbleProto__PermissionDenied, session),
  910. + NULL,
  911. + NULL,
  912. + 0, /* packed */
  913. +@@ -2684,7 +2684,7 @@
  914. + PROTOBUF_C_LABEL_OPTIONAL,
  915. + PROTOBUF_C_TYPE_STRING,
  916. + 0, /* quantifier_offset */
  917. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, reason),
  918. ++ offsetof(MumbleProto__PermissionDenied, reason),
  919. + NULL,
  920. + NULL,
  921. + 0, /* packed */
  922. +@@ -2695,8 +2695,8 @@
  923. + 5,
  924. + PROTOBUF_C_LABEL_OPTIONAL,
  925. + PROTOBUF_C_TYPE_ENUM,
  926. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_type),
  927. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, type),
  928. ++ offsetof(MumbleProto__PermissionDenied, has_type),
  929. ++ offsetof(MumbleProto__PermissionDenied, type),
  930. + &mumble_proto__permission_denied__deny_type__descriptor,
  931. + NULL,
  932. + 0, /* packed */
  933. +@@ -2708,7 +2708,7 @@
  934. + PROTOBUF_C_LABEL_OPTIONAL,
  935. + PROTOBUF_C_TYPE_STRING,
  936. + 0, /* quantifier_offset */
  937. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, name),
  938. ++ offsetof(MumbleProto__PermissionDenied, name),
  939. + NULL,
  940. + NULL,
  941. + 0, /* packed */
  942. +@@ -2754,7 +2754,7 @@
  943. + PROTOBUF_C_LABEL_REQUIRED,
  944. + PROTOBUF_C_TYPE_STRING,
  945. + 0, /* quantifier_offset */
  946. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, name),
  947. ++ offsetof(MumbleProto__ACL__ChanGroup, name),
  948. + NULL,
  949. + NULL,
  950. + 0, /* packed */
  951. +@@ -2765,8 +2765,8 @@
  952. + 2,
  953. + PROTOBUF_C_LABEL_OPTIONAL,
  954. + PROTOBUF_C_TYPE_BOOL,
  955. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherited),
  956. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited),
  957. ++ offsetof(MumbleProto__ACL__ChanGroup, has_inherited),
  958. ++ offsetof(MumbleProto__ACL__ChanGroup, inherited),
  959. + NULL,
  960. + &mumble_proto__acl__chan_group__inherited__default_value,
  961. + 0, /* packed */
  962. +@@ -2777,8 +2777,8 @@
  963. + 3,
  964. + PROTOBUF_C_LABEL_OPTIONAL,
  965. + PROTOBUF_C_TYPE_BOOL,
  966. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherit),
  967. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherit),
  968. ++ offsetof(MumbleProto__ACL__ChanGroup, has_inherit),
  969. ++ offsetof(MumbleProto__ACL__ChanGroup, inherit),
  970. + NULL,
  971. + &mumble_proto__acl__chan_group__inherit__default_value,
  972. + 0, /* packed */
  973. +@@ -2789,8 +2789,8 @@
  974. + 4,
  975. + PROTOBUF_C_LABEL_OPTIONAL,
  976. + PROTOBUF_C_TYPE_BOOL,
  977. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inheritable),
  978. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inheritable),
  979. ++ offsetof(MumbleProto__ACL__ChanGroup, has_inheritable),
  980. ++ offsetof(MumbleProto__ACL__ChanGroup, inheritable),
  981. + NULL,
  982. + &mumble_proto__acl__chan_group__inheritable__default_value,
  983. + 0, /* packed */
  984. +@@ -2801,8 +2801,8 @@
  985. + 5,
  986. + PROTOBUF_C_LABEL_REPEATED,
  987. + PROTOBUF_C_TYPE_UINT32,
  988. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_add),
  989. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, add),
  990. ++ offsetof(MumbleProto__ACL__ChanGroup, n_add),
  991. ++ offsetof(MumbleProto__ACL__ChanGroup, add),
  992. + NULL,
  993. + NULL,
  994. + 0, /* packed */
  995. +@@ -2813,8 +2813,8 @@
  996. + 6,
  997. + PROTOBUF_C_LABEL_REPEATED,
  998. + PROTOBUF_C_TYPE_UINT32,
  999. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_remove),
  1000. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, remove),
  1001. ++ offsetof(MumbleProto__ACL__ChanGroup, n_remove),
  1002. ++ offsetof(MumbleProto__ACL__ChanGroup, remove),
  1003. + NULL,
  1004. + NULL,
  1005. + 0, /* packed */
  1006. +@@ -2825,8 +2825,8 @@
  1007. + 7,
  1008. + PROTOBUF_C_LABEL_REPEATED,
  1009. + PROTOBUF_C_TYPE_UINT32,
  1010. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_inherited_members),
  1011. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited_members),
  1012. ++ offsetof(MumbleProto__ACL__ChanGroup, n_inherited_members),
  1013. ++ offsetof(MumbleProto__ACL__ChanGroup, inherited_members),
  1014. + NULL,
  1015. + NULL,
  1016. + 0, /* packed */
  1017. +@@ -2872,8 +2872,8 @@
  1018. + 1,
  1019. + PROTOBUF_C_LABEL_OPTIONAL,
  1020. + PROTOBUF_C_TYPE_BOOL,
  1021. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_here),
  1022. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_here),
  1023. ++ offsetof(MumbleProto__ACL__ChanACL, has_apply_here),
  1024. ++ offsetof(MumbleProto__ACL__ChanACL, apply_here),
  1025. + NULL,
  1026. + &mumble_proto__acl__chan_acl__apply_here__default_value,
  1027. + 0, /* packed */
  1028. +@@ -2884,8 +2884,8 @@
  1029. + 2,
  1030. + PROTOBUF_C_LABEL_OPTIONAL,
  1031. + PROTOBUF_C_TYPE_BOOL,
  1032. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_subs),
  1033. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_subs),
  1034. ++ offsetof(MumbleProto__ACL__ChanACL, has_apply_subs),
  1035. ++ offsetof(MumbleProto__ACL__ChanACL, apply_subs),
  1036. + NULL,
  1037. + &mumble_proto__acl__chan_acl__apply_subs__default_value,
  1038. + 0, /* packed */
  1039. +@@ -2896,8 +2896,8 @@
  1040. + 3,
  1041. + PROTOBUF_C_LABEL_OPTIONAL,
  1042. + PROTOBUF_C_TYPE_BOOL,
  1043. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_inherited),
  1044. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, inherited),
  1045. ++ offsetof(MumbleProto__ACL__ChanACL, has_inherited),
  1046. ++ offsetof(MumbleProto__ACL__ChanACL, inherited),
  1047. + NULL,
  1048. + &mumble_proto__acl__chan_acl__inherited__default_value,
  1049. + 0, /* packed */
  1050. +@@ -2908,8 +2908,8 @@
  1051. + 4,
  1052. + PROTOBUF_C_LABEL_OPTIONAL,
  1053. + PROTOBUF_C_TYPE_UINT32,
  1054. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_user_id),
  1055. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, user_id),
  1056. ++ offsetof(MumbleProto__ACL__ChanACL, has_user_id),
  1057. ++ offsetof(MumbleProto__ACL__ChanACL, user_id),
  1058. + NULL,
  1059. + NULL,
  1060. + 0, /* packed */
  1061. +@@ -2921,7 +2921,7 @@
  1062. + PROTOBUF_C_LABEL_OPTIONAL,
  1063. + PROTOBUF_C_TYPE_STRING,
  1064. + 0, /* quantifier_offset */
  1065. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, group),
  1066. ++ offsetof(MumbleProto__ACL__ChanACL, group),
  1067. + NULL,
  1068. + NULL,
  1069. + 0, /* packed */
  1070. +@@ -2932,8 +2932,8 @@
  1071. + 6,
  1072. + PROTOBUF_C_LABEL_OPTIONAL,
  1073. + PROTOBUF_C_TYPE_UINT32,
  1074. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_grant),
  1075. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, grant),
  1076. ++ offsetof(MumbleProto__ACL__ChanACL, has_grant),
  1077. ++ offsetof(MumbleProto__ACL__ChanACL, grant),
  1078. + NULL,
  1079. + NULL,
  1080. + 0, /* packed */
  1081. +@@ -2944,8 +2944,8 @@
  1082. + 7,
  1083. + PROTOBUF_C_LABEL_OPTIONAL,
  1084. + PROTOBUF_C_TYPE_UINT32,
  1085. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_deny),
  1086. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, deny),
  1087. ++ offsetof(MumbleProto__ACL__ChanACL, has_deny),
  1088. ++ offsetof(MumbleProto__ACL__ChanACL, deny),
  1089. + NULL,
  1090. + NULL,
  1091. + 0, /* packed */
  1092. +@@ -2991,7 +2991,7 @@
  1093. + PROTOBUF_C_LABEL_REQUIRED,
  1094. + PROTOBUF_C_TYPE_UINT32,
  1095. + 0, /* quantifier_offset */
  1096. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, channel_id),
  1097. ++ offsetof(MumbleProto__ACL, channel_id),
  1098. + NULL,
  1099. + NULL,
  1100. + 0, /* packed */
  1101. +@@ -3002,8 +3002,8 @@
  1102. + 2,
  1103. + PROTOBUF_C_LABEL_OPTIONAL,
  1104. + PROTOBUF_C_TYPE_BOOL,
  1105. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_inherit_acls),
  1106. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, inherit_acls),
  1107. ++ offsetof(MumbleProto__ACL, has_inherit_acls),
  1108. ++ offsetof(MumbleProto__ACL, inherit_acls),
  1109. + NULL,
  1110. + &mumble_proto__acl__inherit_acls__default_value,
  1111. + 0, /* packed */
  1112. +@@ -3014,8 +3014,8 @@
  1113. + 3,
  1114. + PROTOBUF_C_LABEL_REPEATED,
  1115. + PROTOBUF_C_TYPE_MESSAGE,
  1116. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_groups),
  1117. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, groups),
  1118. ++ offsetof(MumbleProto__ACL, n_groups),
  1119. ++ offsetof(MumbleProto__ACL, groups),
  1120. + &mumble_proto__acl__chan_group__descriptor,
  1121. + NULL,
  1122. + 0, /* packed */
  1123. +@@ -3026,8 +3026,8 @@
  1124. + 4,
  1125. + PROTOBUF_C_LABEL_REPEATED,
  1126. + PROTOBUF_C_TYPE_MESSAGE,
  1127. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_acls),
  1128. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, acls),
  1129. ++ offsetof(MumbleProto__ACL, n_acls),
  1130. ++ offsetof(MumbleProto__ACL, acls),
  1131. + &mumble_proto__acl__chan_acl__descriptor,
  1132. + NULL,
  1133. + 0, /* packed */
  1134. +@@ -3038,8 +3038,8 @@
  1135. + 5,
  1136. + PROTOBUF_C_LABEL_OPTIONAL,
  1137. + PROTOBUF_C_TYPE_BOOL,
  1138. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_query),
  1139. +- PROTOBUF_C_OFFSETOF(MumbleProto__ACL, query),
  1140. ++ offsetof(MumbleProto__ACL, has_query),
  1141. ++ offsetof(MumbleProto__ACL, query),
  1142. + NULL,
  1143. + &mumble_proto__acl__query__default_value,
  1144. + 0, /* packed */
  1145. +@@ -3080,8 +3080,8 @@
  1146. + 1,
  1147. + PROTOBUF_C_LABEL_REPEATED,
  1148. + PROTOBUF_C_TYPE_UINT32,
  1149. +- PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_ids),
  1150. +- PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, ids),
  1151. ++ offsetof(MumbleProto__QueryUsers, n_ids),
  1152. ++ offsetof(MumbleProto__QueryUsers, ids),
  1153. + NULL,
  1154. + NULL,
  1155. + 0, /* packed */
  1156. +@@ -3092,8 +3092,8 @@
  1157. + 2,
  1158. + PROTOBUF_C_LABEL_REPEATED,
  1159. + PROTOBUF_C_TYPE_STRING,
  1160. +- PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_names),
  1161. +- PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, names),
  1162. ++ offsetof(MumbleProto__QueryUsers, n_names),
  1163. ++ offsetof(MumbleProto__QueryUsers, names),
  1164. + NULL,
  1165. + NULL,
  1166. + 0, /* packed */
  1167. +@@ -3131,8 +3131,8 @@
  1168. + 1,
  1169. + PROTOBUF_C_LABEL_OPTIONAL,
  1170. + PROTOBUF_C_TYPE_BYTES,
  1171. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_key),
  1172. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, key),
  1173. ++ offsetof(MumbleProto__CryptSetup, has_key),
  1174. ++ offsetof(MumbleProto__CryptSetup, key),
  1175. + NULL,
  1176. + NULL,
  1177. + 0, /* packed */
  1178. +@@ -3143,8 +3143,8 @@
  1179. + 2,
  1180. + PROTOBUF_C_LABEL_OPTIONAL,
  1181. + PROTOBUF_C_TYPE_BYTES,
  1182. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_client_nonce),
  1183. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, client_nonce),
  1184. ++ offsetof(MumbleProto__CryptSetup, has_client_nonce),
  1185. ++ offsetof(MumbleProto__CryptSetup, client_nonce),
  1186. + NULL,
  1187. + NULL,
  1188. + 0, /* packed */
  1189. +@@ -3155,8 +3155,8 @@
  1190. + 3,
  1191. + PROTOBUF_C_LABEL_OPTIONAL,
  1192. + PROTOBUF_C_TYPE_BYTES,
  1193. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_server_nonce),
  1194. +- PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, server_nonce),
  1195. ++ offsetof(MumbleProto__CryptSetup, has_server_nonce),
  1196. ++ offsetof(MumbleProto__CryptSetup, server_nonce),
  1197. + NULL,
  1198. + NULL,
  1199. + 0, /* packed */
  1200. +@@ -3254,7 +3254,7 @@
  1201. + PROTOBUF_C_LABEL_REQUIRED,
  1202. + PROTOBUF_C_TYPE_STRING,
  1203. + 0, /* quantifier_offset */
  1204. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, action),
  1205. ++ offsetof(MumbleProto__ContextActionModify, action),
  1206. + NULL,
  1207. + NULL,
  1208. + 0, /* packed */
  1209. +@@ -3266,7 +3266,7 @@
  1210. + PROTOBUF_C_LABEL_OPTIONAL,
  1211. + PROTOBUF_C_TYPE_STRING,
  1212. + 0, /* quantifier_offset */
  1213. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, text),
  1214. ++ offsetof(MumbleProto__ContextActionModify, text),
  1215. + NULL,
  1216. + NULL,
  1217. + 0, /* packed */
  1218. +@@ -3277,8 +3277,8 @@
  1219. + 3,
  1220. + PROTOBUF_C_LABEL_OPTIONAL,
  1221. + PROTOBUF_C_TYPE_UINT32,
  1222. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, has_context),
  1223. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, context),
  1224. ++ offsetof(MumbleProto__ContextActionModify, has_context),
  1225. ++ offsetof(MumbleProto__ContextActionModify, context),
  1226. + NULL,
  1227. + NULL,
  1228. + 0, /* packed */
  1229. +@@ -3289,8 +3289,8 @@
  1230. + 4,
  1231. + PROTOBUF_C_LABEL_OPTIONAL,
  1232. + PROTOBUF_C_TYPE_ENUM,
  1233. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, has_operation),
  1234. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, operation),
  1235. ++ offsetof(MumbleProto__ContextActionModify, has_operation),
  1236. ++ offsetof(MumbleProto__ContextActionModify, operation),
  1237. + &mumble_proto__context_action_modify__operation__descriptor,
  1238. + NULL,
  1239. + 0, /* packed */
  1240. +@@ -3330,8 +3330,8 @@
  1241. + 1,
  1242. + PROTOBUF_C_LABEL_OPTIONAL,
  1243. + PROTOBUF_C_TYPE_UINT32,
  1244. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_session),
  1245. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, session),
  1246. ++ offsetof(MumbleProto__ContextAction, has_session),
  1247. ++ offsetof(MumbleProto__ContextAction, session),
  1248. + NULL,
  1249. + NULL,
  1250. + 0, /* packed */
  1251. +@@ -3342,8 +3342,8 @@
  1252. + 2,
  1253. + PROTOBUF_C_LABEL_OPTIONAL,
  1254. + PROTOBUF_C_TYPE_UINT32,
  1255. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_channel_id),
  1256. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, channel_id),
  1257. ++ offsetof(MumbleProto__ContextAction, has_channel_id),
  1258. ++ offsetof(MumbleProto__ContextAction, channel_id),
  1259. + NULL,
  1260. + NULL,
  1261. + 0, /* packed */
  1262. +@@ -3355,7 +3355,7 @@
  1263. + PROTOBUF_C_LABEL_REQUIRED,
  1264. + PROTOBUF_C_TYPE_STRING,
  1265. + 0, /* quantifier_offset */
  1266. +- PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, action),
  1267. ++ offsetof(MumbleProto__ContextAction, action),
  1268. + NULL,
  1269. + NULL,
  1270. + 0, /* packed */
  1271. +@@ -3395,7 +3395,7 @@
  1272. + PROTOBUF_C_LABEL_REQUIRED,
  1273. + PROTOBUF_C_TYPE_UINT32,
  1274. + 0, /* quantifier_offset */
  1275. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, user_id),
  1276. ++ offsetof(MumbleProto__UserList__User, user_id),
  1277. + NULL,
  1278. + NULL,
  1279. + 0, /* packed */
  1280. +@@ -3407,7 +3407,7 @@
  1281. + PROTOBUF_C_LABEL_OPTIONAL,
  1282. + PROTOBUF_C_TYPE_STRING,
  1283. + 0, /* quantifier_offset */
  1284. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, name),
  1285. ++ offsetof(MumbleProto__UserList__User, name),
  1286. + NULL,
  1287. + NULL,
  1288. + 0, /* packed */
  1289. +@@ -3445,8 +3445,8 @@
  1290. + 1,
  1291. + PROTOBUF_C_LABEL_REPEATED,
  1292. + PROTOBUF_C_TYPE_MESSAGE,
  1293. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserList, n_users),
  1294. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserList, users),
  1295. ++ offsetof(MumbleProto__UserList, n_users),
  1296. ++ offsetof(MumbleProto__UserList, users),
  1297. + &mumble_proto__user_list__user__descriptor,
  1298. + NULL,
  1299. + 0, /* packed */
  1300. +@@ -3485,8 +3485,8 @@
  1301. + 1,
  1302. + PROTOBUF_C_LABEL_REPEATED,
  1303. + PROTOBUF_C_TYPE_UINT32,
  1304. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, n_session),
  1305. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, session),
  1306. ++ offsetof(MumbleProto__VoiceTarget__Target, n_session),
  1307. ++ offsetof(MumbleProto__VoiceTarget__Target, session),
  1308. + NULL,
  1309. + NULL,
  1310. + 0, /* packed */
  1311. +@@ -3497,8 +3497,8 @@
  1312. + 2,
  1313. + PROTOBUF_C_LABEL_OPTIONAL,
  1314. + PROTOBUF_C_TYPE_UINT32,
  1315. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_channel_id),
  1316. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, channel_id),
  1317. ++ offsetof(MumbleProto__VoiceTarget__Target, has_channel_id),
  1318. ++ offsetof(MumbleProto__VoiceTarget__Target, channel_id),
  1319. + NULL,
  1320. + NULL,
  1321. + 0, /* packed */
  1322. +@@ -3510,7 +3510,7 @@
  1323. + PROTOBUF_C_LABEL_OPTIONAL,
  1324. + PROTOBUF_C_TYPE_STRING,
  1325. + 0, /* quantifier_offset */
  1326. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, group),
  1327. ++ offsetof(MumbleProto__VoiceTarget__Target, group),
  1328. + NULL,
  1329. + NULL,
  1330. + 0, /* packed */
  1331. +@@ -3521,8 +3521,8 @@
  1332. + 4,
  1333. + PROTOBUF_C_LABEL_OPTIONAL,
  1334. + PROTOBUF_C_TYPE_BOOL,
  1335. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_links),
  1336. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, links),
  1337. ++ offsetof(MumbleProto__VoiceTarget__Target, has_links),
  1338. ++ offsetof(MumbleProto__VoiceTarget__Target, links),
  1339. + NULL,
  1340. + &mumble_proto__voice_target__target__links__default_value,
  1341. + 0, /* packed */
  1342. +@@ -3533,8 +3533,8 @@
  1343. + 5,
  1344. + PROTOBUF_C_LABEL_OPTIONAL,
  1345. + PROTOBUF_C_TYPE_BOOL,
  1346. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_children),
  1347. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, children),
  1348. ++ offsetof(MumbleProto__VoiceTarget__Target, has_children),
  1349. ++ offsetof(MumbleProto__VoiceTarget__Target, children),
  1350. + NULL,
  1351. + &mumble_proto__voice_target__target__children__default_value,
  1352. + 0, /* packed */
  1353. +@@ -3575,8 +3575,8 @@
  1354. + 1,
  1355. + PROTOBUF_C_LABEL_OPTIONAL,
  1356. + PROTOBUF_C_TYPE_UINT32,
  1357. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, has_id),
  1358. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, id),
  1359. ++ offsetof(MumbleProto__VoiceTarget, has_id),
  1360. ++ offsetof(MumbleProto__VoiceTarget, id),
  1361. + NULL,
  1362. + NULL,
  1363. + 0, /* packed */
  1364. +@@ -3587,8 +3587,8 @@
  1365. + 2,
  1366. + PROTOBUF_C_LABEL_REPEATED,
  1367. + PROTOBUF_C_TYPE_MESSAGE,
  1368. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, n_targets),
  1369. +- PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, targets),
  1370. ++ offsetof(MumbleProto__VoiceTarget, n_targets),
  1371. ++ offsetof(MumbleProto__VoiceTarget, targets),
  1372. + &mumble_proto__voice_target__target__descriptor,
  1373. + NULL,
  1374. + 0, /* packed */
  1375. +@@ -3627,8 +3627,8 @@
  1376. + 1,
  1377. + PROTOBUF_C_LABEL_OPTIONAL,
  1378. + PROTOBUF_C_TYPE_UINT32,
  1379. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_channel_id),
  1380. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, channel_id),
  1381. ++ offsetof(MumbleProto__PermissionQuery, has_channel_id),
  1382. ++ offsetof(MumbleProto__PermissionQuery, channel_id),
  1383. + NULL,
  1384. + NULL,
  1385. + 0, /* packed */
  1386. +@@ -3639,8 +3639,8 @@
  1387. + 2,
  1388. + PROTOBUF_C_LABEL_OPTIONAL,
  1389. + PROTOBUF_C_TYPE_UINT32,
  1390. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_permissions),
  1391. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, permissions),
  1392. ++ offsetof(MumbleProto__PermissionQuery, has_permissions),
  1393. ++ offsetof(MumbleProto__PermissionQuery, permissions),
  1394. + NULL,
  1395. + NULL,
  1396. + 0, /* packed */
  1397. +@@ -3651,8 +3651,8 @@
  1398. + 3,
  1399. + PROTOBUF_C_LABEL_OPTIONAL,
  1400. + PROTOBUF_C_TYPE_BOOL,
  1401. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_flush),
  1402. +- PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, flush),
  1403. ++ offsetof(MumbleProto__PermissionQuery, has_flush),
  1404. ++ offsetof(MumbleProto__PermissionQuery, flush),
  1405. + NULL,
  1406. + &mumble_proto__permission_query__flush__default_value,
  1407. + 0, /* packed */
  1408. +@@ -3694,7 +3694,7 @@
  1409. + PROTOBUF_C_LABEL_REQUIRED,
  1410. + PROTOBUF_C_TYPE_INT32,
  1411. + 0, /* quantifier_offset */
  1412. +- PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, alpha),
  1413. ++ offsetof(MumbleProto__CodecVersion, alpha),
  1414. + NULL,
  1415. + NULL,
  1416. + 0, /* packed */
  1417. +@@ -3706,7 +3706,7 @@
  1418. + PROTOBUF_C_LABEL_REQUIRED,
  1419. + PROTOBUF_C_TYPE_INT32,
  1420. + 0, /* quantifier_offset */
  1421. +- PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, beta),
  1422. ++ offsetof(MumbleProto__CodecVersion, beta),
  1423. + NULL,
  1424. + NULL,
  1425. + 0, /* packed */
  1426. +@@ -3718,7 +3718,7 @@
  1427. + PROTOBUF_C_LABEL_REQUIRED,
  1428. + PROTOBUF_C_TYPE_BOOL,
  1429. + 0, /* quantifier_offset */
  1430. +- PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, prefer_alpha),
  1431. ++ offsetof(MumbleProto__CodecVersion, prefer_alpha),
  1432. + NULL,
  1433. + &mumble_proto__codec_version__prefer_alpha__default_value,
  1434. + 0, /* packed */
  1435. +@@ -3729,8 +3729,8 @@
  1436. + 4,
  1437. + PROTOBUF_C_LABEL_OPTIONAL,
  1438. + PROTOBUF_C_TYPE_BOOL,
  1439. +- PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, has_opus),
  1440. +- PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, opus),
  1441. ++ offsetof(MumbleProto__CodecVersion, has_opus),
  1442. ++ offsetof(MumbleProto__CodecVersion, opus),
  1443. + NULL,
  1444. + &mumble_proto__codec_version__opus__default_value,
  1445. + 0, /* packed */
  1446. +@@ -3770,8 +3770,8 @@
  1447. + 1,
  1448. + PROTOBUF_C_LABEL_OPTIONAL,
  1449. + PROTOBUF_C_TYPE_UINT32,
  1450. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_good),
  1451. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, good),
  1452. ++ offsetof(MumbleProto__UserStats__Stats, has_good),
  1453. ++ offsetof(MumbleProto__UserStats__Stats, good),
  1454. + NULL,
  1455. + NULL,
  1456. + 0, /* packed */
  1457. +@@ -3782,8 +3782,8 @@
  1458. + 2,
  1459. + PROTOBUF_C_LABEL_OPTIONAL,
  1460. + PROTOBUF_C_TYPE_UINT32,
  1461. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_late),
  1462. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, late),
  1463. ++ offsetof(MumbleProto__UserStats__Stats, has_late),
  1464. ++ offsetof(MumbleProto__UserStats__Stats, late),
  1465. + NULL,
  1466. + NULL,
  1467. + 0, /* packed */
  1468. +@@ -3794,8 +3794,8 @@
  1469. + 3,
  1470. + PROTOBUF_C_LABEL_OPTIONAL,
  1471. + PROTOBUF_C_TYPE_UINT32,
  1472. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_lost),
  1473. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, lost),
  1474. ++ offsetof(MumbleProto__UserStats__Stats, has_lost),
  1475. ++ offsetof(MumbleProto__UserStats__Stats, lost),
  1476. + NULL,
  1477. + NULL,
  1478. + 0, /* packed */
  1479. +@@ -3806,8 +3806,8 @@
  1480. + 4,
  1481. + PROTOBUF_C_LABEL_OPTIONAL,
  1482. + PROTOBUF_C_TYPE_UINT32,
  1483. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_resync),
  1484. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, resync),
  1485. ++ offsetof(MumbleProto__UserStats__Stats, has_resync),
  1486. ++ offsetof(MumbleProto__UserStats__Stats, resync),
  1487. + NULL,
  1488. + NULL,
  1489. + 0, /* packed */
  1490. +@@ -3850,8 +3850,8 @@
  1491. + 1,
  1492. + PROTOBUF_C_LABEL_OPTIONAL,
  1493. + PROTOBUF_C_TYPE_UINT32,
  1494. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_session),
  1495. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, session),
  1496. ++ offsetof(MumbleProto__UserStats, has_session),
  1497. ++ offsetof(MumbleProto__UserStats, session),
  1498. + NULL,
  1499. + NULL,
  1500. + 0, /* packed */
  1501. +@@ -3862,8 +3862,8 @@
  1502. + 2,
  1503. + PROTOBUF_C_LABEL_OPTIONAL,
  1504. + PROTOBUF_C_TYPE_BOOL,
  1505. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_stats_only),
  1506. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, stats_only),
  1507. ++ offsetof(MumbleProto__UserStats, has_stats_only),
  1508. ++ offsetof(MumbleProto__UserStats, stats_only),
  1509. + NULL,
  1510. + &mumble_proto__user_stats__stats_only__default_value,
  1511. + 0, /* packed */
  1512. +@@ -3874,8 +3874,8 @@
  1513. + 3,
  1514. + PROTOBUF_C_LABEL_REPEATED,
  1515. + PROTOBUF_C_TYPE_BYTES,
  1516. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_certificates),
  1517. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, certificates),
  1518. ++ offsetof(MumbleProto__UserStats, n_certificates),
  1519. ++ offsetof(MumbleProto__UserStats, certificates),
  1520. + NULL,
  1521. + NULL,
  1522. + 0, /* packed */
  1523. +@@ -3887,7 +3887,7 @@
  1524. + PROTOBUF_C_LABEL_OPTIONAL,
  1525. + PROTOBUF_C_TYPE_MESSAGE,
  1526. + 0, /* quantifier_offset */
  1527. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_client),
  1528. ++ offsetof(MumbleProto__UserStats, from_client),
  1529. + &mumble_proto__user_stats__stats__descriptor,
  1530. + NULL,
  1531. + 0, /* packed */
  1532. +@@ -3899,7 +3899,7 @@
  1533. + PROTOBUF_C_LABEL_OPTIONAL,
  1534. + PROTOBUF_C_TYPE_MESSAGE,
  1535. + 0, /* quantifier_offset */
  1536. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_server),
  1537. ++ offsetof(MumbleProto__UserStats, from_server),
  1538. + &mumble_proto__user_stats__stats__descriptor,
  1539. + NULL,
  1540. + 0, /* packed */
  1541. +@@ -3910,8 +3910,8 @@
  1542. + 6,
  1543. + PROTOBUF_C_LABEL_OPTIONAL,
  1544. + PROTOBUF_C_TYPE_UINT32,
  1545. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_packets),
  1546. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_packets),
  1547. ++ offsetof(MumbleProto__UserStats, has_udp_packets),
  1548. ++ offsetof(MumbleProto__UserStats, udp_packets),
  1549. + NULL,
  1550. + NULL,
  1551. + 0, /* packed */
  1552. +@@ -3922,8 +3922,8 @@
  1553. + 7,
  1554. + PROTOBUF_C_LABEL_OPTIONAL,
  1555. + PROTOBUF_C_TYPE_UINT32,
  1556. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_packets),
  1557. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_packets),
  1558. ++ offsetof(MumbleProto__UserStats, has_tcp_packets),
  1559. ++ offsetof(MumbleProto__UserStats, tcp_packets),
  1560. + NULL,
  1561. + NULL,
  1562. + 0, /* packed */
  1563. +@@ -3934,8 +3934,8 @@
  1564. + 8,
  1565. + PROTOBUF_C_LABEL_OPTIONAL,
  1566. + PROTOBUF_C_TYPE_FLOAT,
  1567. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_avg),
  1568. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_avg),
  1569. ++ offsetof(MumbleProto__UserStats, has_udp_ping_avg),
  1570. ++ offsetof(MumbleProto__UserStats, udp_ping_avg),
  1571. + NULL,
  1572. + NULL,
  1573. + 0, /* packed */
  1574. +@@ -3946,8 +3946,8 @@
  1575. + 9,
  1576. + PROTOBUF_C_LABEL_OPTIONAL,
  1577. + PROTOBUF_C_TYPE_FLOAT,
  1578. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_var),
  1579. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_var),
  1580. ++ offsetof(MumbleProto__UserStats, has_udp_ping_var),
  1581. ++ offsetof(MumbleProto__UserStats, udp_ping_var),
  1582. + NULL,
  1583. + NULL,
  1584. + 0, /* packed */
  1585. +@@ -3958,8 +3958,8 @@
  1586. + 10,
  1587. + PROTOBUF_C_LABEL_OPTIONAL,
  1588. + PROTOBUF_C_TYPE_FLOAT,
  1589. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_avg),
  1590. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_avg),
  1591. ++ offsetof(MumbleProto__UserStats, has_tcp_ping_avg),
  1592. ++ offsetof(MumbleProto__UserStats, tcp_ping_avg),
  1593. + NULL,
  1594. + NULL,
  1595. + 0, /* packed */
  1596. +@@ -3970,8 +3970,8 @@
  1597. + 11,
  1598. + PROTOBUF_C_LABEL_OPTIONAL,
  1599. + PROTOBUF_C_TYPE_FLOAT,
  1600. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_var),
  1601. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_var),
  1602. ++ offsetof(MumbleProto__UserStats, has_tcp_ping_var),
  1603. ++ offsetof(MumbleProto__UserStats, tcp_ping_var),
  1604. + NULL,
  1605. + NULL,
  1606. + 0, /* packed */
  1607. +@@ -3983,7 +3983,7 @@
  1608. + PROTOBUF_C_LABEL_OPTIONAL,
  1609. + PROTOBUF_C_TYPE_MESSAGE,
  1610. + 0, /* quantifier_offset */
  1611. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, version),
  1612. ++ offsetof(MumbleProto__UserStats, version),
  1613. + &mumble_proto__version__descriptor,
  1614. + NULL,
  1615. + 0, /* packed */
  1616. +@@ -3994,8 +3994,8 @@
  1617. + 13,
  1618. + PROTOBUF_C_LABEL_REPEATED,
  1619. + PROTOBUF_C_TYPE_INT32,
  1620. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_celt_versions),
  1621. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, celt_versions),
  1622. ++ offsetof(MumbleProto__UserStats, n_celt_versions),
  1623. ++ offsetof(MumbleProto__UserStats, celt_versions),
  1624. + NULL,
  1625. + NULL,
  1626. + 0, /* packed */
  1627. +@@ -4006,8 +4006,8 @@
  1628. + 14,
  1629. + PROTOBUF_C_LABEL_OPTIONAL,
  1630. + PROTOBUF_C_TYPE_BYTES,
  1631. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_address),
  1632. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, address),
  1633. ++ offsetof(MumbleProto__UserStats, has_address),
  1634. ++ offsetof(MumbleProto__UserStats, address),
  1635. + NULL,
  1636. + NULL,
  1637. + 0, /* packed */
  1638. +@@ -4018,8 +4018,8 @@
  1639. + 15,
  1640. + PROTOBUF_C_LABEL_OPTIONAL,
  1641. + PROTOBUF_C_TYPE_UINT32,
  1642. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_bandwidth),
  1643. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, bandwidth),
  1644. ++ offsetof(MumbleProto__UserStats, has_bandwidth),
  1645. ++ offsetof(MumbleProto__UserStats, bandwidth),
  1646. + NULL,
  1647. + NULL,
  1648. + 0, /* packed */
  1649. +@@ -4030,8 +4030,8 @@
  1650. + 16,
  1651. + PROTOBUF_C_LABEL_OPTIONAL,
  1652. + PROTOBUF_C_TYPE_UINT32,
  1653. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_onlinesecs),
  1654. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, onlinesecs),
  1655. ++ offsetof(MumbleProto__UserStats, has_onlinesecs),
  1656. ++ offsetof(MumbleProto__UserStats, onlinesecs),
  1657. + NULL,
  1658. + NULL,
  1659. + 0, /* packed */
  1660. +@@ -4042,8 +4042,8 @@
  1661. + 17,
  1662. + PROTOBUF_C_LABEL_OPTIONAL,
  1663. + PROTOBUF_C_TYPE_UINT32,
  1664. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_idlesecs),
  1665. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, idlesecs),
  1666. ++ offsetof(MumbleProto__UserStats, has_idlesecs),
  1667. ++ offsetof(MumbleProto__UserStats, idlesecs),
  1668. + NULL,
  1669. + NULL,
  1670. + 0, /* packed */
  1671. +@@ -4054,8 +4054,8 @@
  1672. + 18,
  1673. + PROTOBUF_C_LABEL_OPTIONAL,
  1674. + PROTOBUF_C_TYPE_BOOL,
  1675. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_strong_certificate),
  1676. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, strong_certificate),
  1677. ++ offsetof(MumbleProto__UserStats, has_strong_certificate),
  1678. ++ offsetof(MumbleProto__UserStats, strong_certificate),
  1679. + NULL,
  1680. + &mumble_proto__user_stats__strong_certificate__default_value,
  1681. + 0, /* packed */
  1682. +@@ -4066,8 +4066,8 @@
  1683. + 19,
  1684. + PROTOBUF_C_LABEL_OPTIONAL,
  1685. + PROTOBUF_C_TYPE_BOOL,
  1686. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_opus),
  1687. +- PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, opus),
  1688. ++ offsetof(MumbleProto__UserStats, has_opus),
  1689. ++ offsetof(MumbleProto__UserStats, opus),
  1690. + NULL,
  1691. + &mumble_proto__user_stats__opus__default_value,
  1692. + 0, /* packed */
  1693. +@@ -4122,8 +4122,8 @@
  1694. + 1,
  1695. + PROTOBUF_C_LABEL_OPTIONAL,
  1696. + PROTOBUF_C_TYPE_UINT32,
  1697. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_version),
  1698. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, version),
  1699. ++ offsetof(MumbleProto__SuggestConfig, has_version),
  1700. ++ offsetof(MumbleProto__SuggestConfig, version),
  1701. + NULL,
  1702. + NULL,
  1703. + 0, /* packed */
  1704. +@@ -4134,8 +4134,8 @@
  1705. + 2,
  1706. + PROTOBUF_C_LABEL_OPTIONAL,
  1707. + PROTOBUF_C_TYPE_BOOL,
  1708. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_positional),
  1709. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, positional),
  1710. ++ offsetof(MumbleProto__SuggestConfig, has_positional),
  1711. ++ offsetof(MumbleProto__SuggestConfig, positional),
  1712. + NULL,
  1713. + NULL,
  1714. + 0, /* packed */
  1715. +@@ -4146,8 +4146,8 @@
  1716. + 3,
  1717. + PROTOBUF_C_LABEL_OPTIONAL,
  1718. + PROTOBUF_C_TYPE_BOOL,
  1719. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_push_to_talk),
  1720. +- PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, push_to_talk),
  1721. ++ offsetof(MumbleProto__SuggestConfig, has_push_to_talk),
  1722. ++ offsetof(MumbleProto__SuggestConfig, push_to_talk),
  1723. + NULL,
  1724. + NULL,
  1725. + 0, /* packed */
  1726. +@@ -4186,8 +4186,8 @@
  1727. + 1,
  1728. + PROTOBUF_C_LABEL_REPEATED,
  1729. + PROTOBUF_C_TYPE_UINT32,
  1730. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_texture),
  1731. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_texture),
  1732. ++ offsetof(MumbleProto__RequestBlob, n_session_texture),
  1733. ++ offsetof(MumbleProto__RequestBlob, session_texture),
  1734. + NULL,
  1735. + NULL,
  1736. + 0, /* packed */
  1737. +@@ -4198,8 +4198,8 @@
  1738. + 2,
  1739. + PROTOBUF_C_LABEL_REPEATED,
  1740. + PROTOBUF_C_TYPE_UINT32,
  1741. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_comment),
  1742. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_comment),
  1743. ++ offsetof(MumbleProto__RequestBlob, n_session_comment),
  1744. ++ offsetof(MumbleProto__RequestBlob, session_comment),
  1745. + NULL,
  1746. + NULL,
  1747. + 0, /* packed */
  1748. +@@ -4210,8 +4210,8 @@
  1749. + 3,
  1750. + PROTOBUF_C_LABEL_REPEATED,
  1751. + PROTOBUF_C_TYPE_UINT32,
  1752. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_channel_description),
  1753. +- PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, channel_description),
  1754. ++ offsetof(MumbleProto__RequestBlob, n_channel_description),
  1755. ++ offsetof(MumbleProto__RequestBlob, channel_description),
  1756. + NULL,
  1757. + NULL,
  1758. + 0, /* packed */
  1759. --- /dev/null 2014-07-27 17:46:41.073281280 -0400
  1760. +++ feeds/oldpackages/net/umurmur/patches/004-magic
  1761. @@ -0,0 +1,11 @@
  1762. +--- a/src/Mumble.pb-c.h
  1763. ++++ b/src/Mumble.pb-c.h
  1764. +@@ -1301,4 +1301,8 @@
  1765. + extern const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor;
  1766. + extern const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor;
  1767. +
  1768. ++#define PROTOBUF_C_SERVICE_DESCRIPTOR_MAGIC 0x14159bc3
  1769. ++#define PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC 0x28aaeef9
  1770. ++#define PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC 0x114315af
  1771. ++
  1772. + #endif /* PROTOBUF_Mumble_2eproto__INCLUDED */
  1773. --- /dev/null 2014-07-27 17:46:41.073281280 -0400
  1774. +++ feeds/oldpackages/net/umurmur/patches/005-assert
  1775. @@ -0,0 +1,886 @@
  1776. +--- a/src/Mumble.pb-c.c
  1777. ++++ b/src/Mumble.pb-c.c
  1778. +@@ -15,21 +15,21 @@
  1779. + size_t mumble_proto__version__get_packed_size
  1780. + (const MumbleProto__Version *message)
  1781. + {
  1782. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  1783. ++ assert (message->base.descriptor == &mumble_proto__version__descriptor);
  1784. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1785. + }
  1786. + size_t mumble_proto__version__pack
  1787. + (const MumbleProto__Version *message,
  1788. + uint8_t *out)
  1789. + {
  1790. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  1791. ++ assert (message->base.descriptor == &mumble_proto__version__descriptor);
  1792. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1793. + }
  1794. + size_t mumble_proto__version__pack_to_buffer
  1795. + (const MumbleProto__Version *message,
  1796. + ProtobufCBuffer *buffer)
  1797. + {
  1798. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  1799. ++ assert (message->base.descriptor == &mumble_proto__version__descriptor);
  1800. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1801. + }
  1802. + MumbleProto__Version *
  1803. +@@ -46,7 +46,7 @@
  1804. + (MumbleProto__Version *message,
  1805. + ProtobufCAllocator *allocator)
  1806. + {
  1807. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  1808. ++ assert (message->base.descriptor == &mumble_proto__version__descriptor);
  1809. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1810. + }
  1811. + void mumble_proto__udptunnel__init
  1812. +@@ -58,21 +58,21 @@
  1813. + size_t mumble_proto__udptunnel__get_packed_size
  1814. + (const MumbleProto__UDPTunnel *message)
  1815. + {
  1816. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1817. ++ assert (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1818. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1819. + }
  1820. + size_t mumble_proto__udptunnel__pack
  1821. + (const MumbleProto__UDPTunnel *message,
  1822. + uint8_t *out)
  1823. + {
  1824. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1825. ++ assert (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1826. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1827. + }
  1828. + size_t mumble_proto__udptunnel__pack_to_buffer
  1829. + (const MumbleProto__UDPTunnel *message,
  1830. + ProtobufCBuffer *buffer)
  1831. + {
  1832. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1833. ++ assert (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1834. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1835. + }
  1836. + MumbleProto__UDPTunnel *
  1837. +@@ -89,7 +89,7 @@
  1838. + (MumbleProto__UDPTunnel *message,
  1839. + ProtobufCAllocator *allocator)
  1840. + {
  1841. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1842. ++ assert (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  1843. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1844. + }
  1845. + void mumble_proto__authenticate__init
  1846. +@@ -101,21 +101,21 @@
  1847. + size_t mumble_proto__authenticate__get_packed_size
  1848. + (const MumbleProto__Authenticate *message)
  1849. + {
  1850. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1851. ++ assert (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1852. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1853. + }
  1854. + size_t mumble_proto__authenticate__pack
  1855. + (const MumbleProto__Authenticate *message,
  1856. + uint8_t *out)
  1857. + {
  1858. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1859. ++ assert (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1860. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1861. + }
  1862. + size_t mumble_proto__authenticate__pack_to_buffer
  1863. + (const MumbleProto__Authenticate *message,
  1864. + ProtobufCBuffer *buffer)
  1865. + {
  1866. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1867. ++ assert (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1868. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1869. + }
  1870. + MumbleProto__Authenticate *
  1871. +@@ -132,7 +132,7 @@
  1872. + (MumbleProto__Authenticate *message,
  1873. + ProtobufCAllocator *allocator)
  1874. + {
  1875. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1876. ++ assert (message->base.descriptor == &mumble_proto__authenticate__descriptor);
  1877. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1878. + }
  1879. + void mumble_proto__ping__init
  1880. +@@ -144,21 +144,21 @@
  1881. + size_t mumble_proto__ping__get_packed_size
  1882. + (const MumbleProto__Ping *message)
  1883. + {
  1884. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
  1885. ++ assert (message->base.descriptor == &mumble_proto__ping__descriptor);
  1886. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1887. + }
  1888. + size_t mumble_proto__ping__pack
  1889. + (const MumbleProto__Ping *message,
  1890. + uint8_t *out)
  1891. + {
  1892. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
  1893. ++ assert (message->base.descriptor == &mumble_proto__ping__descriptor);
  1894. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1895. + }
  1896. + size_t mumble_proto__ping__pack_to_buffer
  1897. + (const MumbleProto__Ping *message,
  1898. + ProtobufCBuffer *buffer)
  1899. + {
  1900. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
  1901. ++ assert (message->base.descriptor == &mumble_proto__ping__descriptor);
  1902. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1903. + }
  1904. + MumbleProto__Ping *
  1905. +@@ -175,7 +175,7 @@
  1906. + (MumbleProto__Ping *message,
  1907. + ProtobufCAllocator *allocator)
  1908. + {
  1909. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
  1910. ++ assert (message->base.descriptor == &mumble_proto__ping__descriptor);
  1911. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1912. + }
  1913. + void mumble_proto__reject__init
  1914. +@@ -187,21 +187,21 @@
  1915. + size_t mumble_proto__reject__get_packed_size
  1916. + (const MumbleProto__Reject *message)
  1917. + {
  1918. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
  1919. ++ assert (message->base.descriptor == &mumble_proto__reject__descriptor);
  1920. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1921. + }
  1922. + size_t mumble_proto__reject__pack
  1923. + (const MumbleProto__Reject *message,
  1924. + uint8_t *out)
  1925. + {
  1926. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
  1927. ++ assert (message->base.descriptor == &mumble_proto__reject__descriptor);
  1928. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1929. + }
  1930. + size_t mumble_proto__reject__pack_to_buffer
  1931. + (const MumbleProto__Reject *message,
  1932. + ProtobufCBuffer *buffer)
  1933. + {
  1934. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
  1935. ++ assert (message->base.descriptor == &mumble_proto__reject__descriptor);
  1936. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1937. + }
  1938. + MumbleProto__Reject *
  1939. +@@ -218,7 +218,7 @@
  1940. + (MumbleProto__Reject *message,
  1941. + ProtobufCAllocator *allocator)
  1942. + {
  1943. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
  1944. ++ assert (message->base.descriptor == &mumble_proto__reject__descriptor);
  1945. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1946. + }
  1947. + void mumble_proto__server_config__init
  1948. +@@ -230,21 +230,21 @@
  1949. + size_t mumble_proto__server_config__get_packed_size
  1950. + (const MumbleProto__ServerConfig *message)
  1951. + {
  1952. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1953. ++ assert (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1954. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1955. + }
  1956. + size_t mumble_proto__server_config__pack
  1957. + (const MumbleProto__ServerConfig *message,
  1958. + uint8_t *out)
  1959. + {
  1960. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1961. ++ assert (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1962. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1963. + }
  1964. + size_t mumble_proto__server_config__pack_to_buffer
  1965. + (const MumbleProto__ServerConfig *message,
  1966. + ProtobufCBuffer *buffer)
  1967. + {
  1968. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1969. ++ assert (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1970. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  1971. + }
  1972. + MumbleProto__ServerConfig *
  1973. +@@ -261,7 +261,7 @@
  1974. + (MumbleProto__ServerConfig *message,
  1975. + ProtobufCAllocator *allocator)
  1976. + {
  1977. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1978. ++ assert (message->base.descriptor == &mumble_proto__server_config__descriptor);
  1979. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  1980. + }
  1981. + void mumble_proto__server_sync__init
  1982. +@@ -273,21 +273,21 @@
  1983. + size_t mumble_proto__server_sync__get_packed_size
  1984. + (const MumbleProto__ServerSync *message)
  1985. + {
  1986. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  1987. ++ assert (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  1988. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  1989. + }
  1990. + size_t mumble_proto__server_sync__pack
  1991. + (const MumbleProto__ServerSync *message,
  1992. + uint8_t *out)
  1993. + {
  1994. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  1995. ++ assert (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  1996. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  1997. + }
  1998. + size_t mumble_proto__server_sync__pack_to_buffer
  1999. + (const MumbleProto__ServerSync *message,
  2000. + ProtobufCBuffer *buffer)
  2001. + {
  2002. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  2003. ++ assert (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  2004. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2005. + }
  2006. + MumbleProto__ServerSync *
  2007. +@@ -304,7 +304,7 @@
  2008. + (MumbleProto__ServerSync *message,
  2009. + ProtobufCAllocator *allocator)
  2010. + {
  2011. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  2012. ++ assert (message->base.descriptor == &mumble_proto__server_sync__descriptor);
  2013. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2014. + }
  2015. + void mumble_proto__channel_remove__init
  2016. +@@ -316,21 +316,21 @@
  2017. + size_t mumble_proto__channel_remove__get_packed_size
  2018. + (const MumbleProto__ChannelRemove *message)
  2019. + {
  2020. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2021. ++ assert (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2022. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2023. + }
  2024. + size_t mumble_proto__channel_remove__pack
  2025. + (const MumbleProto__ChannelRemove *message,
  2026. + uint8_t *out)
  2027. + {
  2028. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2029. ++ assert (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2030. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2031. + }
  2032. + size_t mumble_proto__channel_remove__pack_to_buffer
  2033. + (const MumbleProto__ChannelRemove *message,
  2034. + ProtobufCBuffer *buffer)
  2035. + {
  2036. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2037. ++ assert (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2038. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2039. + }
  2040. + MumbleProto__ChannelRemove *
  2041. +@@ -347,7 +347,7 @@
  2042. + (MumbleProto__ChannelRemove *message,
  2043. + ProtobufCAllocator *allocator)
  2044. + {
  2045. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2046. ++ assert (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
  2047. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2048. + }
  2049. + void mumble_proto__channel_state__init
  2050. +@@ -359,21 +359,21 @@
  2051. + size_t mumble_proto__channel_state__get_packed_size
  2052. + (const MumbleProto__ChannelState *message)
  2053. + {
  2054. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2055. ++ assert (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2056. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2057. + }
  2058. + size_t mumble_proto__channel_state__pack
  2059. + (const MumbleProto__ChannelState *message,
  2060. + uint8_t *out)
  2061. + {
  2062. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2063. ++ assert (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2064. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2065. + }
  2066. + size_t mumble_proto__channel_state__pack_to_buffer
  2067. + (const MumbleProto__ChannelState *message,
  2068. + ProtobufCBuffer *buffer)
  2069. + {
  2070. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2071. ++ assert (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2072. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2073. + }
  2074. + MumbleProto__ChannelState *
  2075. +@@ -390,7 +390,7 @@
  2076. + (MumbleProto__ChannelState *message,
  2077. + ProtobufCAllocator *allocator)
  2078. + {
  2079. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2080. ++ assert (message->base.descriptor == &mumble_proto__channel_state__descriptor);
  2081. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2082. + }
  2083. + void mumble_proto__user_remove__init
  2084. +@@ -402,21 +402,21 @@
  2085. + size_t mumble_proto__user_remove__get_packed_size
  2086. + (const MumbleProto__UserRemove *message)
  2087. + {
  2088. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2089. ++ assert (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2090. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2091. + }
  2092. + size_t mumble_proto__user_remove__pack
  2093. + (const MumbleProto__UserRemove *message,
  2094. + uint8_t *out)
  2095. + {
  2096. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2097. ++ assert (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2098. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2099. + }
  2100. + size_t mumble_proto__user_remove__pack_to_buffer
  2101. + (const MumbleProto__UserRemove *message,
  2102. + ProtobufCBuffer *buffer)
  2103. + {
  2104. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2105. ++ assert (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2106. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2107. + }
  2108. + MumbleProto__UserRemove *
  2109. +@@ -433,7 +433,7 @@
  2110. + (MumbleProto__UserRemove *message,
  2111. + ProtobufCAllocator *allocator)
  2112. + {
  2113. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2114. ++ assert (message->base.descriptor == &mumble_proto__user_remove__descriptor);
  2115. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2116. + }
  2117. + void mumble_proto__user_state__init
  2118. +@@ -445,21 +445,21 @@
  2119. + size_t mumble_proto__user_state__get_packed_size
  2120. + (const MumbleProto__UserState *message)
  2121. + {
  2122. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2123. ++ assert (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2124. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2125. + }
  2126. + size_t mumble_proto__user_state__pack
  2127. + (const MumbleProto__UserState *message,
  2128. + uint8_t *out)
  2129. + {
  2130. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2131. ++ assert (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2132. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2133. + }
  2134. + size_t mumble_proto__user_state__pack_to_buffer
  2135. + (const MumbleProto__UserState *message,
  2136. + ProtobufCBuffer *buffer)
  2137. + {
  2138. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2139. ++ assert (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2140. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2141. + }
  2142. + MumbleProto__UserState *
  2143. +@@ -476,7 +476,7 @@
  2144. + (MumbleProto__UserState *message,
  2145. + ProtobufCAllocator *allocator)
  2146. + {
  2147. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2148. ++ assert (message->base.descriptor == &mumble_proto__user_state__descriptor);
  2149. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2150. + }
  2151. + void mumble_proto__ban_list__ban_entry__init
  2152. +@@ -494,21 +494,21 @@
  2153. + size_t mumble_proto__ban_list__get_packed_size
  2154. + (const MumbleProto__BanList *message)
  2155. + {
  2156. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2157. ++ assert (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2158. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2159. + }
  2160. + size_t mumble_proto__ban_list__pack
  2161. + (const MumbleProto__BanList *message,
  2162. + uint8_t *out)
  2163. + {
  2164. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2165. ++ assert (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2166. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2167. + }
  2168. + size_t mumble_proto__ban_list__pack_to_buffer
  2169. + (const MumbleProto__BanList *message,
  2170. + ProtobufCBuffer *buffer)
  2171. + {
  2172. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2173. ++ assert (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2174. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2175. + }
  2176. + MumbleProto__BanList *
  2177. +@@ -525,7 +525,7 @@
  2178. + (MumbleProto__BanList *message,
  2179. + ProtobufCAllocator *allocator)
  2180. + {
  2181. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2182. ++ assert (message->base.descriptor == &mumble_proto__ban_list__descriptor);
  2183. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2184. + }
  2185. + void mumble_proto__text_message__init
  2186. +@@ -537,21 +537,21 @@
  2187. + size_t mumble_proto__text_message__get_packed_size
  2188. + (const MumbleProto__TextMessage *message)
  2189. + {
  2190. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2191. ++ assert (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2192. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2193. + }
  2194. + size_t mumble_proto__text_message__pack
  2195. + (const MumbleProto__TextMessage *message,
  2196. + uint8_t *out)
  2197. + {
  2198. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2199. ++ assert (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2200. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2201. + }
  2202. + size_t mumble_proto__text_message__pack_to_buffer
  2203. + (const MumbleProto__TextMessage *message,
  2204. + ProtobufCBuffer *buffer)
  2205. + {
  2206. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2207. ++ assert (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2208. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2209. + }
  2210. + MumbleProto__TextMessage *
  2211. +@@ -568,7 +568,7 @@
  2212. + (MumbleProto__TextMessage *message,
  2213. + ProtobufCAllocator *allocator)
  2214. + {
  2215. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2216. ++ assert (message->base.descriptor == &mumble_proto__text_message__descriptor);
  2217. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2218. + }
  2219. + void mumble_proto__permission_denied__init
  2220. +@@ -580,21 +580,21 @@
  2221. + size_t mumble_proto__permission_denied__get_packed_size
  2222. + (const MumbleProto__PermissionDenied *message)
  2223. + {
  2224. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2225. ++ assert (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2226. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2227. + }
  2228. + size_t mumble_proto__permission_denied__pack
  2229. + (const MumbleProto__PermissionDenied *message,
  2230. + uint8_t *out)
  2231. + {
  2232. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2233. ++ assert (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2234. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2235. + }
  2236. + size_t mumble_proto__permission_denied__pack_to_buffer
  2237. + (const MumbleProto__PermissionDenied *message,
  2238. + ProtobufCBuffer *buffer)
  2239. + {
  2240. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2241. ++ assert (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2242. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2243. + }
  2244. + MumbleProto__PermissionDenied *
  2245. +@@ -611,7 +611,7 @@
  2246. + (MumbleProto__PermissionDenied *message,
  2247. + ProtobufCAllocator *allocator)
  2248. + {
  2249. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2250. ++ assert (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
  2251. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2252. + }
  2253. + void mumble_proto__acl__chan_group__init
  2254. +@@ -635,21 +635,21 @@
  2255. + size_t mumble_proto__acl__get_packed_size
  2256. + (const MumbleProto__ACL *message)
  2257. + {
  2258. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
  2259. ++ assert (message->base.descriptor == &mumble_proto__acl__descriptor);
  2260. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2261. + }
  2262. + size_t mumble_proto__acl__pack
  2263. + (const MumbleProto__ACL *message,
  2264. + uint8_t *out)
  2265. + {
  2266. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
  2267. ++ assert (message->base.descriptor == &mumble_proto__acl__descriptor);
  2268. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2269. + }
  2270. + size_t mumble_proto__acl__pack_to_buffer
  2271. + (const MumbleProto__ACL *message,
  2272. + ProtobufCBuffer *buffer)
  2273. + {
  2274. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
  2275. ++ assert (message->base.descriptor == &mumble_proto__acl__descriptor);
  2276. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2277. + }
  2278. + MumbleProto__ACL *
  2279. +@@ -666,7 +666,7 @@
  2280. + (MumbleProto__ACL *message,
  2281. + ProtobufCAllocator *allocator)
  2282. + {
  2283. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
  2284. ++ assert (message->base.descriptor == &mumble_proto__acl__descriptor);
  2285. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2286. + }
  2287. + void mumble_proto__query_users__init
  2288. +@@ -678,21 +678,21 @@
  2289. + size_t mumble_proto__query_users__get_packed_size
  2290. + (const MumbleProto__QueryUsers *message)
  2291. + {
  2292. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2293. ++ assert (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2294. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2295. + }
  2296. + size_t mumble_proto__query_users__pack
  2297. + (const MumbleProto__QueryUsers *message,
  2298. + uint8_t *out)
  2299. + {
  2300. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2301. ++ assert (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2302. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2303. + }
  2304. + size_t mumble_proto__query_users__pack_to_buffer
  2305. + (const MumbleProto__QueryUsers *message,
  2306. + ProtobufCBuffer *buffer)
  2307. + {
  2308. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2309. ++ assert (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2310. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2311. + }
  2312. + MumbleProto__QueryUsers *
  2313. +@@ -709,7 +709,7 @@
  2314. + (MumbleProto__QueryUsers *message,
  2315. + ProtobufCAllocator *allocator)
  2316. + {
  2317. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2318. ++ assert (message->base.descriptor == &mumble_proto__query_users__descriptor);
  2319. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2320. + }
  2321. + void mumble_proto__crypt_setup__init
  2322. +@@ -721,21 +721,21 @@
  2323. + size_t mumble_proto__crypt_setup__get_packed_size
  2324. + (const MumbleProto__CryptSetup *message)
  2325. + {
  2326. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2327. ++ assert (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2328. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2329. + }
  2330. + size_t mumble_proto__crypt_setup__pack
  2331. + (const MumbleProto__CryptSetup *message,
  2332. + uint8_t *out)
  2333. + {
  2334. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2335. ++ assert (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2336. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2337. + }
  2338. + size_t mumble_proto__crypt_setup__pack_to_buffer
  2339. + (const MumbleProto__CryptSetup *message,
  2340. + ProtobufCBuffer *buffer)
  2341. + {
  2342. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2343. ++ assert (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2344. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2345. + }
  2346. + MumbleProto__CryptSetup *
  2347. +@@ -752,7 +752,7 @@
  2348. + (MumbleProto__CryptSetup *message,
  2349. + ProtobufCAllocator *allocator)
  2350. + {
  2351. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2352. ++ assert (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
  2353. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2354. + }
  2355. + void mumble_proto__context_action_modify__init
  2356. +@@ -764,21 +764,21 @@
  2357. + size_t mumble_proto__context_action_modify__get_packed_size
  2358. + (const MumbleProto__ContextActionModify *message)
  2359. + {
  2360. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2361. ++ assert (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2362. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2363. + }
  2364. + size_t mumble_proto__context_action_modify__pack
  2365. + (const MumbleProto__ContextActionModify *message,
  2366. + uint8_t *out)
  2367. + {
  2368. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2369. ++ assert (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2370. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2371. + }
  2372. + size_t mumble_proto__context_action_modify__pack_to_buffer
  2373. + (const MumbleProto__ContextActionModify *message,
  2374. + ProtobufCBuffer *buffer)
  2375. + {
  2376. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2377. ++ assert (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2378. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2379. + }
  2380. + MumbleProto__ContextActionModify *
  2381. +@@ -795,7 +795,7 @@
  2382. + (MumbleProto__ContextActionModify *message,
  2383. + ProtobufCAllocator *allocator)
  2384. + {
  2385. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2386. ++ assert (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
  2387. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2388. + }
  2389. + void mumble_proto__context_action__init
  2390. +@@ -807,21 +807,21 @@
  2391. + size_t mumble_proto__context_action__get_packed_size
  2392. + (const MumbleProto__ContextAction *message)
  2393. + {
  2394. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2395. ++ assert (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2396. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2397. + }
  2398. + size_t mumble_proto__context_action__pack
  2399. + (const MumbleProto__ContextAction *message,
  2400. + uint8_t *out)
  2401. + {
  2402. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2403. ++ assert (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2404. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2405. + }
  2406. + size_t mumble_proto__context_action__pack_to_buffer
  2407. + (const MumbleProto__ContextAction *message,
  2408. + ProtobufCBuffer *buffer)
  2409. + {
  2410. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2411. ++ assert (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2412. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2413. + }
  2414. + MumbleProto__ContextAction *
  2415. +@@ -838,7 +838,7 @@
  2416. + (MumbleProto__ContextAction *message,
  2417. + ProtobufCAllocator *allocator)
  2418. + {
  2419. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2420. ++ assert (message->base.descriptor == &mumble_proto__context_action__descriptor);
  2421. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2422. + }
  2423. + void mumble_proto__user_list__user__init
  2424. +@@ -856,21 +856,21 @@
  2425. + size_t mumble_proto__user_list__get_packed_size
  2426. + (const MumbleProto__UserList *message)
  2427. + {
  2428. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2429. ++ assert (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2430. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2431. + }
  2432. + size_t mumble_proto__user_list__pack
  2433. + (const MumbleProto__UserList *message,
  2434. + uint8_t *out)
  2435. + {
  2436. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2437. ++ assert (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2438. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2439. + }
  2440. + size_t mumble_proto__user_list__pack_to_buffer
  2441. + (const MumbleProto__UserList *message,
  2442. + ProtobufCBuffer *buffer)
  2443. + {
  2444. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2445. ++ assert (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2446. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2447. + }
  2448. + MumbleProto__UserList *
  2449. +@@ -887,7 +887,7 @@
  2450. + (MumbleProto__UserList *message,
  2451. + ProtobufCAllocator *allocator)
  2452. + {
  2453. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2454. ++ assert (message->base.descriptor == &mumble_proto__user_list__descriptor);
  2455. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2456. + }
  2457. + void mumble_proto__voice_target__target__init
  2458. +@@ -905,21 +905,21 @@
  2459. + size_t mumble_proto__voice_target__get_packed_size
  2460. + (const MumbleProto__VoiceTarget *message)
  2461. + {
  2462. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2463. ++ assert (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2464. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2465. + }
  2466. + size_t mumble_proto__voice_target__pack
  2467. + (const MumbleProto__VoiceTarget *message,
  2468. + uint8_t *out)
  2469. + {
  2470. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2471. ++ assert (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2472. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2473. + }
  2474. + size_t mumble_proto__voice_target__pack_to_buffer
  2475. + (const MumbleProto__VoiceTarget *message,
  2476. + ProtobufCBuffer *buffer)
  2477. + {
  2478. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2479. ++ assert (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2480. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2481. + }
  2482. + MumbleProto__VoiceTarget *
  2483. +@@ -936,7 +936,7 @@
  2484. + (MumbleProto__VoiceTarget *message,
  2485. + ProtobufCAllocator *allocator)
  2486. + {
  2487. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2488. ++ assert (message->base.descriptor == &mumble_proto__voice_target__descriptor);
  2489. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2490. + }
  2491. + void mumble_proto__permission_query__init
  2492. +@@ -948,21 +948,21 @@
  2493. + size_t mumble_proto__permission_query__get_packed_size
  2494. + (const MumbleProto__PermissionQuery *message)
  2495. + {
  2496. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2497. ++ assert (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2498. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2499. + }
  2500. + size_t mumble_proto__permission_query__pack
  2501. + (const MumbleProto__PermissionQuery *message,
  2502. + uint8_t *out)
  2503. + {
  2504. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2505. ++ assert (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2506. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2507. + }
  2508. + size_t mumble_proto__permission_query__pack_to_buffer
  2509. + (const MumbleProto__PermissionQuery *message,
  2510. + ProtobufCBuffer *buffer)
  2511. + {
  2512. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2513. ++ assert (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2514. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2515. + }
  2516. + MumbleProto__PermissionQuery *
  2517. +@@ -979,7 +979,7 @@
  2518. + (MumbleProto__PermissionQuery *message,
  2519. + ProtobufCAllocator *allocator)
  2520. + {
  2521. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2522. ++ assert (message->base.descriptor == &mumble_proto__permission_query__descriptor);
  2523. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2524. + }
  2525. + void mumble_proto__codec_version__init
  2526. +@@ -991,21 +991,21 @@
  2527. + size_t mumble_proto__codec_version__get_packed_size
  2528. + (const MumbleProto__CodecVersion *message)
  2529. + {
  2530. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2531. ++ assert (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2532. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2533. + }
  2534. + size_t mumble_proto__codec_version__pack
  2535. + (const MumbleProto__CodecVersion *message,
  2536. + uint8_t *out)
  2537. + {
  2538. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2539. ++ assert (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2540. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2541. + }
  2542. + size_t mumble_proto__codec_version__pack_to_buffer
  2543. + (const MumbleProto__CodecVersion *message,
  2544. + ProtobufCBuffer *buffer)
  2545. + {
  2546. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2547. ++ assert (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2548. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2549. + }
  2550. + MumbleProto__CodecVersion *
  2551. +@@ -1022,7 +1022,7 @@
  2552. + (MumbleProto__CodecVersion *message,
  2553. + ProtobufCAllocator *allocator)
  2554. + {
  2555. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2556. ++ assert (message->base.descriptor == &mumble_proto__codec_version__descriptor);
  2557. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2558. + }
  2559. + void mumble_proto__user_stats__stats__init
  2560. +@@ -1040,21 +1040,21 @@
  2561. + size_t mumble_proto__user_stats__get_packed_size
  2562. + (const MumbleProto__UserStats *message)
  2563. + {
  2564. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2565. ++ assert (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2566. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2567. + }
  2568. + size_t mumble_proto__user_stats__pack
  2569. + (const MumbleProto__UserStats *message,
  2570. + uint8_t *out)
  2571. + {
  2572. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2573. ++ assert (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2574. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2575. + }
  2576. + size_t mumble_proto__user_stats__pack_to_buffer
  2577. + (const MumbleProto__UserStats *message,
  2578. + ProtobufCBuffer *buffer)
  2579. + {
  2580. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2581. ++ assert (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2582. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2583. + }
  2584. + MumbleProto__UserStats *
  2585. +@@ -1071,7 +1071,7 @@
  2586. + (MumbleProto__UserStats *message,
  2587. + ProtobufCAllocator *allocator)
  2588. + {
  2589. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2590. ++ assert (message->base.descriptor == &mumble_proto__user_stats__descriptor);
  2591. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2592. + }
  2593. + void mumble_proto__suggest_config__init
  2594. +@@ -1083,21 +1083,21 @@
  2595. + size_t mumble_proto__suggest_config__get_packed_size
  2596. + (const MumbleProto__SuggestConfig *message)
  2597. + {
  2598. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2599. ++ assert (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2600. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2601. + }
  2602. + size_t mumble_proto__suggest_config__pack
  2603. + (const MumbleProto__SuggestConfig *message,
  2604. + uint8_t *out)
  2605. + {
  2606. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2607. ++ assert (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2608. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2609. + }
  2610. + size_t mumble_proto__suggest_config__pack_to_buffer
  2611. + (const MumbleProto__SuggestConfig *message,
  2612. + ProtobufCBuffer *buffer)
  2613. + {
  2614. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2615. ++ assert (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2616. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2617. + }
  2618. + MumbleProto__SuggestConfig *
  2619. +@@ -1114,7 +1114,7 @@
  2620. + (MumbleProto__SuggestConfig *message,
  2621. + ProtobufCAllocator *allocator)
  2622. + {
  2623. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2624. ++ assert (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
  2625. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2626. + }
  2627. + void mumble_proto__request_blob__init
  2628. +@@ -1126,21 +1126,21 @@
  2629. + size_t mumble_proto__request_blob__get_packed_size
  2630. + (const MumbleProto__RequestBlob *message)
  2631. + {
  2632. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2633. ++ assert (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2634. + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  2635. + }
  2636. + size_t mumble_proto__request_blob__pack
  2637. + (const MumbleProto__RequestBlob *message,
  2638. + uint8_t *out)
  2639. + {
  2640. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2641. ++ assert (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2642. + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  2643. + }
  2644. + size_t mumble_proto__request_blob__pack_to_buffer
  2645. + (const MumbleProto__RequestBlob *message,
  2646. + ProtobufCBuffer *buffer)
  2647. + {
  2648. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2649. ++ assert (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2650. + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  2651. + }
  2652. + MumbleProto__RequestBlob *
  2653. +@@ -1157,7 +1157,7 @@
  2654. + (MumbleProto__RequestBlob *message,
  2655. + ProtobufCAllocator *allocator)
  2656. + {
  2657. +- PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2658. ++ assert (message->base.descriptor == &mumble_proto__request_blob__descriptor);
  2659. + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  2660. + }
  2661. + static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!