redrust/
commands.rs

1extern crate c2rust_bitfields;
2extern crate libc;
3extern crate core;
4extern "C" {
5    pub type RedisModuleCommand;
6    pub type clusterSlotToKeyMapping;
7    fn sintercardGetKeys(
8        cmd: *mut redisCommand,
9        argv: *mut *mut robj,
10        argc: libc::c_int,
11        result: *mut getKeysResult,
12    ) -> libc::c_int;
13    fn zunionInterDiffGetKeys(
14        cmd: *mut redisCommand,
15        argv: *mut *mut robj,
16        argc: libc::c_int,
17        result: *mut getKeysResult,
18    ) -> libc::c_int;
19    fn zunionInterDiffStoreGetKeys(
20        cmd: *mut redisCommand,
21        argv: *mut *mut robj,
22        argc: libc::c_int,
23        result: *mut getKeysResult,
24    ) -> libc::c_int;
25    fn evalGetKeys(
26        cmd: *mut redisCommand,
27        argv: *mut *mut robj,
28        argc: libc::c_int,
29        result: *mut getKeysResult,
30    ) -> libc::c_int;
31    fn functionGetKeys(
32        cmd: *mut redisCommand,
33        argv: *mut *mut robj,
34        argc: libc::c_int,
35        result: *mut getKeysResult,
36    ) -> libc::c_int;
37    fn sortGetKeys(
38        cmd: *mut redisCommand,
39        argv: *mut *mut robj,
40        argc: libc::c_int,
41        result: *mut getKeysResult,
42    ) -> libc::c_int;
43    fn sortROGetKeys(
44        cmd: *mut redisCommand,
45        argv: *mut *mut robj,
46        argc: libc::c_int,
47        result: *mut getKeysResult,
48    ) -> libc::c_int;
49    fn migrateGetKeys(
50        cmd: *mut redisCommand,
51        argv: *mut *mut robj,
52        argc: libc::c_int,
53        result: *mut getKeysResult,
54    ) -> libc::c_int;
55    fn georadiusGetKeys(
56        cmd: *mut redisCommand,
57        argv: *mut *mut robj,
58        argc: libc::c_int,
59        result: *mut getKeysResult,
60    ) -> libc::c_int;
61    fn xreadGetKeys(
62        cmd: *mut redisCommand,
63        argv: *mut *mut robj,
64        argc: libc::c_int,
65        result: *mut getKeysResult,
66    ) -> libc::c_int;
67    fn lmpopGetKeys(
68        cmd: *mut redisCommand,
69        argv: *mut *mut robj,
70        argc: libc::c_int,
71        result: *mut getKeysResult,
72    ) -> libc::c_int;
73    fn blmpopGetKeys(
74        cmd: *mut redisCommand,
75        argv: *mut *mut robj,
76        argc: libc::c_int,
77        result: *mut getKeysResult,
78    ) -> libc::c_int;
79    fn zmpopGetKeys(
80        cmd: *mut redisCommand,
81        argv: *mut *mut robj,
82        argc: libc::c_int,
83        result: *mut getKeysResult,
84    ) -> libc::c_int;
85    fn setGetKeys(
86        cmd: *mut redisCommand,
87        argv: *mut *mut robj,
88        argc: libc::c_int,
89        result: *mut getKeysResult,
90    ) -> libc::c_int;
91    fn bitfieldGetKeys(
92        cmd: *mut redisCommand,
93        argv: *mut *mut robj,
94        argc: libc::c_int,
95        result: *mut getKeysResult,
96    ) -> libc::c_int;
97    fn sentinelCommand(c: *mut client);
98    fn authCommand(c: *mut client);
99    fn pingCommand(c: *mut client);
100    fn echoCommand(c: *mut client);
101    fn commandCommand(c: *mut client);
102    fn commandCountCommand(c: *mut client);
103    fn commandListCommand(c: *mut client);
104    fn commandInfoCommand(c: *mut client);
105    fn commandGetKeysCommand(c: *mut client);
106    fn commandGetKeysAndFlagsCommand(c: *mut client);
107    fn commandHelpCommand(c: *mut client);
108    fn commandDocsCommand(c: *mut client);
109    fn setCommand(c: *mut client);
110    fn setnxCommand(c: *mut client);
111    fn setexCommand(c: *mut client);
112    fn psetexCommand(c: *mut client);
113    fn getCommand(c: *mut client);
114    fn getexCommand(c: *mut client);
115    fn getdelCommand(c: *mut client);
116    fn delCommand(c: *mut client);
117    fn unlinkCommand(c: *mut client);
118    fn existsCommand(c: *mut client);
119    fn setbitCommand(c: *mut client);
120    fn getbitCommand(c: *mut client);
121    fn bitfieldCommand(c: *mut client);
122    fn bitfieldroCommand(c: *mut client);
123    fn setrangeCommand(c: *mut client);
124    fn getrangeCommand(c: *mut client);
125    fn incrCommand(c: *mut client);
126    fn decrCommand(c: *mut client);
127    fn incrbyCommand(c: *mut client);
128    fn decrbyCommand(c: *mut client);
129    fn incrbyfloatCommand(c: *mut client);
130    fn selectCommand(c: *mut client);
131    fn swapdbCommand(c: *mut client);
132    fn randomkeyCommand(c: *mut client);
133    fn keysCommand(c: *mut client);
134    fn scanCommand(c: *mut client);
135    fn dbsizeCommand(c: *mut client);
136    fn lastsaveCommand(c: *mut client);
137    fn saveCommand(c: *mut client);
138    fn bgsaveCommand(c: *mut client);
139    fn bgrewriteaofCommand(c: *mut client);
140    fn shutdownCommand(c: *mut client);
141    fn slowlogCommand(c: *mut client);
142    fn moveCommand(c: *mut client);
143    fn copyCommand(c: *mut client);
144    fn renameCommand(c: *mut client);
145    fn renamenxCommand(c: *mut client);
146    fn lpushCommand(c: *mut client);
147    fn rpushCommand(c: *mut client);
148    fn lpushxCommand(c: *mut client);
149    fn rpushxCommand(c: *mut client);
150    fn linsertCommand(c: *mut client);
151    fn lpopCommand(c: *mut client);
152    fn rpopCommand(c: *mut client);
153    fn lmpopCommand(c: *mut client);
154    fn llenCommand(c: *mut client);
155    fn lindexCommand(c: *mut client);
156    fn lrangeCommand(c: *mut client);
157    fn ltrimCommand(c: *mut client);
158    fn typeCommand(c: *mut client);
159    fn lsetCommand(c: *mut client);
160    fn saddCommand(c: *mut client);
161    fn sremCommand(c: *mut client);
162    fn smoveCommand(c: *mut client);
163    fn sismemberCommand(c: *mut client);
164    fn smismemberCommand(c: *mut client);
165    fn scardCommand(c: *mut client);
166    fn spopCommand(c: *mut client);
167    fn srandmemberCommand(c: *mut client);
168    fn sinterCommand(c: *mut client);
169    fn sinterCardCommand(c: *mut client);
170    fn sinterstoreCommand(c: *mut client);
171    fn sunionCommand(c: *mut client);
172    fn sunionstoreCommand(c: *mut client);
173    fn sdiffCommand(c: *mut client);
174    fn sdiffstoreCommand(c: *mut client);
175    fn sscanCommand(c: *mut client);
176    fn syncCommand(c: *mut client);
177    fn flushdbCommand(c: *mut client);
178    fn flushallCommand(c: *mut client);
179    fn sortCommand(c: *mut client);
180    fn sortroCommand(c: *mut client);
181    fn lremCommand(c: *mut client);
182    fn lposCommand(c: *mut client);
183    fn rpoplpushCommand(c: *mut client);
184    fn lmoveCommand(c: *mut client);
185    fn infoCommand(c: *mut client);
186    fn mgetCommand(c: *mut client);
187    fn monitorCommand(c: *mut client);
188    fn expireCommand(c: *mut client);
189    fn expireatCommand(c: *mut client);
190    fn pexpireCommand(c: *mut client);
191    fn pexpireatCommand(c: *mut client);
192    fn getsetCommand(c: *mut client);
193    fn ttlCommand(c: *mut client);
194    fn touchCommand(c: *mut client);
195    fn pttlCommand(c: *mut client);
196    fn expiretimeCommand(c: *mut client);
197    fn pexpiretimeCommand(c: *mut client);
198    fn persistCommand(c: *mut client);
199    fn replicaofCommand(c: *mut client);
200    fn roleCommand(c: *mut client);
201    fn debugCommand(c: *mut client);
202    fn msetCommand(c: *mut client);
203    fn msetnxCommand(c: *mut client);
204    fn zaddCommand(c: *mut client);
205    fn zincrbyCommand(c: *mut client);
206    fn zrangeCommand(c: *mut client);
207    fn zrangebyscoreCommand(c: *mut client);
208    fn zrevrangebyscoreCommand(c: *mut client);
209    fn zrangebylexCommand(c: *mut client);
210    fn zrevrangebylexCommand(c: *mut client);
211    fn zcountCommand(c: *mut client);
212    fn zlexcountCommand(c: *mut client);
213    fn zrevrangeCommand(c: *mut client);
214    fn zcardCommand(c: *mut client);
215    fn zremCommand(c: *mut client);
216    fn zscoreCommand(c: *mut client);
217    fn zmscoreCommand(c: *mut client);
218    fn zremrangebyscoreCommand(c: *mut client);
219    fn zremrangebylexCommand(c: *mut client);
220    fn zpopminCommand(c: *mut client);
221    fn zpopmaxCommand(c: *mut client);
222    fn zmpopCommand(c: *mut client);
223    fn bzpopminCommand(c: *mut client);
224    fn bzpopmaxCommand(c: *mut client);
225    fn bzmpopCommand(c: *mut client);
226    fn zrandmemberCommand(c: *mut client);
227    fn multiCommand(c: *mut client);
228    fn execCommand(c: *mut client);
229    fn discardCommand(c: *mut client);
230    fn blpopCommand(c: *mut client);
231    fn brpopCommand(c: *mut client);
232    fn blmpopCommand(c: *mut client);
233    fn brpoplpushCommand(c: *mut client);
234    fn blmoveCommand(c: *mut client);
235    fn appendCommand(c: *mut client);
236    fn strlenCommand(c: *mut client);
237    fn zrankCommand(c: *mut client);
238    fn zrevrankCommand(c: *mut client);
239    fn hsetCommand(c: *mut client);
240    fn hsetnxCommand(c: *mut client);
241    fn hgetCommand(c: *mut client);
242    fn hmgetCommand(c: *mut client);
243    fn hdelCommand(c: *mut client);
244    fn hlenCommand(c: *mut client);
245    fn hstrlenCommand(c: *mut client);
246    fn zremrangebyrankCommand(c: *mut client);
247    fn zunionstoreCommand(c: *mut client);
248    fn zinterstoreCommand(c: *mut client);
249    fn zdiffstoreCommand(c: *mut client);
250    fn zunionCommand(c: *mut client);
251    fn zinterCommand(c: *mut client);
252    fn zinterCardCommand(c: *mut client);
253    fn zrangestoreCommand(c: *mut client);
254    fn zdiffCommand(c: *mut client);
255    fn zscanCommand(c: *mut client);
256    fn hkeysCommand(c: *mut client);
257    fn hvalsCommand(c: *mut client);
258    fn hgetallCommand(c: *mut client);
259    fn hexistsCommand(c: *mut client);
260    fn hscanCommand(c: *mut client);
261    fn hrandfieldCommand(c: *mut client);
262    fn configSetCommand(c: *mut client);
263    fn configGetCommand(c: *mut client);
264    fn configResetStatCommand(c: *mut client);
265    fn configRewriteCommand(c: *mut client);
266    fn configHelpCommand(c: *mut client);
267    fn hincrbyCommand(c: *mut client);
268    fn hincrbyfloatCommand(c: *mut client);
269    fn subscribeCommand(c: *mut client);
270    fn unsubscribeCommand(c: *mut client);
271    fn psubscribeCommand(c: *mut client);
272    fn punsubscribeCommand(c: *mut client);
273    fn publishCommand(c: *mut client);
274    fn pubsubCommand(c: *mut client);
275    fn spublishCommand(c: *mut client);
276    fn ssubscribeCommand(c: *mut client);
277    fn sunsubscribeCommand(c: *mut client);
278    fn watchCommand(c: *mut client);
279    fn unwatchCommand(c: *mut client);
280    fn clusterCommand(c: *mut client);
281    fn restoreCommand(c: *mut client);
282    fn migrateCommand(c: *mut client);
283    fn askingCommand(c: *mut client);
284    fn readonlyCommand(c: *mut client);
285    fn readwriteCommand(c: *mut client);
286    fn dumpCommand(c: *mut client);
287    fn objectCommand(c: *mut client);
288    fn memoryCommand(c: *mut client);
289    fn clientCommand(c: *mut client);
290    fn helloCommand(c: *mut client);
291    fn evalCommand(c: *mut client);
292    fn evalRoCommand(c: *mut client);
293    fn evalShaCommand(c: *mut client);
294    fn evalShaRoCommand(c: *mut client);
295    fn scriptCommand(c: *mut client);
296    fn fcallCommand(c: *mut client);
297    fn fcallroCommand(c: *mut client);
298    fn functionLoadCommand(c: *mut client);
299    fn functionDeleteCommand(c: *mut client);
300    fn functionKillCommand(c: *mut client);
301    fn functionStatsCommand(c: *mut client);
302    fn functionListCommand(c: *mut client);
303    fn functionHelpCommand(c: *mut client);
304    fn functionFlushCommand(c: *mut client);
305    fn functionRestoreCommand(c: *mut client);
306    fn functionDumpCommand(c: *mut client);
307    fn timeCommand(c: *mut client);
308    fn bitopCommand(c: *mut client);
309    fn bitcountCommand(c: *mut client);
310    fn bitposCommand(c: *mut client);
311    fn replconfCommand(c: *mut client);
312    fn waitCommand(c: *mut client);
313    fn georadiusbymemberCommand(c: *mut client);
314    fn georadiusbymemberroCommand(c: *mut client);
315    fn georadiusCommand(c: *mut client);
316    fn georadiusroCommand(c: *mut client);
317    fn geoaddCommand(c: *mut client);
318    fn geohashCommand(c: *mut client);
319    fn geoposCommand(c: *mut client);
320    fn geodistCommand(c: *mut client);
321    fn geosearchCommand(c: *mut client);
322    fn geosearchstoreCommand(c: *mut client);
323    fn pfselftestCommand(c: *mut client);
324    fn pfaddCommand(c: *mut client);
325    fn pfcountCommand(c: *mut client);
326    fn pfmergeCommand(c: *mut client);
327    fn pfdebugCommand(c: *mut client);
328    fn latencyCommand(c: *mut client);
329    fn moduleCommand(c: *mut client);
330    fn xaddCommand(c: *mut client);
331    fn xrangeCommand(c: *mut client);
332    fn xrevrangeCommand(c: *mut client);
333    fn xlenCommand(c: *mut client);
334    fn xreadCommand(c: *mut client);
335    fn xgroupCommand(c: *mut client);
336    fn xsetidCommand(c: *mut client);
337    fn xackCommand(c: *mut client);
338    fn xpendingCommand(c: *mut client);
339    fn xclaimCommand(c: *mut client);
340    fn xautoclaimCommand(c: *mut client);
341    fn xinfoCommand(c: *mut client);
342    fn xdelCommand(c: *mut client);
343    fn xtrimCommand(c: *mut client);
344    fn lolwutCommand(c: *mut client);
345    fn aclCommand(c: *mut client);
346    fn lcsCommand(c: *mut client);
347    fn quitCommand(c: *mut client);
348    fn resetCommand(c: *mut client);
349    fn failoverCommand(c: *mut client);
350}
351pub type __int16_t = libc::c_short;
352pub type __int32_t = libc::c_int;
353pub type __uint32_t = libc::c_uint;
354pub type __int64_t = libc::c_long;
355pub type __uint64_t = libc::c_ulong;
356pub type __off64_t = libc::c_long;
357pub type __time_t = libc::c_long;
358pub type __ssize_t = libc::c_long;
359pub type size_t = libc::c_ulong;
360#[derive(Copy, Clone)]
361#[repr(C)]
362pub struct iovec {
363    pub iov_base: *mut libc::c_void,
364    pub iov_len: size_t,
365}
366pub type off_t = __off64_t;
367pub type ssize_t = __ssize_t;
368pub type time_t = __time_t;
369pub type int16_t = __int16_t;
370pub type int32_t = __int32_t;
371pub type int64_t = __int64_t;
372pub type uint32_t = __uint32_t;
373pub type uint64_t = __uint64_t;
374pub type sds = *mut libc::c_char;
375#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct aeEventLoop {
378    pub maxfd: libc::c_int,
379    pub setsize: libc::c_int,
380    pub timeEventNextId: libc::c_longlong,
381    pub events: *mut aeFileEvent,
382    pub fired: *mut aeFiredEvent,
383    pub timeEventHead: *mut aeTimeEvent,
384    pub stop: libc::c_int,
385    pub apidata: *mut libc::c_void,
386    pub beforesleep: Option::<aeBeforeSleepProc>,
387    pub aftersleep: Option::<aeBeforeSleepProc>,
388    pub flags: libc::c_int,
389}
390pub type aeBeforeSleepProc = unsafe extern "C" fn(*mut aeEventLoop) -> ();
391#[derive(Copy, Clone)]
392#[repr(C)]
393pub struct aeTimeEvent {
394    pub id: libc::c_longlong,
395    pub when: monotime,
396    pub timeProc: Option::<aeTimeProc>,
397    pub finalizerProc: Option::<aeEventFinalizerProc>,
398    pub clientData: *mut libc::c_void,
399    pub prev: *mut aeTimeEvent,
400    pub next: *mut aeTimeEvent,
401    pub refcount: libc::c_int,
402}
403pub type aeEventFinalizerProc = unsafe extern "C" fn(
404    *mut aeEventLoop,
405    *mut libc::c_void,
406) -> ();
407pub type aeTimeProc = unsafe extern "C" fn(
408    *mut aeEventLoop,
409    libc::c_longlong,
410    *mut libc::c_void,
411) -> libc::c_int;
412pub type monotime = uint64_t;
413#[derive(Copy, Clone)]
414#[repr(C)]
415pub struct aeFiredEvent {
416    pub fd: libc::c_int,
417    pub mask: libc::c_int,
418}
419#[derive(Copy, Clone)]
420#[repr(C)]
421pub struct aeFileEvent {
422    pub mask: libc::c_int,
423    pub rfileProc: Option::<aeFileProc>,
424    pub wfileProc: Option::<aeFileProc>,
425    pub clientData: *mut libc::c_void,
426}
427pub type aeFileProc = unsafe extern "C" fn(
428    *mut aeEventLoop,
429    libc::c_int,
430    *mut libc::c_void,
431    libc::c_int,
432) -> ();
433#[derive(Copy, Clone)]
434#[repr(C)]
435pub struct connection {
436    pub type_0: *mut ConnectionType,
437    pub state: ConnectionState,
438    pub flags: libc::c_short,
439    pub refs: libc::c_short,
440    pub last_errno: libc::c_int,
441    pub private_data: *mut libc::c_void,
442    pub conn_handler: ConnectionCallbackFunc,
443    pub write_handler: ConnectionCallbackFunc,
444    pub read_handler: ConnectionCallbackFunc,
445    pub fd: libc::c_int,
446}
447pub type ConnectionCallbackFunc = Option::<unsafe extern "C" fn(*mut connection) -> ()>;
448pub type ConnectionState = libc::c_uint;
449pub const CONN_STATE_ERROR: ConnectionState = 5;
450pub const CONN_STATE_CLOSED: ConnectionState = 4;
451pub const CONN_STATE_CONNECTED: ConnectionState = 3;
452pub const CONN_STATE_ACCEPTING: ConnectionState = 2;
453pub const CONN_STATE_CONNECTING: ConnectionState = 1;
454pub const CONN_STATE_NONE: ConnectionState = 0;
455#[derive(Copy, Clone)]
456#[repr(C)]
457pub struct ConnectionType {
458    pub ae_handler: Option::<
459        unsafe extern "C" fn(
460            *mut aeEventLoop,
461            libc::c_int,
462            *mut libc::c_void,
463            libc::c_int,
464        ) -> (),
465    >,
466    pub connect: Option::<
467        unsafe extern "C" fn(
468            *mut connection,
469            *const libc::c_char,
470            libc::c_int,
471            *const libc::c_char,
472            ConnectionCallbackFunc,
473        ) -> libc::c_int,
474    >,
475    pub write: Option::<
476        unsafe extern "C" fn(*mut connection, *const libc::c_void, size_t) -> libc::c_int,
477    >,
478    pub writev: Option::<
479        unsafe extern "C" fn(*mut connection, *const iovec, libc::c_int) -> libc::c_int,
480    >,
481    pub read: Option::<
482        unsafe extern "C" fn(*mut connection, *mut libc::c_void, size_t) -> libc::c_int,
483    >,
484    pub close: Option::<unsafe extern "C" fn(*mut connection) -> ()>,
485    pub accept: Option::<
486        unsafe extern "C" fn(*mut connection, ConnectionCallbackFunc) -> libc::c_int,
487    >,
488    pub set_write_handler: Option::<
489        unsafe extern "C" fn(
490            *mut connection,
491            ConnectionCallbackFunc,
492            libc::c_int,
493        ) -> libc::c_int,
494    >,
495    pub set_read_handler: Option::<
496        unsafe extern "C" fn(*mut connection, ConnectionCallbackFunc) -> libc::c_int,
497    >,
498    pub get_last_error: Option::<
499        unsafe extern "C" fn(*mut connection) -> *const libc::c_char,
500    >,
501    pub blocking_connect: Option::<
502        unsafe extern "C" fn(
503            *mut connection,
504            *const libc::c_char,
505            libc::c_int,
506            libc::c_longlong,
507        ) -> libc::c_int,
508    >,
509    pub sync_write: Option::<
510        unsafe extern "C" fn(
511            *mut connection,
512            *mut libc::c_char,
513            ssize_t,
514            libc::c_longlong,
515        ) -> ssize_t,
516    >,
517    pub sync_read: Option::<
518        unsafe extern "C" fn(
519            *mut connection,
520            *mut libc::c_char,
521            ssize_t,
522            libc::c_longlong,
523        ) -> ssize_t,
524    >,
525    pub sync_readline: Option::<
526        unsafe extern "C" fn(
527            *mut connection,
528            *mut libc::c_char,
529            ssize_t,
530            libc::c_longlong,
531        ) -> ssize_t,
532    >,
533    pub get_type: Option::<unsafe extern "C" fn(*mut connection) -> libc::c_int>,
534}
535#[derive(Copy, Clone,c2rust_bitfields::BitfieldStruct)]
536#[repr(C)]
537pub struct redisObject {
538    #[bitfield(name = "type_0", ty = "libc::c_uint", bits = "0..=3")]
539    #[bitfield(name = "encoding", ty = "libc::c_uint", bits = "4..=7")]
540    #[bitfield(name = "lru", ty = "libc::c_uint", bits = "8..=31")]
541    pub type_0_encoding_lru: [u8; 4],
542    pub refcount: libc::c_int,
543    pub ptr: *mut libc::c_void,
544}
545#[derive(Copy, Clone)]
546#[repr(C)]
547pub struct hdr_histogram {
548    pub lowest_discernible_value: int64_t,
549    pub highest_trackable_value: int64_t,
550    pub unit_magnitude: int32_t,
551    pub significant_figures: int32_t,
552    pub sub_bucket_half_count_magnitude: int32_t,
553    pub sub_bucket_half_count: int32_t,
554    pub sub_bucket_mask: int64_t,
555    pub sub_bucket_count: int32_t,
556    pub bucket_count: int32_t,
557    pub min_value: int64_t,
558    pub max_value: int64_t,
559    pub normalizing_index_offset: int32_t,
560    pub conversion_ratio: libc::c_double,
561    pub counts_len: int32_t,
562    pub total_count: int64_t,
563    pub counts: *mut int64_t,
564}
565pub type mstime_t = libc::c_longlong;
566#[derive(Copy, Clone)]
567#[repr(C)]
568pub struct dictEntry {
569    pub key: *mut libc::c_void,
570    pub v: C2RustUnnamed,
571    pub next: *mut dictEntry,
572    pub metadata: [*mut libc::c_void; 0],
573}
574#[derive(Copy, Clone)]
575#[repr(C)]
576pub union C2RustUnnamed {
577    pub val: *mut libc::c_void,
578    pub u64_0: uint64_t,
579    pub s64: int64_t,
580    pub d: libc::c_double,
581}
582#[derive(Copy, Clone)]
583#[repr(C)]
584pub struct dict {
585    pub type_0: *mut dictType,
586    pub ht_table: [*mut *mut dictEntry; 2],
587    pub ht_used: [libc::c_ulong; 2],
588    pub rehashidx: libc::c_long,
589    pub pauserehash: int16_t,
590    pub ht_size_exp: [libc::c_schar; 2],
591}
592#[derive(Copy, Clone)]
593#[repr(C)]
594pub struct dictType {
595    pub hashFunction: Option::<unsafe extern "C" fn(*const libc::c_void) -> uint64_t>,
596    pub keyDup: Option::<
597        unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
598    >,
599    pub valDup: Option::<
600        unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
601    >,
602    pub keyCompare: Option::<
603        unsafe extern "C" fn(
604            *mut dict,
605            *const libc::c_void,
606            *const libc::c_void,
607        ) -> libc::c_int,
608    >,
609    pub keyDestructor: Option::<
610        unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
611    >,
612    pub valDestructor: Option::<
613        unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
614    >,
615    pub expandAllowed: Option::<
616        unsafe extern "C" fn(size_t, libc::c_double) -> libc::c_int,
617    >,
618    pub dictEntryMetadataBytes: Option::<unsafe extern "C" fn(*mut dict) -> size_t>,
619}
620#[derive(Copy, Clone)]
621#[repr(C)]
622pub struct listNode {
623    pub prev: *mut listNode,
624    pub next: *mut listNode,
625    pub value: *mut libc::c_void,
626}
627#[derive(Copy, Clone)]
628#[repr(C)]
629pub struct list {
630    pub head: *mut listNode,
631    pub tail: *mut listNode,
632    pub dup: Option::<unsafe extern "C" fn(*mut libc::c_void) -> *mut libc::c_void>,
633    pub free: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
634    pub match_0: Option::<
635        unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> libc::c_int,
636    >,
637    pub len: libc::c_ulong,
638}
639#[derive(Copy, Clone,c2rust_bitfields::BitfieldStruct)]
640#[repr(C)]
641pub struct raxNode {
642    #[bitfield(name = "iskey", ty = "uint32_t", bits = "0..=0")]
643    #[bitfield(name = "isnull", ty = "uint32_t", bits = "1..=1")]
644    #[bitfield(name = "iscompr", ty = "uint32_t", bits = "2..=2")]
645    #[bitfield(name = "size", ty = "uint32_t", bits = "3..=31")]
646    pub iskey_isnull_iscompr_size: [u8; 4],
647    pub data: [libc::c_uchar; 0],
648}
649#[derive(Copy, Clone)]
650#[repr(C)]
651pub struct rax {
652    pub head: *mut raxNode,
653    pub numele: uint64_t,
654    pub numnodes: uint64_t,
655}
656pub type robj = redisObject;
657pub type RedisModuleUserChangedFunc = Option::<
658    unsafe extern "C" fn(uint64_t, *mut libc::c_void) -> (),
659>;
660#[derive(Copy, Clone)]
661#[repr(C)]
662pub struct redisDb {
663    pub dict: *mut dict,
664    pub expires: *mut dict,
665    pub blocking_keys: *mut dict,
666    pub ready_keys: *mut dict,
667    pub watched_keys: *mut dict,
668    pub id: libc::c_int,
669    pub avg_ttl: libc::c_longlong,
670    pub expires_cursor: libc::c_ulong,
671    pub defrag_later: *mut list,
672    pub slots_to_keys: *mut clusterSlotToKeyMapping,
673}
674#[derive(Copy, Clone)]
675#[repr(C)]
676pub struct multiCmd {
677    pub argv: *mut *mut robj,
678    pub argv_len: libc::c_int,
679    pub argc: libc::c_int,
680    pub cmd: *mut redisCommand,
681}
682#[derive(Copy, Clone)]
683#[repr(C)]
684pub struct redisCommand {
685    pub declared_name: *const libc::c_char,
686    pub summary: *const libc::c_char,
687    pub complexity: *const libc::c_char,
688    pub since: *const libc::c_char,
689    pub doc_flags: libc::c_int,
690    pub replaced_by: *const libc::c_char,
691    pub deprecated_since: *const libc::c_char,
692    pub group: redisCommandGroup,
693    pub history: *mut commandHistory,
694    pub tips: *mut *const libc::c_char,
695    pub proc_0: Option::<redisCommandProc>,
696    pub arity: libc::c_int,
697    pub flags: uint64_t,
698    pub acl_categories: uint64_t,
699    pub key_specs_static: [keySpec; 4],
700    pub getkeys_proc: Option::<redisGetKeysProc>,
701    pub subcommands: *mut redisCommand,
702    pub args: *mut redisCommandArg,
703    pub microseconds: libc::c_longlong,
704    pub calls: libc::c_longlong,
705    pub rejected_calls: libc::c_longlong,
706    pub failed_calls: libc::c_longlong,
707    pub id: libc::c_int,
708    pub fullname: sds,
709    pub latency_histogram: *mut hdr_histogram,
710    pub key_specs: *mut keySpec,
711    pub legacy_range_key_spec: keySpec,
712    pub num_args: libc::c_int,
713    pub num_history: libc::c_int,
714    pub num_tips: libc::c_int,
715    pub key_specs_num: libc::c_int,
716    pub key_specs_max: libc::c_int,
717    pub subcommands_dict: *mut dict,
718    pub parent: *mut redisCommand,
719    pub module_cmd: *mut RedisModuleCommand,
720}
721#[derive(Copy, Clone)]
722#[repr(C)]
723pub struct keySpec {
724    pub notes: *const libc::c_char,
725    pub flags: uint64_t,
726    pub begin_search_type: kspec_bs_type,
727    pub bs: C2RustUnnamed_3,
728    pub find_keys_type: kspec_fk_type,
729    pub fk: C2RustUnnamed_0,
730}
731#[derive(Copy, Clone)]
732#[repr(C)]
733pub union C2RustUnnamed_0 {
734    pub range: C2RustUnnamed_2,
735    pub keynum: C2RustUnnamed_1,
736}
737#[derive(Copy, Clone)]
738#[repr(C)]
739pub struct C2RustUnnamed_1 {
740    pub keynumidx: libc::c_int,
741    pub firstkey: libc::c_int,
742    pub keystep: libc::c_int,
743}
744#[derive(Copy, Clone)]
745#[repr(C)]
746pub struct C2RustUnnamed_2 {
747    pub lastkey: libc::c_int,
748    pub keystep: libc::c_int,
749    pub limit: libc::c_int,
750}
751pub type kspec_fk_type = libc::c_uint;
752pub const KSPEC_FK_KEYNUM: kspec_fk_type = 3;
753pub const KSPEC_FK_RANGE: kspec_fk_type = 2;
754pub const KSPEC_FK_UNKNOWN: kspec_fk_type = 1;
755pub const KSPEC_FK_INVALID: kspec_fk_type = 0;
756#[derive(Copy, Clone)]
757#[repr(C)]
758pub union C2RustUnnamed_3 {
759    pub index: C2RustUnnamed_5,
760    pub keyword: C2RustUnnamed_4,
761}
762#[derive(Copy, Clone)]
763#[repr(C)]
764pub struct C2RustUnnamed_4 {
765    pub keyword: *const libc::c_char,
766    pub startfrom: libc::c_int,
767}
768#[derive(Copy, Clone)]
769#[repr(C)]
770pub struct C2RustUnnamed_5 {
771    pub pos: libc::c_int,
772}
773pub type kspec_bs_type = libc::c_uint;
774pub const KSPEC_BS_KEYWORD: kspec_bs_type = 3;
775pub const KSPEC_BS_INDEX: kspec_bs_type = 2;
776pub const KSPEC_BS_UNKNOWN: kspec_bs_type = 1;
777pub const KSPEC_BS_INVALID: kspec_bs_type = 0;
778#[derive(Copy, Clone)]
779#[repr(C)]
780pub struct redisCommandArg {
781    pub name: *const libc::c_char,
782    pub type_0: redisCommandArgType,
783    pub key_spec_index: libc::c_int,
784    pub token: *const libc::c_char,
785    pub summary: *const libc::c_char,
786    pub since: *const libc::c_char,
787    pub flags: libc::c_int,
788    pub deprecated_since: *const libc::c_char,
789    pub subargs: *mut redisCommandArg,
790    pub num_args: libc::c_int,
791}
792pub type redisCommandArgType = libc::c_uint;
793pub const ARG_TYPE_BLOCK: redisCommandArgType = 8;
794pub const ARG_TYPE_ONEOF: redisCommandArgType = 7;
795pub const ARG_TYPE_PURE_TOKEN: redisCommandArgType = 6;
796pub const ARG_TYPE_UNIX_TIME: redisCommandArgType = 5;
797pub const ARG_TYPE_PATTERN: redisCommandArgType = 4;
798pub const ARG_TYPE_KEY: redisCommandArgType = 3;
799pub const ARG_TYPE_DOUBLE: redisCommandArgType = 2;
800pub const ARG_TYPE_INTEGER: redisCommandArgType = 1;
801pub const ARG_TYPE_STRING: redisCommandArgType = 0;
802pub type redisGetKeysProc = unsafe extern "C" fn(
803    *mut redisCommand,
804    *mut *mut robj,
805    libc::c_int,
806    *mut getKeysResult,
807) -> libc::c_int;
808#[derive(Copy, Clone)]
809#[repr(C)]
810pub struct getKeysResult {
811    pub keysbuf: [keyReference; 256],
812    pub keys: *mut keyReference,
813    pub numkeys: libc::c_int,
814    pub size: libc::c_int,
815}
816#[derive(Copy, Clone)]
817#[repr(C)]
818pub struct keyReference {
819    pub pos: libc::c_int,
820    pub flags: libc::c_int,
821}
822pub type redisCommandProc = unsafe extern "C" fn(*mut client) -> ();
823#[derive(Copy, Clone)]
824#[repr(C)]
825pub struct client {
826    pub id: uint64_t,
827    pub flags: uint64_t,
828    pub conn: *mut connection,
829    pub resp: libc::c_int,
830    pub db: *mut redisDb,
831    pub name: *mut robj,
832    pub querybuf: sds,
833    pub qb_pos: size_t,
834    pub querybuf_peak: size_t,
835    pub argc: libc::c_int,
836    pub argv: *mut *mut robj,
837    pub argv_len: libc::c_int,
838    pub original_argc: libc::c_int,
839    pub original_argv: *mut *mut robj,
840    pub argv_len_sum: size_t,
841    pub cmd: *mut redisCommand,
842    pub lastcmd: *mut redisCommand,
843    pub realcmd: *mut redisCommand,
844    pub user: *mut user,
845    pub reqtype: libc::c_int,
846    pub multibulklen: libc::c_int,
847    pub bulklen: libc::c_long,
848    pub reply: *mut list,
849    pub reply_bytes: libc::c_ulonglong,
850    pub deferred_reply_errors: *mut list,
851    pub sentlen: size_t,
852    pub ctime: time_t,
853    pub duration: libc::c_long,
854    pub slot: libc::c_int,
855    pub cur_script: *mut dictEntry,
856    pub lastinteraction: time_t,
857    pub obuf_soft_limit_reached_time: time_t,
858    pub authenticated: libc::c_int,
859    pub replstate: libc::c_int,
860    pub repl_start_cmd_stream_on_ack: libc::c_int,
861    pub repldbfd: libc::c_int,
862    pub repldboff: off_t,
863    pub repldbsize: off_t,
864    pub replpreamble: sds,
865    pub read_reploff: libc::c_longlong,
866    pub reploff: libc::c_longlong,
867    pub repl_applied: libc::c_longlong,
868    pub repl_ack_off: libc::c_longlong,
869    pub repl_ack_time: libc::c_longlong,
870    pub repl_last_partial_write: libc::c_longlong,
871    pub psync_initial_offset: libc::c_longlong,
872    pub replid: [libc::c_char; 41],
873    pub slave_listening_port: libc::c_int,
874    pub slave_addr: *mut libc::c_char,
875    pub slave_capa: libc::c_int,
876    pub slave_req: libc::c_int,
877    pub mstate: multiState,
878    pub btype: libc::c_int,
879    pub bpop: blockingState,
880    pub woff: libc::c_longlong,
881    pub watched_keys: *mut list,
882    pub pubsub_channels: *mut dict,
883    pub pubsub_patterns: *mut list,
884    pub pubsubshard_channels: *mut dict,
885    pub peerid: sds,
886    pub sockname: sds,
887    pub client_list_node: *mut listNode,
888    pub postponed_list_node: *mut listNode,
889    pub pending_read_list_node: *mut listNode,
890    pub auth_callback: RedisModuleUserChangedFunc,
891    pub auth_callback_privdata: *mut libc::c_void,
892    pub auth_module: *mut libc::c_void,
893    pub client_tracking_redirection: uint64_t,
894    pub client_tracking_prefixes: *mut rax,
895    pub last_memory_usage: size_t,
896    pub last_memory_type: libc::c_int,
897    pub mem_usage_bucket_node: *mut listNode,
898    pub mem_usage_bucket: *mut clientMemUsageBucket,
899    pub ref_repl_buf_node: *mut listNode,
900    pub ref_block_pos: size_t,
901    pub buf_peak: size_t,
902    pub buf_peak_last_reset_time: mstime_t,
903    pub bufpos: libc::c_int,
904    pub buf_usable_size: size_t,
905    pub buf: *mut libc::c_char,
906}
907#[derive(Copy, Clone)]
908#[repr(C)]
909pub struct clientMemUsageBucket {
910    pub clients: *mut list,
911    pub mem_usage_sum: size_t,
912}
913#[derive(Copy, Clone)]
914#[repr(C)]
915pub struct blockingState {
916    pub count: libc::c_long,
917    pub timeout: mstime_t,
918    pub keys: *mut dict,
919    pub target: *mut robj,
920    pub blockpos: blockPos,
921    pub xread_count: size_t,
922    pub xread_group: *mut robj,
923    pub xread_consumer: *mut robj,
924    pub xread_group_noack: libc::c_int,
925    pub numreplicas: libc::c_int,
926    pub reploffset: libc::c_longlong,
927    pub module_blocked_handle: *mut libc::c_void,
928}
929#[derive(Copy, Clone)]
930#[repr(C)]
931pub struct blockPos {
932    pub wherefrom: libc::c_int,
933    pub whereto: libc::c_int,
934}
935#[derive(Copy, Clone)]
936#[repr(C)]
937pub struct multiState {
938    pub commands: *mut multiCmd,
939    pub count: libc::c_int,
940    pub cmd_flags: libc::c_int,
941    pub cmd_inv_flags: libc::c_int,
942    pub argv_len_sums: size_t,
943    pub alloc_count: libc::c_int,
944}
945#[derive(Copy, Clone)]
946#[repr(C)]
947pub struct user {
948    pub name: sds,
949    pub flags: uint32_t,
950    pub passwords: *mut list,
951    pub selectors: *mut list,
952    pub acl_string: *mut robj,
953}
954#[derive(Copy, Clone)]
955#[repr(C)]
956pub struct commandHistory {
957    pub since: *const libc::c_char,
958    pub changes: *const libc::c_char,
959}
960pub type redisCommandGroup = libc::c_uint;
961pub const COMMAND_GROUP_MODULE: redisCommandGroup = 17;
962pub const COMMAND_GROUP_BITMAP: redisCommandGroup = 16;
963pub const COMMAND_GROUP_STREAM: redisCommandGroup = 15;
964pub const COMMAND_GROUP_GEO: redisCommandGroup = 14;
965pub const COMMAND_GROUP_SENTINEL: redisCommandGroup = 13;
966pub const COMMAND_GROUP_CLUSTER: redisCommandGroup = 12;
967pub const COMMAND_GROUP_HYPERLOGLOG: redisCommandGroup = 11;
968pub const COMMAND_GROUP_SCRIPTING: redisCommandGroup = 10;
969pub const COMMAND_GROUP_SERVER: redisCommandGroup = 9;
970pub const COMMAND_GROUP_CONNECTION: redisCommandGroup = 8;
971pub const COMMAND_GROUP_TRANSACTIONS: redisCommandGroup = 7;
972pub const COMMAND_GROUP_PUBSUB: redisCommandGroup = 6;
973pub const COMMAND_GROUP_HASH: redisCommandGroup = 5;
974pub const COMMAND_GROUP_SORTED_SET: redisCommandGroup = 4;
975pub const COMMAND_GROUP_SET: redisCommandGroup = 3;
976pub const COMMAND_GROUP_LIST: redisCommandGroup = 2;
977pub const COMMAND_GROUP_STRING: redisCommandGroup = 1;
978pub const COMMAND_GROUP_GENERIC: redisCommandGroup = 0;
979#[no_mangle]
980pub static mut BITCOUNT_History: [commandHistory; 2] = [
981    {
982        let mut init = commandHistory {
983            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
984            changes: b"Added the `BYTE|BIT` option.\0" as *const u8
985                as *const libc::c_char,
986        };
987        init
988    },
989    {
990        let mut init = commandHistory {
991            since: 0 as *const libc::c_char,
992            changes: 0 as *const libc::c_char,
993        };
994        init
995    },
996];
997#[no_mangle]
998pub static mut BITCOUNT_index_index_unit_Subargs: [redisCommandArg; 3] = [
999    {
1000        let mut init = redisCommandArg {
1001            name: b"byte\0" as *const u8 as *const libc::c_char,
1002            type_0: ARG_TYPE_PURE_TOKEN,
1003            key_spec_index: -(1 as libc::c_int),
1004            token: b"BYTE\0" as *const u8 as *const libc::c_char,
1005            summary: 0 as *const libc::c_char,
1006            since: 0 as *const libc::c_char,
1007            flags: 0 as libc::c_int,
1008            deprecated_since: 0 as *const libc::c_char,
1009            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1010            num_args: 0,
1011        };
1012        init
1013    },
1014    {
1015        let mut init = redisCommandArg {
1016            name: b"bit\0" as *const u8 as *const libc::c_char,
1017            type_0: ARG_TYPE_PURE_TOKEN,
1018            key_spec_index: -(1 as libc::c_int),
1019            token: b"BIT\0" as *const u8 as *const libc::c_char,
1020            summary: 0 as *const libc::c_char,
1021            since: 0 as *const libc::c_char,
1022            flags: 0 as libc::c_int,
1023            deprecated_since: 0 as *const libc::c_char,
1024            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1025            num_args: 0,
1026        };
1027        init
1028    },
1029    {
1030        let mut init = redisCommandArg {
1031            name: 0 as *const libc::c_char,
1032            type_0: ARG_TYPE_STRING,
1033            key_spec_index: 0,
1034            token: 0 as *const libc::c_char,
1035            summary: 0 as *const libc::c_char,
1036            since: 0 as *const libc::c_char,
1037            flags: 0,
1038            deprecated_since: 0 as *const libc::c_char,
1039            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1040            num_args: 0,
1041        };
1042        init
1043    },
1044];
1045#[no_mangle]
1046pub static mut BITCOUNT_index_Subargs: [redisCommandArg; 4] = unsafe {
1047    [
1048        {
1049            let mut init = redisCommandArg {
1050                name: b"start\0" as *const u8 as *const libc::c_char,
1051                type_0: ARG_TYPE_INTEGER,
1052                key_spec_index: -(1 as libc::c_int),
1053                token: 0 as *const libc::c_char,
1054                summary: 0 as *const libc::c_char,
1055                since: 0 as *const libc::c_char,
1056                flags: 0 as libc::c_int,
1057                deprecated_since: 0 as *const libc::c_char,
1058                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1059                num_args: 0,
1060            };
1061            init
1062        },
1063        {
1064            let mut init = redisCommandArg {
1065                name: b"end\0" as *const u8 as *const libc::c_char,
1066                type_0: ARG_TYPE_INTEGER,
1067                key_spec_index: -(1 as libc::c_int),
1068                token: 0 as *const libc::c_char,
1069                summary: 0 as *const libc::c_char,
1070                since: 0 as *const libc::c_char,
1071                flags: 0 as libc::c_int,
1072                deprecated_since: 0 as *const libc::c_char,
1073                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1074                num_args: 0,
1075            };
1076            init
1077        },
1078        {
1079            let mut init = redisCommandArg {
1080                name: b"index_unit\0" as *const u8 as *const libc::c_char,
1081                type_0: ARG_TYPE_ONEOF,
1082                key_spec_index: -(1 as libc::c_int),
1083                token: 0 as *const libc::c_char,
1084                summary: 0 as *const libc::c_char,
1085                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
1086                flags: (1 as libc::c_int) << 0 as libc::c_int,
1087                deprecated_since: 0 as *const libc::c_char,
1088                subargs: BITCOUNT_index_index_unit_Subargs.as_ptr() as *mut _,
1089                num_args: 0,
1090            };
1091            init
1092        },
1093        {
1094            let mut init = redisCommandArg {
1095                name: 0 as *const libc::c_char,
1096                type_0: ARG_TYPE_STRING,
1097                key_spec_index: 0,
1098                token: 0 as *const libc::c_char,
1099                summary: 0 as *const libc::c_char,
1100                since: 0 as *const libc::c_char,
1101                flags: 0,
1102                deprecated_since: 0 as *const libc::c_char,
1103                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1104                num_args: 0,
1105            };
1106            init
1107        },
1108    ]
1109};
1110#[no_mangle]
1111pub static mut BITCOUNT_Args: [redisCommandArg; 3] = unsafe {
1112    [
1113        {
1114            let mut init = redisCommandArg {
1115                name: b"key\0" as *const u8 as *const libc::c_char,
1116                type_0: ARG_TYPE_KEY,
1117                key_spec_index: 0 as libc::c_int,
1118                token: 0 as *const libc::c_char,
1119                summary: 0 as *const libc::c_char,
1120                since: 0 as *const libc::c_char,
1121                flags: 0 as libc::c_int,
1122                deprecated_since: 0 as *const libc::c_char,
1123                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1124                num_args: 0,
1125            };
1126            init
1127        },
1128        {
1129            let mut init = redisCommandArg {
1130                name: b"index\0" as *const u8 as *const libc::c_char,
1131                type_0: ARG_TYPE_BLOCK,
1132                key_spec_index: -(1 as libc::c_int),
1133                token: 0 as *const libc::c_char,
1134                summary: 0 as *const libc::c_char,
1135                since: 0 as *const libc::c_char,
1136                flags: (1 as libc::c_int) << 0 as libc::c_int,
1137                deprecated_since: 0 as *const libc::c_char,
1138                subargs: BITCOUNT_index_Subargs.as_ptr() as *mut _,
1139                num_args: 0,
1140            };
1141            init
1142        },
1143        {
1144            let mut init = redisCommandArg {
1145                name: 0 as *const libc::c_char,
1146                type_0: ARG_TYPE_STRING,
1147                key_spec_index: 0,
1148                token: 0 as *const libc::c_char,
1149                summary: 0 as *const libc::c_char,
1150                since: 0 as *const libc::c_char,
1151                flags: 0,
1152                deprecated_since: 0 as *const libc::c_char,
1153                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1154                num_args: 0,
1155            };
1156            init
1157        },
1158    ]
1159};
1160#[no_mangle]
1161pub static mut BITFIELD_operation_encoding_offset_Subargs: [redisCommandArg; 3] = [
1162    {
1163        let mut init = redisCommandArg {
1164            name: b"encoding\0" as *const u8 as *const libc::c_char,
1165            type_0: ARG_TYPE_STRING,
1166            key_spec_index: -(1 as libc::c_int),
1167            token: 0 as *const libc::c_char,
1168            summary: 0 as *const libc::c_char,
1169            since: 0 as *const libc::c_char,
1170            flags: 0 as libc::c_int,
1171            deprecated_since: 0 as *const libc::c_char,
1172            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1173            num_args: 0,
1174        };
1175        init
1176    },
1177    {
1178        let mut init = redisCommandArg {
1179            name: b"offset\0" as *const u8 as *const libc::c_char,
1180            type_0: ARG_TYPE_INTEGER,
1181            key_spec_index: -(1 as libc::c_int),
1182            token: 0 as *const libc::c_char,
1183            summary: 0 as *const libc::c_char,
1184            since: 0 as *const libc::c_char,
1185            flags: 0 as libc::c_int,
1186            deprecated_since: 0 as *const libc::c_char,
1187            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1188            num_args: 0,
1189        };
1190        init
1191    },
1192    {
1193        let mut init = redisCommandArg {
1194            name: 0 as *const libc::c_char,
1195            type_0: ARG_TYPE_STRING,
1196            key_spec_index: 0,
1197            token: 0 as *const libc::c_char,
1198            summary: 0 as *const libc::c_char,
1199            since: 0 as *const libc::c_char,
1200            flags: 0,
1201            deprecated_since: 0 as *const libc::c_char,
1202            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1203            num_args: 0,
1204        };
1205        init
1206    },
1207];
1208#[no_mangle]
1209pub static mut BITFIELD_operation_write_wrap_sat_fail_Subargs: [redisCommandArg; 4] = [
1210    {
1211        let mut init = redisCommandArg {
1212            name: b"wrap\0" as *const u8 as *const libc::c_char,
1213            type_0: ARG_TYPE_PURE_TOKEN,
1214            key_spec_index: -(1 as libc::c_int),
1215            token: b"WRAP\0" as *const u8 as *const libc::c_char,
1216            summary: 0 as *const libc::c_char,
1217            since: 0 as *const libc::c_char,
1218            flags: 0 as libc::c_int,
1219            deprecated_since: 0 as *const libc::c_char,
1220            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1221            num_args: 0,
1222        };
1223        init
1224    },
1225    {
1226        let mut init = redisCommandArg {
1227            name: b"sat\0" as *const u8 as *const libc::c_char,
1228            type_0: ARG_TYPE_PURE_TOKEN,
1229            key_spec_index: -(1 as libc::c_int),
1230            token: b"SAT\0" as *const u8 as *const libc::c_char,
1231            summary: 0 as *const libc::c_char,
1232            since: 0 as *const libc::c_char,
1233            flags: 0 as libc::c_int,
1234            deprecated_since: 0 as *const libc::c_char,
1235            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1236            num_args: 0,
1237        };
1238        init
1239    },
1240    {
1241        let mut init = redisCommandArg {
1242            name: b"fail\0" as *const u8 as *const libc::c_char,
1243            type_0: ARG_TYPE_PURE_TOKEN,
1244            key_spec_index: -(1 as libc::c_int),
1245            token: b"FAIL\0" as *const u8 as *const libc::c_char,
1246            summary: 0 as *const libc::c_char,
1247            since: 0 as *const libc::c_char,
1248            flags: 0 as libc::c_int,
1249            deprecated_since: 0 as *const libc::c_char,
1250            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1251            num_args: 0,
1252        };
1253        init
1254    },
1255    {
1256        let mut init = redisCommandArg {
1257            name: 0 as *const libc::c_char,
1258            type_0: ARG_TYPE_STRING,
1259            key_spec_index: 0,
1260            token: 0 as *const libc::c_char,
1261            summary: 0 as *const libc::c_char,
1262            since: 0 as *const libc::c_char,
1263            flags: 0,
1264            deprecated_since: 0 as *const libc::c_char,
1265            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1266            num_args: 0,
1267        };
1268        init
1269    },
1270];
1271#[no_mangle]
1272pub static mut BITFIELD_operation_write_write_operation_encoding_offset_value_Subargs: [redisCommandArg; 4] = [
1273    {
1274        let mut init = redisCommandArg {
1275            name: b"encoding\0" as *const u8 as *const libc::c_char,
1276            type_0: ARG_TYPE_STRING,
1277            key_spec_index: -(1 as libc::c_int),
1278            token: 0 as *const libc::c_char,
1279            summary: 0 as *const libc::c_char,
1280            since: 0 as *const libc::c_char,
1281            flags: 0 as libc::c_int,
1282            deprecated_since: 0 as *const libc::c_char,
1283            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1284            num_args: 0,
1285        };
1286        init
1287    },
1288    {
1289        let mut init = redisCommandArg {
1290            name: b"offset\0" as *const u8 as *const libc::c_char,
1291            type_0: ARG_TYPE_INTEGER,
1292            key_spec_index: -(1 as libc::c_int),
1293            token: 0 as *const libc::c_char,
1294            summary: 0 as *const libc::c_char,
1295            since: 0 as *const libc::c_char,
1296            flags: 0 as libc::c_int,
1297            deprecated_since: 0 as *const libc::c_char,
1298            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1299            num_args: 0,
1300        };
1301        init
1302    },
1303    {
1304        let mut init = redisCommandArg {
1305            name: b"value\0" as *const u8 as *const libc::c_char,
1306            type_0: ARG_TYPE_INTEGER,
1307            key_spec_index: -(1 as libc::c_int),
1308            token: 0 as *const libc::c_char,
1309            summary: 0 as *const libc::c_char,
1310            since: 0 as *const libc::c_char,
1311            flags: 0 as libc::c_int,
1312            deprecated_since: 0 as *const libc::c_char,
1313            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1314            num_args: 0,
1315        };
1316        init
1317    },
1318    {
1319        let mut init = redisCommandArg {
1320            name: 0 as *const libc::c_char,
1321            type_0: ARG_TYPE_STRING,
1322            key_spec_index: 0,
1323            token: 0 as *const libc::c_char,
1324            summary: 0 as *const libc::c_char,
1325            since: 0 as *const libc::c_char,
1326            flags: 0,
1327            deprecated_since: 0 as *const libc::c_char,
1328            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1329            num_args: 0,
1330        };
1331        init
1332    },
1333];
1334#[no_mangle]
1335pub static mut BITFIELD_operation_write_write_operation_encoding_offset_increment_Subargs: [redisCommandArg; 4] = [
1336    {
1337        let mut init = redisCommandArg {
1338            name: b"encoding\0" as *const u8 as *const libc::c_char,
1339            type_0: ARG_TYPE_STRING,
1340            key_spec_index: -(1 as libc::c_int),
1341            token: 0 as *const libc::c_char,
1342            summary: 0 as *const libc::c_char,
1343            since: 0 as *const libc::c_char,
1344            flags: 0 as libc::c_int,
1345            deprecated_since: 0 as *const libc::c_char,
1346            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1347            num_args: 0,
1348        };
1349        init
1350    },
1351    {
1352        let mut init = redisCommandArg {
1353            name: b"offset\0" as *const u8 as *const libc::c_char,
1354            type_0: ARG_TYPE_INTEGER,
1355            key_spec_index: -(1 as libc::c_int),
1356            token: 0 as *const libc::c_char,
1357            summary: 0 as *const libc::c_char,
1358            since: 0 as *const libc::c_char,
1359            flags: 0 as libc::c_int,
1360            deprecated_since: 0 as *const libc::c_char,
1361            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1362            num_args: 0,
1363        };
1364        init
1365    },
1366    {
1367        let mut init = redisCommandArg {
1368            name: b"increment\0" as *const u8 as *const libc::c_char,
1369            type_0: ARG_TYPE_INTEGER,
1370            key_spec_index: -(1 as libc::c_int),
1371            token: 0 as *const libc::c_char,
1372            summary: 0 as *const libc::c_char,
1373            since: 0 as *const libc::c_char,
1374            flags: 0 as libc::c_int,
1375            deprecated_since: 0 as *const libc::c_char,
1376            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1377            num_args: 0,
1378        };
1379        init
1380    },
1381    {
1382        let mut init = redisCommandArg {
1383            name: 0 as *const libc::c_char,
1384            type_0: ARG_TYPE_STRING,
1385            key_spec_index: 0,
1386            token: 0 as *const libc::c_char,
1387            summary: 0 as *const libc::c_char,
1388            since: 0 as *const libc::c_char,
1389            flags: 0,
1390            deprecated_since: 0 as *const libc::c_char,
1391            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1392            num_args: 0,
1393        };
1394        init
1395    },
1396];
1397#[no_mangle]
1398pub static mut BITFIELD_operation_write_write_operation_Subargs: [redisCommandArg; 3] = unsafe {
1399    [
1400        {
1401            let mut init = redisCommandArg {
1402                name: b"encoding_offset_value\0" as *const u8 as *const libc::c_char,
1403                type_0: ARG_TYPE_BLOCK,
1404                key_spec_index: -(1 as libc::c_int),
1405                token: b"SET\0" as *const u8 as *const libc::c_char,
1406                summary: 0 as *const libc::c_char,
1407                since: 0 as *const libc::c_char,
1408                flags: 0 as libc::c_int,
1409                deprecated_since: 0 as *const libc::c_char,
1410                subargs: BITFIELD_operation_write_write_operation_encoding_offset_value_Subargs
1411                    .as_ptr() as *mut _,
1412                num_args: 0,
1413            };
1414            init
1415        },
1416        {
1417            let mut init = redisCommandArg {
1418                name: b"encoding_offset_increment\0" as *const u8 as *const libc::c_char,
1419                type_0: ARG_TYPE_BLOCK,
1420                key_spec_index: -(1 as libc::c_int),
1421                token: b"INCRBY\0" as *const u8 as *const libc::c_char,
1422                summary: 0 as *const libc::c_char,
1423                since: 0 as *const libc::c_char,
1424                flags: 0 as libc::c_int,
1425                deprecated_since: 0 as *const libc::c_char,
1426                subargs: BITFIELD_operation_write_write_operation_encoding_offset_increment_Subargs
1427                    .as_ptr() as *mut _,
1428                num_args: 0,
1429            };
1430            init
1431        },
1432        {
1433            let mut init = redisCommandArg {
1434                name: 0 as *const libc::c_char,
1435                type_0: ARG_TYPE_STRING,
1436                key_spec_index: 0,
1437                token: 0 as *const libc::c_char,
1438                summary: 0 as *const libc::c_char,
1439                since: 0 as *const libc::c_char,
1440                flags: 0,
1441                deprecated_since: 0 as *const libc::c_char,
1442                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1443                num_args: 0,
1444            };
1445            init
1446        },
1447    ]
1448};
1449#[no_mangle]
1450pub static mut BITFIELD_operation_write_Subargs: [redisCommandArg; 3] = unsafe {
1451    [
1452        {
1453            let mut init = redisCommandArg {
1454                name: b"wrap_sat_fail\0" as *const u8 as *const libc::c_char,
1455                type_0: ARG_TYPE_ONEOF,
1456                key_spec_index: -(1 as libc::c_int),
1457                token: b"OVERFLOW\0" as *const u8 as *const libc::c_char,
1458                summary: 0 as *const libc::c_char,
1459                since: 0 as *const libc::c_char,
1460                flags: (1 as libc::c_int) << 0 as libc::c_int,
1461                deprecated_since: 0 as *const libc::c_char,
1462                subargs: BITFIELD_operation_write_wrap_sat_fail_Subargs.as_ptr()
1463                    as *mut _,
1464                num_args: 0,
1465            };
1466            init
1467        },
1468        {
1469            let mut init = redisCommandArg {
1470                name: b"write_operation\0" as *const u8 as *const libc::c_char,
1471                type_0: ARG_TYPE_ONEOF,
1472                key_spec_index: -(1 as libc::c_int),
1473                token: 0 as *const libc::c_char,
1474                summary: 0 as *const libc::c_char,
1475                since: 0 as *const libc::c_char,
1476                flags: 0 as libc::c_int,
1477                deprecated_since: 0 as *const libc::c_char,
1478                subargs: BITFIELD_operation_write_write_operation_Subargs.as_ptr()
1479                    as *mut _,
1480                num_args: 0,
1481            };
1482            init
1483        },
1484        {
1485            let mut init = redisCommandArg {
1486                name: 0 as *const libc::c_char,
1487                type_0: ARG_TYPE_STRING,
1488                key_spec_index: 0,
1489                token: 0 as *const libc::c_char,
1490                summary: 0 as *const libc::c_char,
1491                since: 0 as *const libc::c_char,
1492                flags: 0,
1493                deprecated_since: 0 as *const libc::c_char,
1494                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1495                num_args: 0,
1496            };
1497            init
1498        },
1499    ]
1500};
1501#[no_mangle]
1502pub static mut BITFIELD_operation_Subargs: [redisCommandArg; 3] = unsafe {
1503    [
1504        {
1505            let mut init = redisCommandArg {
1506                name: b"encoding_offset\0" as *const u8 as *const libc::c_char,
1507                type_0: ARG_TYPE_BLOCK,
1508                key_spec_index: -(1 as libc::c_int),
1509                token: b"GET\0" as *const u8 as *const libc::c_char,
1510                summary: 0 as *const libc::c_char,
1511                since: 0 as *const libc::c_char,
1512                flags: 0 as libc::c_int,
1513                deprecated_since: 0 as *const libc::c_char,
1514                subargs: BITFIELD_operation_encoding_offset_Subargs.as_ptr() as *mut _,
1515                num_args: 0,
1516            };
1517            init
1518        },
1519        {
1520            let mut init = redisCommandArg {
1521                name: b"write\0" as *const u8 as *const libc::c_char,
1522                type_0: ARG_TYPE_BLOCK,
1523                key_spec_index: -(1 as libc::c_int),
1524                token: 0 as *const libc::c_char,
1525                summary: 0 as *const libc::c_char,
1526                since: 0 as *const libc::c_char,
1527                flags: 0 as libc::c_int,
1528                deprecated_since: 0 as *const libc::c_char,
1529                subargs: BITFIELD_operation_write_Subargs.as_ptr() as *mut _,
1530                num_args: 0,
1531            };
1532            init
1533        },
1534        {
1535            let mut init = redisCommandArg {
1536                name: 0 as *const libc::c_char,
1537                type_0: ARG_TYPE_STRING,
1538                key_spec_index: 0,
1539                token: 0 as *const libc::c_char,
1540                summary: 0 as *const libc::c_char,
1541                since: 0 as *const libc::c_char,
1542                flags: 0,
1543                deprecated_since: 0 as *const libc::c_char,
1544                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1545                num_args: 0,
1546            };
1547            init
1548        },
1549    ]
1550};
1551#[no_mangle]
1552pub static mut BITFIELD_Args: [redisCommandArg; 3] = unsafe {
1553    [
1554        {
1555            let mut init = redisCommandArg {
1556                name: b"key\0" as *const u8 as *const libc::c_char,
1557                type_0: ARG_TYPE_KEY,
1558                key_spec_index: 0 as libc::c_int,
1559                token: 0 as *const libc::c_char,
1560                summary: 0 as *const libc::c_char,
1561                since: 0 as *const libc::c_char,
1562                flags: 0 as libc::c_int,
1563                deprecated_since: 0 as *const libc::c_char,
1564                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1565                num_args: 0,
1566            };
1567            init
1568        },
1569        {
1570            let mut init = redisCommandArg {
1571                name: b"operation\0" as *const u8 as *const libc::c_char,
1572                type_0: ARG_TYPE_ONEOF,
1573                key_spec_index: -(1 as libc::c_int),
1574                token: 0 as *const libc::c_char,
1575                summary: 0 as *const libc::c_char,
1576                since: 0 as *const libc::c_char,
1577                flags: (1 as libc::c_int) << 1 as libc::c_int,
1578                deprecated_since: 0 as *const libc::c_char,
1579                subargs: BITFIELD_operation_Subargs.as_ptr() as *mut _,
1580                num_args: 0,
1581            };
1582            init
1583        },
1584        {
1585            let mut init = redisCommandArg {
1586                name: 0 as *const libc::c_char,
1587                type_0: ARG_TYPE_STRING,
1588                key_spec_index: 0,
1589                token: 0 as *const libc::c_char,
1590                summary: 0 as *const libc::c_char,
1591                since: 0 as *const libc::c_char,
1592                flags: 0,
1593                deprecated_since: 0 as *const libc::c_char,
1594                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1595                num_args: 0,
1596            };
1597            init
1598        },
1599    ]
1600};
1601#[no_mangle]
1602pub static mut BITFIELD_RO_encoding_offset_Subargs: [redisCommandArg; 3] = [
1603    {
1604        let mut init = redisCommandArg {
1605            name: b"encoding\0" as *const u8 as *const libc::c_char,
1606            type_0: ARG_TYPE_STRING,
1607            key_spec_index: -(1 as libc::c_int),
1608            token: 0 as *const libc::c_char,
1609            summary: 0 as *const libc::c_char,
1610            since: 0 as *const libc::c_char,
1611            flags: 0 as libc::c_int,
1612            deprecated_since: 0 as *const libc::c_char,
1613            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1614            num_args: 0,
1615        };
1616        init
1617    },
1618    {
1619        let mut init = redisCommandArg {
1620            name: b"offset\0" as *const u8 as *const libc::c_char,
1621            type_0: ARG_TYPE_INTEGER,
1622            key_spec_index: -(1 as libc::c_int),
1623            token: 0 as *const libc::c_char,
1624            summary: 0 as *const libc::c_char,
1625            since: 0 as *const libc::c_char,
1626            flags: 0 as libc::c_int,
1627            deprecated_since: 0 as *const libc::c_char,
1628            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1629            num_args: 0,
1630        };
1631        init
1632    },
1633    {
1634        let mut init = redisCommandArg {
1635            name: 0 as *const libc::c_char,
1636            type_0: ARG_TYPE_STRING,
1637            key_spec_index: 0,
1638            token: 0 as *const libc::c_char,
1639            summary: 0 as *const libc::c_char,
1640            since: 0 as *const libc::c_char,
1641            flags: 0,
1642            deprecated_since: 0 as *const libc::c_char,
1643            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1644            num_args: 0,
1645        };
1646        init
1647    },
1648];
1649#[no_mangle]
1650pub static mut BITFIELD_RO_Args: [redisCommandArg; 3] = unsafe {
1651    [
1652        {
1653            let mut init = redisCommandArg {
1654                name: b"key\0" as *const u8 as *const libc::c_char,
1655                type_0: ARG_TYPE_KEY,
1656                key_spec_index: 0 as libc::c_int,
1657                token: 0 as *const libc::c_char,
1658                summary: 0 as *const libc::c_char,
1659                since: 0 as *const libc::c_char,
1660                flags: 0 as libc::c_int,
1661                deprecated_since: 0 as *const libc::c_char,
1662                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1663                num_args: 0,
1664            };
1665            init
1666        },
1667        {
1668            let mut init = redisCommandArg {
1669                name: b"encoding_offset\0" as *const u8 as *const libc::c_char,
1670                type_0: ARG_TYPE_BLOCK,
1671                key_spec_index: -(1 as libc::c_int),
1672                token: b"GET\0" as *const u8 as *const libc::c_char,
1673                summary: 0 as *const libc::c_char,
1674                since: 0 as *const libc::c_char,
1675                flags: (1 as libc::c_int) << 1 as libc::c_int
1676                    | (1 as libc::c_int) << 2 as libc::c_int,
1677                deprecated_since: 0 as *const libc::c_char,
1678                subargs: BITFIELD_RO_encoding_offset_Subargs.as_ptr() as *mut _,
1679                num_args: 0,
1680            };
1681            init
1682        },
1683        {
1684            let mut init = redisCommandArg {
1685                name: 0 as *const libc::c_char,
1686                type_0: ARG_TYPE_STRING,
1687                key_spec_index: 0,
1688                token: 0 as *const libc::c_char,
1689                summary: 0 as *const libc::c_char,
1690                since: 0 as *const libc::c_char,
1691                flags: 0,
1692                deprecated_since: 0 as *const libc::c_char,
1693                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1694                num_args: 0,
1695            };
1696            init
1697        },
1698    ]
1699};
1700#[no_mangle]
1701pub static mut BITOP_Args: [redisCommandArg; 4] = [
1702    {
1703        let mut init = redisCommandArg {
1704            name: b"operation\0" as *const u8 as *const libc::c_char,
1705            type_0: ARG_TYPE_STRING,
1706            key_spec_index: -(1 as libc::c_int),
1707            token: 0 as *const libc::c_char,
1708            summary: 0 as *const libc::c_char,
1709            since: 0 as *const libc::c_char,
1710            flags: 0 as libc::c_int,
1711            deprecated_since: 0 as *const libc::c_char,
1712            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1713            num_args: 0,
1714        };
1715        init
1716    },
1717    {
1718        let mut init = redisCommandArg {
1719            name: b"destkey\0" as *const u8 as *const libc::c_char,
1720            type_0: ARG_TYPE_KEY,
1721            key_spec_index: 0 as libc::c_int,
1722            token: 0 as *const libc::c_char,
1723            summary: 0 as *const libc::c_char,
1724            since: 0 as *const libc::c_char,
1725            flags: 0 as libc::c_int,
1726            deprecated_since: 0 as *const libc::c_char,
1727            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1728            num_args: 0,
1729        };
1730        init
1731    },
1732    {
1733        let mut init = redisCommandArg {
1734            name: b"key\0" as *const u8 as *const libc::c_char,
1735            type_0: ARG_TYPE_KEY,
1736            key_spec_index: 1 as libc::c_int,
1737            token: 0 as *const libc::c_char,
1738            summary: 0 as *const libc::c_char,
1739            since: 0 as *const libc::c_char,
1740            flags: (1 as libc::c_int) << 1 as libc::c_int,
1741            deprecated_since: 0 as *const libc::c_char,
1742            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1743            num_args: 0,
1744        };
1745        init
1746    },
1747    {
1748        let mut init = redisCommandArg {
1749            name: 0 as *const libc::c_char,
1750            type_0: ARG_TYPE_STRING,
1751            key_spec_index: 0,
1752            token: 0 as *const libc::c_char,
1753            summary: 0 as *const libc::c_char,
1754            since: 0 as *const libc::c_char,
1755            flags: 0,
1756            deprecated_since: 0 as *const libc::c_char,
1757            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1758            num_args: 0,
1759        };
1760        init
1761    },
1762];
1763#[no_mangle]
1764pub static mut BITPOS_History: [commandHistory; 2] = [
1765    {
1766        let mut init = commandHistory {
1767            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
1768            changes: b"Added the `BYTE|BIT` option.\0" as *const u8
1769                as *const libc::c_char,
1770        };
1771        init
1772    },
1773    {
1774        let mut init = commandHistory {
1775            since: 0 as *const libc::c_char,
1776            changes: 0 as *const libc::c_char,
1777        };
1778        init
1779    },
1780];
1781#[no_mangle]
1782pub static mut BITPOS_index_end_index_index_unit_Subargs: [redisCommandArg; 3] = [
1783    {
1784        let mut init = redisCommandArg {
1785            name: b"byte\0" as *const u8 as *const libc::c_char,
1786            type_0: ARG_TYPE_PURE_TOKEN,
1787            key_spec_index: -(1 as libc::c_int),
1788            token: b"BYTE\0" as *const u8 as *const libc::c_char,
1789            summary: 0 as *const libc::c_char,
1790            since: 0 as *const libc::c_char,
1791            flags: 0 as libc::c_int,
1792            deprecated_since: 0 as *const libc::c_char,
1793            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1794            num_args: 0,
1795        };
1796        init
1797    },
1798    {
1799        let mut init = redisCommandArg {
1800            name: b"bit\0" as *const u8 as *const libc::c_char,
1801            type_0: ARG_TYPE_PURE_TOKEN,
1802            key_spec_index: -(1 as libc::c_int),
1803            token: b"BIT\0" as *const u8 as *const libc::c_char,
1804            summary: 0 as *const libc::c_char,
1805            since: 0 as *const libc::c_char,
1806            flags: 0 as libc::c_int,
1807            deprecated_since: 0 as *const libc::c_char,
1808            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1809            num_args: 0,
1810        };
1811        init
1812    },
1813    {
1814        let mut init = redisCommandArg {
1815            name: 0 as *const libc::c_char,
1816            type_0: ARG_TYPE_STRING,
1817            key_spec_index: 0,
1818            token: 0 as *const libc::c_char,
1819            summary: 0 as *const libc::c_char,
1820            since: 0 as *const libc::c_char,
1821            flags: 0,
1822            deprecated_since: 0 as *const libc::c_char,
1823            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1824            num_args: 0,
1825        };
1826        init
1827    },
1828];
1829#[no_mangle]
1830pub static mut BITPOS_index_end_index_Subargs: [redisCommandArg; 3] = unsafe {
1831    [
1832        {
1833            let mut init = redisCommandArg {
1834                name: b"end\0" as *const u8 as *const libc::c_char,
1835                type_0: ARG_TYPE_INTEGER,
1836                key_spec_index: -(1 as libc::c_int),
1837                token: 0 as *const libc::c_char,
1838                summary: 0 as *const libc::c_char,
1839                since: 0 as *const libc::c_char,
1840                flags: 0 as libc::c_int,
1841                deprecated_since: 0 as *const libc::c_char,
1842                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1843                num_args: 0,
1844            };
1845            init
1846        },
1847        {
1848            let mut init = redisCommandArg {
1849                name: b"index_unit\0" as *const u8 as *const libc::c_char,
1850                type_0: ARG_TYPE_ONEOF,
1851                key_spec_index: -(1 as libc::c_int),
1852                token: 0 as *const libc::c_char,
1853                summary: 0 as *const libc::c_char,
1854                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
1855                flags: (1 as libc::c_int) << 0 as libc::c_int,
1856                deprecated_since: 0 as *const libc::c_char,
1857                subargs: BITPOS_index_end_index_index_unit_Subargs.as_ptr() as *mut _,
1858                num_args: 0,
1859            };
1860            init
1861        },
1862        {
1863            let mut init = redisCommandArg {
1864                name: 0 as *const libc::c_char,
1865                type_0: ARG_TYPE_STRING,
1866                key_spec_index: 0,
1867                token: 0 as *const libc::c_char,
1868                summary: 0 as *const libc::c_char,
1869                since: 0 as *const libc::c_char,
1870                flags: 0,
1871                deprecated_since: 0 as *const libc::c_char,
1872                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1873                num_args: 0,
1874            };
1875            init
1876        },
1877    ]
1878};
1879#[no_mangle]
1880pub static mut BITPOS_index_Subargs: [redisCommandArg; 3] = unsafe {
1881    [
1882        {
1883            let mut init = redisCommandArg {
1884                name: b"start\0" as *const u8 as *const libc::c_char,
1885                type_0: ARG_TYPE_INTEGER,
1886                key_spec_index: -(1 as libc::c_int),
1887                token: 0 as *const libc::c_char,
1888                summary: 0 as *const libc::c_char,
1889                since: 0 as *const libc::c_char,
1890                flags: 0 as libc::c_int,
1891                deprecated_since: 0 as *const libc::c_char,
1892                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1893                num_args: 0,
1894            };
1895            init
1896        },
1897        {
1898            let mut init = redisCommandArg {
1899                name: b"end_index\0" as *const u8 as *const libc::c_char,
1900                type_0: ARG_TYPE_BLOCK,
1901                key_spec_index: -(1 as libc::c_int),
1902                token: 0 as *const libc::c_char,
1903                summary: 0 as *const libc::c_char,
1904                since: 0 as *const libc::c_char,
1905                flags: (1 as libc::c_int) << 0 as libc::c_int,
1906                deprecated_since: 0 as *const libc::c_char,
1907                subargs: BITPOS_index_end_index_Subargs.as_ptr() as *mut _,
1908                num_args: 0,
1909            };
1910            init
1911        },
1912        {
1913            let mut init = redisCommandArg {
1914                name: 0 as *const libc::c_char,
1915                type_0: ARG_TYPE_STRING,
1916                key_spec_index: 0,
1917                token: 0 as *const libc::c_char,
1918                summary: 0 as *const libc::c_char,
1919                since: 0 as *const libc::c_char,
1920                flags: 0,
1921                deprecated_since: 0 as *const libc::c_char,
1922                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1923                num_args: 0,
1924            };
1925            init
1926        },
1927    ]
1928};
1929#[no_mangle]
1930pub static mut BITPOS_Args: [redisCommandArg; 4] = unsafe {
1931    [
1932        {
1933            let mut init = redisCommandArg {
1934                name: b"key\0" as *const u8 as *const libc::c_char,
1935                type_0: ARG_TYPE_KEY,
1936                key_spec_index: 0 as libc::c_int,
1937                token: 0 as *const libc::c_char,
1938                summary: 0 as *const libc::c_char,
1939                since: 0 as *const libc::c_char,
1940                flags: 0 as libc::c_int,
1941                deprecated_since: 0 as *const libc::c_char,
1942                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1943                num_args: 0,
1944            };
1945            init
1946        },
1947        {
1948            let mut init = redisCommandArg {
1949                name: b"bit\0" as *const u8 as *const libc::c_char,
1950                type_0: ARG_TYPE_INTEGER,
1951                key_spec_index: -(1 as libc::c_int),
1952                token: 0 as *const libc::c_char,
1953                summary: 0 as *const libc::c_char,
1954                since: 0 as *const libc::c_char,
1955                flags: 0 as libc::c_int,
1956                deprecated_since: 0 as *const libc::c_char,
1957                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1958                num_args: 0,
1959            };
1960            init
1961        },
1962        {
1963            let mut init = redisCommandArg {
1964                name: b"index\0" as *const u8 as *const libc::c_char,
1965                type_0: ARG_TYPE_BLOCK,
1966                key_spec_index: -(1 as libc::c_int),
1967                token: 0 as *const libc::c_char,
1968                summary: 0 as *const libc::c_char,
1969                since: 0 as *const libc::c_char,
1970                flags: (1 as libc::c_int) << 0 as libc::c_int,
1971                deprecated_since: 0 as *const libc::c_char,
1972                subargs: BITPOS_index_Subargs.as_ptr() as *mut _,
1973                num_args: 0,
1974            };
1975            init
1976        },
1977        {
1978            let mut init = redisCommandArg {
1979                name: 0 as *const libc::c_char,
1980                type_0: ARG_TYPE_STRING,
1981                key_spec_index: 0,
1982                token: 0 as *const libc::c_char,
1983                summary: 0 as *const libc::c_char,
1984                since: 0 as *const libc::c_char,
1985                flags: 0,
1986                deprecated_since: 0 as *const libc::c_char,
1987                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
1988                num_args: 0,
1989            };
1990            init
1991        },
1992    ]
1993};
1994#[no_mangle]
1995pub static mut GETBIT_Args: [redisCommandArg; 3] = [
1996    {
1997        let mut init = redisCommandArg {
1998            name: b"key\0" as *const u8 as *const libc::c_char,
1999            type_0: ARG_TYPE_KEY,
2000            key_spec_index: 0 as libc::c_int,
2001            token: 0 as *const libc::c_char,
2002            summary: 0 as *const libc::c_char,
2003            since: 0 as *const libc::c_char,
2004            flags: 0 as libc::c_int,
2005            deprecated_since: 0 as *const libc::c_char,
2006            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2007            num_args: 0,
2008        };
2009        init
2010    },
2011    {
2012        let mut init = redisCommandArg {
2013            name: b"offset\0" as *const u8 as *const libc::c_char,
2014            type_0: ARG_TYPE_INTEGER,
2015            key_spec_index: -(1 as libc::c_int),
2016            token: 0 as *const libc::c_char,
2017            summary: 0 as *const libc::c_char,
2018            since: 0 as *const libc::c_char,
2019            flags: 0 as libc::c_int,
2020            deprecated_since: 0 as *const libc::c_char,
2021            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2022            num_args: 0,
2023        };
2024        init
2025    },
2026    {
2027        let mut init = redisCommandArg {
2028            name: 0 as *const libc::c_char,
2029            type_0: ARG_TYPE_STRING,
2030            key_spec_index: 0,
2031            token: 0 as *const libc::c_char,
2032            summary: 0 as *const libc::c_char,
2033            since: 0 as *const libc::c_char,
2034            flags: 0,
2035            deprecated_since: 0 as *const libc::c_char,
2036            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2037            num_args: 0,
2038        };
2039        init
2040    },
2041];
2042#[no_mangle]
2043pub static mut SETBIT_Args: [redisCommandArg; 4] = [
2044    {
2045        let mut init = redisCommandArg {
2046            name: b"key\0" as *const u8 as *const libc::c_char,
2047            type_0: ARG_TYPE_KEY,
2048            key_spec_index: 0 as libc::c_int,
2049            token: 0 as *const libc::c_char,
2050            summary: 0 as *const libc::c_char,
2051            since: 0 as *const libc::c_char,
2052            flags: 0 as libc::c_int,
2053            deprecated_since: 0 as *const libc::c_char,
2054            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2055            num_args: 0,
2056        };
2057        init
2058    },
2059    {
2060        let mut init = redisCommandArg {
2061            name: b"offset\0" as *const u8 as *const libc::c_char,
2062            type_0: ARG_TYPE_INTEGER,
2063            key_spec_index: -(1 as libc::c_int),
2064            token: 0 as *const libc::c_char,
2065            summary: 0 as *const libc::c_char,
2066            since: 0 as *const libc::c_char,
2067            flags: 0 as libc::c_int,
2068            deprecated_since: 0 as *const libc::c_char,
2069            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2070            num_args: 0,
2071        };
2072        init
2073    },
2074    {
2075        let mut init = redisCommandArg {
2076            name: b"value\0" as *const u8 as *const libc::c_char,
2077            type_0: ARG_TYPE_INTEGER,
2078            key_spec_index: -(1 as libc::c_int),
2079            token: 0 as *const libc::c_char,
2080            summary: 0 as *const libc::c_char,
2081            since: 0 as *const libc::c_char,
2082            flags: 0 as libc::c_int,
2083            deprecated_since: 0 as *const libc::c_char,
2084            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2085            num_args: 0,
2086        };
2087        init
2088    },
2089    {
2090        let mut init = redisCommandArg {
2091            name: 0 as *const libc::c_char,
2092            type_0: ARG_TYPE_STRING,
2093            key_spec_index: 0,
2094            token: 0 as *const libc::c_char,
2095            summary: 0 as *const libc::c_char,
2096            since: 0 as *const libc::c_char,
2097            flags: 0,
2098            deprecated_since: 0 as *const libc::c_char,
2099            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2100            num_args: 0,
2101        };
2102        init
2103    },
2104];
2105#[no_mangle]
2106pub static mut CLUSTER_ADDSLOTS_Args: [redisCommandArg; 2] = [
2107    {
2108        let mut init = redisCommandArg {
2109            name: b"slot\0" as *const u8 as *const libc::c_char,
2110            type_0: ARG_TYPE_INTEGER,
2111            key_spec_index: -(1 as libc::c_int),
2112            token: 0 as *const libc::c_char,
2113            summary: 0 as *const libc::c_char,
2114            since: 0 as *const libc::c_char,
2115            flags: (1 as libc::c_int) << 1 as libc::c_int,
2116            deprecated_since: 0 as *const libc::c_char,
2117            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2118            num_args: 0,
2119        };
2120        init
2121    },
2122    {
2123        let mut init = redisCommandArg {
2124            name: 0 as *const libc::c_char,
2125            type_0: ARG_TYPE_STRING,
2126            key_spec_index: 0,
2127            token: 0 as *const libc::c_char,
2128            summary: 0 as *const libc::c_char,
2129            since: 0 as *const libc::c_char,
2130            flags: 0,
2131            deprecated_since: 0 as *const libc::c_char,
2132            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2133            num_args: 0,
2134        };
2135        init
2136    },
2137];
2138#[no_mangle]
2139pub static mut CLUSTER_ADDSLOTSRANGE_start_slot_end_slot_Subargs: [redisCommandArg; 3] = [
2140    {
2141        let mut init = redisCommandArg {
2142            name: b"start-slot\0" as *const u8 as *const libc::c_char,
2143            type_0: ARG_TYPE_INTEGER,
2144            key_spec_index: -(1 as libc::c_int),
2145            token: 0 as *const libc::c_char,
2146            summary: 0 as *const libc::c_char,
2147            since: 0 as *const libc::c_char,
2148            flags: 0 as libc::c_int,
2149            deprecated_since: 0 as *const libc::c_char,
2150            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2151            num_args: 0,
2152        };
2153        init
2154    },
2155    {
2156        let mut init = redisCommandArg {
2157            name: b"end-slot\0" as *const u8 as *const libc::c_char,
2158            type_0: ARG_TYPE_INTEGER,
2159            key_spec_index: -(1 as libc::c_int),
2160            token: 0 as *const libc::c_char,
2161            summary: 0 as *const libc::c_char,
2162            since: 0 as *const libc::c_char,
2163            flags: 0 as libc::c_int,
2164            deprecated_since: 0 as *const libc::c_char,
2165            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2166            num_args: 0,
2167        };
2168        init
2169    },
2170    {
2171        let mut init = redisCommandArg {
2172            name: 0 as *const libc::c_char,
2173            type_0: ARG_TYPE_STRING,
2174            key_spec_index: 0,
2175            token: 0 as *const libc::c_char,
2176            summary: 0 as *const libc::c_char,
2177            since: 0 as *const libc::c_char,
2178            flags: 0,
2179            deprecated_since: 0 as *const libc::c_char,
2180            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2181            num_args: 0,
2182        };
2183        init
2184    },
2185];
2186#[no_mangle]
2187pub static mut CLUSTER_ADDSLOTSRANGE_Args: [redisCommandArg; 2] = unsafe {
2188    [
2189        {
2190            let mut init = redisCommandArg {
2191                name: b"start-slot_end-slot\0" as *const u8 as *const libc::c_char,
2192                type_0: ARG_TYPE_BLOCK,
2193                key_spec_index: -(1 as libc::c_int),
2194                token: 0 as *const libc::c_char,
2195                summary: 0 as *const libc::c_char,
2196                since: 0 as *const libc::c_char,
2197                flags: (1 as libc::c_int) << 1 as libc::c_int,
2198                deprecated_since: 0 as *const libc::c_char,
2199                subargs: CLUSTER_ADDSLOTSRANGE_start_slot_end_slot_Subargs.as_ptr()
2200                    as *mut _,
2201                num_args: 0,
2202            };
2203            init
2204        },
2205        {
2206            let mut init = redisCommandArg {
2207                name: 0 as *const libc::c_char,
2208                type_0: ARG_TYPE_STRING,
2209                key_spec_index: 0,
2210                token: 0 as *const libc::c_char,
2211                summary: 0 as *const libc::c_char,
2212                since: 0 as *const libc::c_char,
2213                flags: 0,
2214                deprecated_since: 0 as *const libc::c_char,
2215                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2216                num_args: 0,
2217            };
2218            init
2219        },
2220    ]
2221};
2222#[no_mangle]
2223pub static mut CLUSTER_BUMPEPOCH_tips: [*const libc::c_char; 2] = [
2224    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2225    0 as *const libc::c_char,
2226];
2227#[no_mangle]
2228pub static mut CLUSTER_COUNT_FAILURE_REPORTS_tips: [*const libc::c_char; 2] = [
2229    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2230    0 as *const libc::c_char,
2231];
2232#[no_mangle]
2233pub static mut CLUSTER_COUNT_FAILURE_REPORTS_Args: [redisCommandArg; 2] = [
2234    {
2235        let mut init = redisCommandArg {
2236            name: b"node-id\0" as *const u8 as *const libc::c_char,
2237            type_0: ARG_TYPE_STRING,
2238            key_spec_index: -(1 as libc::c_int),
2239            token: 0 as *const libc::c_char,
2240            summary: 0 as *const libc::c_char,
2241            since: 0 as *const libc::c_char,
2242            flags: 0 as libc::c_int,
2243            deprecated_since: 0 as *const libc::c_char,
2244            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2245            num_args: 0,
2246        };
2247        init
2248    },
2249    {
2250        let mut init = redisCommandArg {
2251            name: 0 as *const libc::c_char,
2252            type_0: ARG_TYPE_STRING,
2253            key_spec_index: 0,
2254            token: 0 as *const libc::c_char,
2255            summary: 0 as *const libc::c_char,
2256            since: 0 as *const libc::c_char,
2257            flags: 0,
2258            deprecated_since: 0 as *const libc::c_char,
2259            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2260            num_args: 0,
2261        };
2262        init
2263    },
2264];
2265#[no_mangle]
2266pub static mut CLUSTER_COUNTKEYSINSLOT_Args: [redisCommandArg; 2] = [
2267    {
2268        let mut init = redisCommandArg {
2269            name: b"slot\0" as *const u8 as *const libc::c_char,
2270            type_0: ARG_TYPE_INTEGER,
2271            key_spec_index: -(1 as libc::c_int),
2272            token: 0 as *const libc::c_char,
2273            summary: 0 as *const libc::c_char,
2274            since: 0 as *const libc::c_char,
2275            flags: 0 as libc::c_int,
2276            deprecated_since: 0 as *const libc::c_char,
2277            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2278            num_args: 0,
2279        };
2280        init
2281    },
2282    {
2283        let mut init = redisCommandArg {
2284            name: 0 as *const libc::c_char,
2285            type_0: ARG_TYPE_STRING,
2286            key_spec_index: 0,
2287            token: 0 as *const libc::c_char,
2288            summary: 0 as *const libc::c_char,
2289            since: 0 as *const libc::c_char,
2290            flags: 0,
2291            deprecated_since: 0 as *const libc::c_char,
2292            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2293            num_args: 0,
2294        };
2295        init
2296    },
2297];
2298#[no_mangle]
2299pub static mut CLUSTER_DELSLOTS_Args: [redisCommandArg; 2] = [
2300    {
2301        let mut init = redisCommandArg {
2302            name: b"slot\0" as *const u8 as *const libc::c_char,
2303            type_0: ARG_TYPE_INTEGER,
2304            key_spec_index: -(1 as libc::c_int),
2305            token: 0 as *const libc::c_char,
2306            summary: 0 as *const libc::c_char,
2307            since: 0 as *const libc::c_char,
2308            flags: (1 as libc::c_int) << 1 as libc::c_int,
2309            deprecated_since: 0 as *const libc::c_char,
2310            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2311            num_args: 0,
2312        };
2313        init
2314    },
2315    {
2316        let mut init = redisCommandArg {
2317            name: 0 as *const libc::c_char,
2318            type_0: ARG_TYPE_STRING,
2319            key_spec_index: 0,
2320            token: 0 as *const libc::c_char,
2321            summary: 0 as *const libc::c_char,
2322            since: 0 as *const libc::c_char,
2323            flags: 0,
2324            deprecated_since: 0 as *const libc::c_char,
2325            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2326            num_args: 0,
2327        };
2328        init
2329    },
2330];
2331#[no_mangle]
2332pub static mut CLUSTER_DELSLOTSRANGE_start_slot_end_slot_Subargs: [redisCommandArg; 3] = [
2333    {
2334        let mut init = redisCommandArg {
2335            name: b"start-slot\0" as *const u8 as *const libc::c_char,
2336            type_0: ARG_TYPE_INTEGER,
2337            key_spec_index: -(1 as libc::c_int),
2338            token: 0 as *const libc::c_char,
2339            summary: 0 as *const libc::c_char,
2340            since: 0 as *const libc::c_char,
2341            flags: 0 as libc::c_int,
2342            deprecated_since: 0 as *const libc::c_char,
2343            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2344            num_args: 0,
2345        };
2346        init
2347    },
2348    {
2349        let mut init = redisCommandArg {
2350            name: b"end-slot\0" as *const u8 as *const libc::c_char,
2351            type_0: ARG_TYPE_INTEGER,
2352            key_spec_index: -(1 as libc::c_int),
2353            token: 0 as *const libc::c_char,
2354            summary: 0 as *const libc::c_char,
2355            since: 0 as *const libc::c_char,
2356            flags: 0 as libc::c_int,
2357            deprecated_since: 0 as *const libc::c_char,
2358            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2359            num_args: 0,
2360        };
2361        init
2362    },
2363    {
2364        let mut init = redisCommandArg {
2365            name: 0 as *const libc::c_char,
2366            type_0: ARG_TYPE_STRING,
2367            key_spec_index: 0,
2368            token: 0 as *const libc::c_char,
2369            summary: 0 as *const libc::c_char,
2370            since: 0 as *const libc::c_char,
2371            flags: 0,
2372            deprecated_since: 0 as *const libc::c_char,
2373            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2374            num_args: 0,
2375        };
2376        init
2377    },
2378];
2379#[no_mangle]
2380pub static mut CLUSTER_DELSLOTSRANGE_Args: [redisCommandArg; 2] = unsafe {
2381    [
2382        {
2383            let mut init = redisCommandArg {
2384                name: b"start-slot_end-slot\0" as *const u8 as *const libc::c_char,
2385                type_0: ARG_TYPE_BLOCK,
2386                key_spec_index: -(1 as libc::c_int),
2387                token: 0 as *const libc::c_char,
2388                summary: 0 as *const libc::c_char,
2389                since: 0 as *const libc::c_char,
2390                flags: (1 as libc::c_int) << 1 as libc::c_int,
2391                deprecated_since: 0 as *const libc::c_char,
2392                subargs: CLUSTER_DELSLOTSRANGE_start_slot_end_slot_Subargs.as_ptr()
2393                    as *mut _,
2394                num_args: 0,
2395            };
2396            init
2397        },
2398        {
2399            let mut init = redisCommandArg {
2400                name: 0 as *const libc::c_char,
2401                type_0: ARG_TYPE_STRING,
2402                key_spec_index: 0,
2403                token: 0 as *const libc::c_char,
2404                summary: 0 as *const libc::c_char,
2405                since: 0 as *const libc::c_char,
2406                flags: 0,
2407                deprecated_since: 0 as *const libc::c_char,
2408                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2409                num_args: 0,
2410            };
2411            init
2412        },
2413    ]
2414};
2415#[no_mangle]
2416pub static mut CLUSTER_FAILOVER_options_Subargs: [redisCommandArg; 3] = [
2417    {
2418        let mut init = redisCommandArg {
2419            name: b"force\0" as *const u8 as *const libc::c_char,
2420            type_0: ARG_TYPE_PURE_TOKEN,
2421            key_spec_index: -(1 as libc::c_int),
2422            token: b"FORCE\0" as *const u8 as *const libc::c_char,
2423            summary: 0 as *const libc::c_char,
2424            since: 0 as *const libc::c_char,
2425            flags: 0 as libc::c_int,
2426            deprecated_since: 0 as *const libc::c_char,
2427            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2428            num_args: 0,
2429        };
2430        init
2431    },
2432    {
2433        let mut init = redisCommandArg {
2434            name: b"takeover\0" as *const u8 as *const libc::c_char,
2435            type_0: ARG_TYPE_PURE_TOKEN,
2436            key_spec_index: -(1 as libc::c_int),
2437            token: b"TAKEOVER\0" as *const u8 as *const libc::c_char,
2438            summary: 0 as *const libc::c_char,
2439            since: 0 as *const libc::c_char,
2440            flags: 0 as libc::c_int,
2441            deprecated_since: 0 as *const libc::c_char,
2442            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2443            num_args: 0,
2444        };
2445        init
2446    },
2447    {
2448        let mut init = redisCommandArg {
2449            name: 0 as *const libc::c_char,
2450            type_0: ARG_TYPE_STRING,
2451            key_spec_index: 0,
2452            token: 0 as *const libc::c_char,
2453            summary: 0 as *const libc::c_char,
2454            since: 0 as *const libc::c_char,
2455            flags: 0,
2456            deprecated_since: 0 as *const libc::c_char,
2457            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2458            num_args: 0,
2459        };
2460        init
2461    },
2462];
2463#[no_mangle]
2464pub static mut CLUSTER_FAILOVER_Args: [redisCommandArg; 2] = unsafe {
2465    [
2466        {
2467            let mut init = redisCommandArg {
2468                name: b"options\0" as *const u8 as *const libc::c_char,
2469                type_0: ARG_TYPE_ONEOF,
2470                key_spec_index: -(1 as libc::c_int),
2471                token: 0 as *const libc::c_char,
2472                summary: 0 as *const libc::c_char,
2473                since: 0 as *const libc::c_char,
2474                flags: (1 as libc::c_int) << 0 as libc::c_int,
2475                deprecated_since: 0 as *const libc::c_char,
2476                subargs: CLUSTER_FAILOVER_options_Subargs.as_ptr() as *mut _,
2477                num_args: 0,
2478            };
2479            init
2480        },
2481        {
2482            let mut init = redisCommandArg {
2483                name: 0 as *const libc::c_char,
2484                type_0: ARG_TYPE_STRING,
2485                key_spec_index: 0,
2486                token: 0 as *const libc::c_char,
2487                summary: 0 as *const libc::c_char,
2488                since: 0 as *const libc::c_char,
2489                flags: 0,
2490                deprecated_since: 0 as *const libc::c_char,
2491                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2492                num_args: 0,
2493            };
2494            init
2495        },
2496    ]
2497};
2498#[no_mangle]
2499pub static mut CLUSTER_FORGET_Args: [redisCommandArg; 2] = [
2500    {
2501        let mut init = redisCommandArg {
2502            name: b"node-id\0" as *const u8 as *const libc::c_char,
2503            type_0: ARG_TYPE_STRING,
2504            key_spec_index: -(1 as libc::c_int),
2505            token: 0 as *const libc::c_char,
2506            summary: 0 as *const libc::c_char,
2507            since: 0 as *const libc::c_char,
2508            flags: 0 as libc::c_int,
2509            deprecated_since: 0 as *const libc::c_char,
2510            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2511            num_args: 0,
2512        };
2513        init
2514    },
2515    {
2516        let mut init = redisCommandArg {
2517            name: 0 as *const libc::c_char,
2518            type_0: ARG_TYPE_STRING,
2519            key_spec_index: 0,
2520            token: 0 as *const libc::c_char,
2521            summary: 0 as *const libc::c_char,
2522            since: 0 as *const libc::c_char,
2523            flags: 0,
2524            deprecated_since: 0 as *const libc::c_char,
2525            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2526            num_args: 0,
2527        };
2528        init
2529    },
2530];
2531#[no_mangle]
2532pub static mut CLUSTER_GETKEYSINSLOT_tips: [*const libc::c_char; 2] = [
2533    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2534    0 as *const libc::c_char,
2535];
2536#[no_mangle]
2537pub static mut CLUSTER_GETKEYSINSLOT_Args: [redisCommandArg; 3] = [
2538    {
2539        let mut init = redisCommandArg {
2540            name: b"slot\0" as *const u8 as *const libc::c_char,
2541            type_0: ARG_TYPE_INTEGER,
2542            key_spec_index: -(1 as libc::c_int),
2543            token: 0 as *const libc::c_char,
2544            summary: 0 as *const libc::c_char,
2545            since: 0 as *const libc::c_char,
2546            flags: 0 as libc::c_int,
2547            deprecated_since: 0 as *const libc::c_char,
2548            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2549            num_args: 0,
2550        };
2551        init
2552    },
2553    {
2554        let mut init = redisCommandArg {
2555            name: b"count\0" as *const u8 as *const libc::c_char,
2556            type_0: ARG_TYPE_INTEGER,
2557            key_spec_index: -(1 as libc::c_int),
2558            token: 0 as *const libc::c_char,
2559            summary: 0 as *const libc::c_char,
2560            since: 0 as *const libc::c_char,
2561            flags: 0 as libc::c_int,
2562            deprecated_since: 0 as *const libc::c_char,
2563            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2564            num_args: 0,
2565        };
2566        init
2567    },
2568    {
2569        let mut init = redisCommandArg {
2570            name: 0 as *const libc::c_char,
2571            type_0: ARG_TYPE_STRING,
2572            key_spec_index: 0,
2573            token: 0 as *const libc::c_char,
2574            summary: 0 as *const libc::c_char,
2575            since: 0 as *const libc::c_char,
2576            flags: 0,
2577            deprecated_since: 0 as *const libc::c_char,
2578            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2579            num_args: 0,
2580        };
2581        init
2582    },
2583];
2584#[no_mangle]
2585pub static mut CLUSTER_INFO_tips: [*const libc::c_char; 2] = [
2586    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2587    0 as *const libc::c_char,
2588];
2589#[no_mangle]
2590pub static mut CLUSTER_KEYSLOT_Args: [redisCommandArg; 2] = [
2591    {
2592        let mut init = redisCommandArg {
2593            name: b"key\0" as *const u8 as *const libc::c_char,
2594            type_0: ARG_TYPE_STRING,
2595            key_spec_index: -(1 as libc::c_int),
2596            token: 0 as *const libc::c_char,
2597            summary: 0 as *const libc::c_char,
2598            since: 0 as *const libc::c_char,
2599            flags: 0 as libc::c_int,
2600            deprecated_since: 0 as *const libc::c_char,
2601            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2602            num_args: 0,
2603        };
2604        init
2605    },
2606    {
2607        let mut init = redisCommandArg {
2608            name: 0 as *const libc::c_char,
2609            type_0: ARG_TYPE_STRING,
2610            key_spec_index: 0,
2611            token: 0 as *const libc::c_char,
2612            summary: 0 as *const libc::c_char,
2613            since: 0 as *const libc::c_char,
2614            flags: 0,
2615            deprecated_since: 0 as *const libc::c_char,
2616            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2617            num_args: 0,
2618        };
2619        init
2620    },
2621];
2622#[no_mangle]
2623pub static mut CLUSTER_LINKS_tips: [*const libc::c_char; 2] = [
2624    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2625    0 as *const libc::c_char,
2626];
2627#[no_mangle]
2628pub static mut CLUSTER_MEET_History: [commandHistory; 2] = [
2629    {
2630        let mut init = commandHistory {
2631            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
2632            changes: b"Added the optional `cluster_bus_port` argument.\0" as *const u8
2633                as *const libc::c_char,
2634        };
2635        init
2636    },
2637    {
2638        let mut init = commandHistory {
2639            since: 0 as *const libc::c_char,
2640            changes: 0 as *const libc::c_char,
2641        };
2642        init
2643    },
2644];
2645#[no_mangle]
2646pub static mut CLUSTER_MEET_Args: [redisCommandArg; 4] = [
2647    {
2648        let mut init = redisCommandArg {
2649            name: b"ip\0" as *const u8 as *const libc::c_char,
2650            type_0: ARG_TYPE_STRING,
2651            key_spec_index: -(1 as libc::c_int),
2652            token: 0 as *const libc::c_char,
2653            summary: 0 as *const libc::c_char,
2654            since: 0 as *const libc::c_char,
2655            flags: 0 as libc::c_int,
2656            deprecated_since: 0 as *const libc::c_char,
2657            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2658            num_args: 0,
2659        };
2660        init
2661    },
2662    {
2663        let mut init = redisCommandArg {
2664            name: b"port\0" as *const u8 as *const libc::c_char,
2665            type_0: ARG_TYPE_INTEGER,
2666            key_spec_index: -(1 as libc::c_int),
2667            token: 0 as *const libc::c_char,
2668            summary: 0 as *const libc::c_char,
2669            since: 0 as *const libc::c_char,
2670            flags: 0 as libc::c_int,
2671            deprecated_since: 0 as *const libc::c_char,
2672            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2673            num_args: 0,
2674        };
2675        init
2676    },
2677    {
2678        let mut init = redisCommandArg {
2679            name: b"cluster_bus_port\0" as *const u8 as *const libc::c_char,
2680            type_0: ARG_TYPE_INTEGER,
2681            key_spec_index: -(1 as libc::c_int),
2682            token: 0 as *const libc::c_char,
2683            summary: 0 as *const libc::c_char,
2684            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
2685            flags: (1 as libc::c_int) << 0 as libc::c_int,
2686            deprecated_since: 0 as *const libc::c_char,
2687            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2688            num_args: 0,
2689        };
2690        init
2691    },
2692    {
2693        let mut init = redisCommandArg {
2694            name: 0 as *const libc::c_char,
2695            type_0: ARG_TYPE_STRING,
2696            key_spec_index: 0,
2697            token: 0 as *const libc::c_char,
2698            summary: 0 as *const libc::c_char,
2699            since: 0 as *const libc::c_char,
2700            flags: 0,
2701            deprecated_since: 0 as *const libc::c_char,
2702            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2703            num_args: 0,
2704        };
2705        init
2706    },
2707];
2708#[no_mangle]
2709pub static mut CLUSTER_NODES_tips: [*const libc::c_char; 2] = [
2710    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2711    0 as *const libc::c_char,
2712];
2713#[no_mangle]
2714pub static mut CLUSTER_REPLICAS_tips: [*const libc::c_char; 2] = [
2715    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
2716    0 as *const libc::c_char,
2717];
2718#[no_mangle]
2719pub static mut CLUSTER_REPLICAS_Args: [redisCommandArg; 2] = [
2720    {
2721        let mut init = redisCommandArg {
2722            name: b"node-id\0" as *const u8 as *const libc::c_char,
2723            type_0: ARG_TYPE_STRING,
2724            key_spec_index: -(1 as libc::c_int),
2725            token: 0 as *const libc::c_char,
2726            summary: 0 as *const libc::c_char,
2727            since: 0 as *const libc::c_char,
2728            flags: 0 as libc::c_int,
2729            deprecated_since: 0 as *const libc::c_char,
2730            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2731            num_args: 0,
2732        };
2733        init
2734    },
2735    {
2736        let mut init = redisCommandArg {
2737            name: 0 as *const libc::c_char,
2738            type_0: ARG_TYPE_STRING,
2739            key_spec_index: 0,
2740            token: 0 as *const libc::c_char,
2741            summary: 0 as *const libc::c_char,
2742            since: 0 as *const libc::c_char,
2743            flags: 0,
2744            deprecated_since: 0 as *const libc::c_char,
2745            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2746            num_args: 0,
2747        };
2748        init
2749    },
2750];
2751#[no_mangle]
2752pub static mut CLUSTER_REPLICATE_Args: [redisCommandArg; 2] = [
2753    {
2754        let mut init = redisCommandArg {
2755            name: b"node-id\0" as *const u8 as *const libc::c_char,
2756            type_0: ARG_TYPE_STRING,
2757            key_spec_index: -(1 as libc::c_int),
2758            token: 0 as *const libc::c_char,
2759            summary: 0 as *const libc::c_char,
2760            since: 0 as *const libc::c_char,
2761            flags: 0 as libc::c_int,
2762            deprecated_since: 0 as *const libc::c_char,
2763            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2764            num_args: 0,
2765        };
2766        init
2767    },
2768    {
2769        let mut init = redisCommandArg {
2770            name: 0 as *const libc::c_char,
2771            type_0: ARG_TYPE_STRING,
2772            key_spec_index: 0,
2773            token: 0 as *const libc::c_char,
2774            summary: 0 as *const libc::c_char,
2775            since: 0 as *const libc::c_char,
2776            flags: 0,
2777            deprecated_since: 0 as *const libc::c_char,
2778            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2779            num_args: 0,
2780        };
2781        init
2782    },
2783];
2784#[no_mangle]
2785pub static mut CLUSTER_RESET_hard_soft_Subargs: [redisCommandArg; 3] = [
2786    {
2787        let mut init = redisCommandArg {
2788            name: b"hard\0" as *const u8 as *const libc::c_char,
2789            type_0: ARG_TYPE_PURE_TOKEN,
2790            key_spec_index: -(1 as libc::c_int),
2791            token: b"HARD\0" as *const u8 as *const libc::c_char,
2792            summary: 0 as *const libc::c_char,
2793            since: 0 as *const libc::c_char,
2794            flags: 0 as libc::c_int,
2795            deprecated_since: 0 as *const libc::c_char,
2796            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2797            num_args: 0,
2798        };
2799        init
2800    },
2801    {
2802        let mut init = redisCommandArg {
2803            name: b"soft\0" as *const u8 as *const libc::c_char,
2804            type_0: ARG_TYPE_PURE_TOKEN,
2805            key_spec_index: -(1 as libc::c_int),
2806            token: b"SOFT\0" as *const u8 as *const libc::c_char,
2807            summary: 0 as *const libc::c_char,
2808            since: 0 as *const libc::c_char,
2809            flags: 0 as libc::c_int,
2810            deprecated_since: 0 as *const libc::c_char,
2811            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2812            num_args: 0,
2813        };
2814        init
2815    },
2816    {
2817        let mut init = redisCommandArg {
2818            name: 0 as *const libc::c_char,
2819            type_0: ARG_TYPE_STRING,
2820            key_spec_index: 0,
2821            token: 0 as *const libc::c_char,
2822            summary: 0 as *const libc::c_char,
2823            since: 0 as *const libc::c_char,
2824            flags: 0,
2825            deprecated_since: 0 as *const libc::c_char,
2826            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2827            num_args: 0,
2828        };
2829        init
2830    },
2831];
2832#[no_mangle]
2833pub static mut CLUSTER_RESET_Args: [redisCommandArg; 2] = unsafe {
2834    [
2835        {
2836            let mut init = redisCommandArg {
2837                name: b"hard_soft\0" as *const u8 as *const libc::c_char,
2838                type_0: ARG_TYPE_ONEOF,
2839                key_spec_index: -(1 as libc::c_int),
2840                token: 0 as *const libc::c_char,
2841                summary: 0 as *const libc::c_char,
2842                since: 0 as *const libc::c_char,
2843                flags: (1 as libc::c_int) << 0 as libc::c_int,
2844                deprecated_since: 0 as *const libc::c_char,
2845                subargs: CLUSTER_RESET_hard_soft_Subargs.as_ptr() as *mut _,
2846                num_args: 0,
2847            };
2848            init
2849        },
2850        {
2851            let mut init = redisCommandArg {
2852                name: 0 as *const libc::c_char,
2853                type_0: ARG_TYPE_STRING,
2854                key_spec_index: 0,
2855                token: 0 as *const libc::c_char,
2856                summary: 0 as *const libc::c_char,
2857                since: 0 as *const libc::c_char,
2858                flags: 0,
2859                deprecated_since: 0 as *const libc::c_char,
2860                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2861                num_args: 0,
2862            };
2863            init
2864        },
2865    ]
2866};
2867#[no_mangle]
2868pub static mut CLUSTER_SET_CONFIG_EPOCH_Args: [redisCommandArg; 2] = [
2869    {
2870        let mut init = redisCommandArg {
2871            name: b"config-epoch\0" as *const u8 as *const libc::c_char,
2872            type_0: ARG_TYPE_INTEGER,
2873            key_spec_index: -(1 as libc::c_int),
2874            token: 0 as *const libc::c_char,
2875            summary: 0 as *const libc::c_char,
2876            since: 0 as *const libc::c_char,
2877            flags: 0 as libc::c_int,
2878            deprecated_since: 0 as *const libc::c_char,
2879            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2880            num_args: 0,
2881        };
2882        init
2883    },
2884    {
2885        let mut init = redisCommandArg {
2886            name: 0 as *const libc::c_char,
2887            type_0: ARG_TYPE_STRING,
2888            key_spec_index: 0,
2889            token: 0 as *const libc::c_char,
2890            summary: 0 as *const libc::c_char,
2891            since: 0 as *const libc::c_char,
2892            flags: 0,
2893            deprecated_since: 0 as *const libc::c_char,
2894            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2895            num_args: 0,
2896        };
2897        init
2898    },
2899];
2900#[no_mangle]
2901pub static mut CLUSTER_SETSLOT_subcommand_Subargs: [redisCommandArg; 5] = [
2902    {
2903        let mut init = redisCommandArg {
2904            name: b"node-id\0" as *const u8 as *const libc::c_char,
2905            type_0: ARG_TYPE_STRING,
2906            key_spec_index: -(1 as libc::c_int),
2907            token: b"IMPORTING\0" as *const u8 as *const libc::c_char,
2908            summary: 0 as *const libc::c_char,
2909            since: 0 as *const libc::c_char,
2910            flags: 0 as libc::c_int,
2911            deprecated_since: 0 as *const libc::c_char,
2912            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2913            num_args: 0,
2914        };
2915        init
2916    },
2917    {
2918        let mut init = redisCommandArg {
2919            name: b"node-id\0" as *const u8 as *const libc::c_char,
2920            type_0: ARG_TYPE_STRING,
2921            key_spec_index: -(1 as libc::c_int),
2922            token: b"MIGRATING\0" as *const u8 as *const libc::c_char,
2923            summary: 0 as *const libc::c_char,
2924            since: 0 as *const libc::c_char,
2925            flags: 0 as libc::c_int,
2926            deprecated_since: 0 as *const libc::c_char,
2927            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2928            num_args: 0,
2929        };
2930        init
2931    },
2932    {
2933        let mut init = redisCommandArg {
2934            name: b"node-id\0" as *const u8 as *const libc::c_char,
2935            type_0: ARG_TYPE_STRING,
2936            key_spec_index: -(1 as libc::c_int),
2937            token: b"NODE\0" as *const u8 as *const libc::c_char,
2938            summary: 0 as *const libc::c_char,
2939            since: 0 as *const libc::c_char,
2940            flags: 0 as libc::c_int,
2941            deprecated_since: 0 as *const libc::c_char,
2942            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2943            num_args: 0,
2944        };
2945        init
2946    },
2947    {
2948        let mut init = redisCommandArg {
2949            name: b"stable\0" as *const u8 as *const libc::c_char,
2950            type_0: ARG_TYPE_PURE_TOKEN,
2951            key_spec_index: -(1 as libc::c_int),
2952            token: b"STABLE\0" as *const u8 as *const libc::c_char,
2953            summary: 0 as *const libc::c_char,
2954            since: 0 as *const libc::c_char,
2955            flags: 0 as libc::c_int,
2956            deprecated_since: 0 as *const libc::c_char,
2957            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2958            num_args: 0,
2959        };
2960        init
2961    },
2962    {
2963        let mut init = redisCommandArg {
2964            name: 0 as *const libc::c_char,
2965            type_0: ARG_TYPE_STRING,
2966            key_spec_index: 0,
2967            token: 0 as *const libc::c_char,
2968            summary: 0 as *const libc::c_char,
2969            since: 0 as *const libc::c_char,
2970            flags: 0,
2971            deprecated_since: 0 as *const libc::c_char,
2972            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2973            num_args: 0,
2974        };
2975        init
2976    },
2977];
2978#[no_mangle]
2979pub static mut CLUSTER_SETSLOT_Args: [redisCommandArg; 3] = unsafe {
2980    [
2981        {
2982            let mut init = redisCommandArg {
2983                name: b"slot\0" as *const u8 as *const libc::c_char,
2984                type_0: ARG_TYPE_INTEGER,
2985                key_spec_index: -(1 as libc::c_int),
2986                token: 0 as *const libc::c_char,
2987                summary: 0 as *const libc::c_char,
2988                since: 0 as *const libc::c_char,
2989                flags: 0 as libc::c_int,
2990                deprecated_since: 0 as *const libc::c_char,
2991                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
2992                num_args: 0,
2993            };
2994            init
2995        },
2996        {
2997            let mut init = redisCommandArg {
2998                name: b"subcommand\0" as *const u8 as *const libc::c_char,
2999                type_0: ARG_TYPE_ONEOF,
3000                key_spec_index: -(1 as libc::c_int),
3001                token: 0 as *const libc::c_char,
3002                summary: 0 as *const libc::c_char,
3003                since: 0 as *const libc::c_char,
3004                flags: 0 as libc::c_int,
3005                deprecated_since: 0 as *const libc::c_char,
3006                subargs: CLUSTER_SETSLOT_subcommand_Subargs.as_ptr() as *mut _,
3007                num_args: 0,
3008            };
3009            init
3010        },
3011        {
3012            let mut init = redisCommandArg {
3013                name: 0 as *const libc::c_char,
3014                type_0: ARG_TYPE_STRING,
3015                key_spec_index: 0,
3016                token: 0 as *const libc::c_char,
3017                summary: 0 as *const libc::c_char,
3018                since: 0 as *const libc::c_char,
3019                flags: 0,
3020                deprecated_since: 0 as *const libc::c_char,
3021                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
3022                num_args: 0,
3023            };
3024            init
3025        },
3026    ]
3027};
3028#[no_mangle]
3029pub static mut CLUSTER_SHARDS_tips: [*const libc::c_char; 2] = [
3030    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
3031    0 as *const libc::c_char,
3032];
3033#[no_mangle]
3034pub static mut CLUSTER_SLAVES_tips: [*const libc::c_char; 2] = [
3035    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
3036    0 as *const libc::c_char,
3037];
3038#[no_mangle]
3039pub static mut CLUSTER_SLAVES_Args: [redisCommandArg; 2] = [
3040    {
3041        let mut init = redisCommandArg {
3042            name: b"node-id\0" as *const u8 as *const libc::c_char,
3043            type_0: ARG_TYPE_STRING,
3044            key_spec_index: -(1 as libc::c_int),
3045            token: 0 as *const libc::c_char,
3046            summary: 0 as *const libc::c_char,
3047            since: 0 as *const libc::c_char,
3048            flags: 0 as libc::c_int,
3049            deprecated_since: 0 as *const libc::c_char,
3050            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
3051            num_args: 0,
3052        };
3053        init
3054    },
3055    {
3056        let mut init = redisCommandArg {
3057            name: 0 as *const libc::c_char,
3058            type_0: ARG_TYPE_STRING,
3059            key_spec_index: 0,
3060            token: 0 as *const libc::c_char,
3061            summary: 0 as *const libc::c_char,
3062            since: 0 as *const libc::c_char,
3063            flags: 0,
3064            deprecated_since: 0 as *const libc::c_char,
3065            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
3066            num_args: 0,
3067        };
3068        init
3069    },
3070];
3071#[no_mangle]
3072pub static mut CLUSTER_SLOTS_History: [commandHistory; 3] = [
3073    {
3074        let mut init = commandHistory {
3075            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
3076            changes: b"Added node IDs.\0" as *const u8 as *const libc::c_char,
3077        };
3078        init
3079    },
3080    {
3081        let mut init = commandHistory {
3082            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
3083            changes: b"Added additional networking metadata field.\0" as *const u8
3084                as *const libc::c_char,
3085        };
3086        init
3087    },
3088    {
3089        let mut init = commandHistory {
3090            since: 0 as *const libc::c_char,
3091            changes: 0 as *const libc::c_char,
3092        };
3093        init
3094    },
3095];
3096#[no_mangle]
3097pub static mut CLUSTER_SLOTS_tips: [*const libc::c_char; 2] = [
3098    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
3099    0 as *const libc::c_char,
3100];
3101#[no_mangle]
3102pub static mut CLUSTER_Subcommands: [redisCommand; 28] = unsafe {
3103    [
3104        {
3105            let mut init = redisCommand {
3106                declared_name: b"addslots\0" as *const u8 as *const libc::c_char,
3107                summary: b"Assign new hash slots to receiving node\0" as *const u8
3108                    as *const libc::c_char,
3109                complexity: b"O(N) where N is the total number of hash slot arguments\0"
3110                    as *const u8 as *const libc::c_char,
3111                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3112                doc_flags: 0 as libc::c_int,
3113                replaced_by: 0 as *const libc::c_char,
3114                deprecated_since: 0 as *const libc::c_char,
3115                group: COMMAND_GROUP_CLUSTER,
3116                history: 0 as *const commandHistory as *mut commandHistory,
3117                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3118                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3119                arity: -(3 as libc::c_int),
3120                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3121                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3122                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3123                acl_categories: 0 as libc::c_int as uint64_t,
3124                key_specs_static: [keySpec {
3125                    notes: 0 as *const libc::c_char,
3126                    flags: 0,
3127                    begin_search_type: KSPEC_BS_INVALID,
3128                    bs: C2RustUnnamed_3 {
3129                        index: C2RustUnnamed_5 { pos: 0 },
3130                    },
3131                    find_keys_type: KSPEC_FK_INVALID,
3132                    fk: C2RustUnnamed_0 {
3133                        range: C2RustUnnamed_2 {
3134                            lastkey: 0,
3135                            keystep: 0,
3136                            limit: 0,
3137                        },
3138                    },
3139                }; 4],
3140                getkeys_proc: None,
3141                subcommands: 0 as *const redisCommand as *mut redisCommand,
3142                args: CLUSTER_ADDSLOTS_Args.as_ptr() as *mut _,
3143                microseconds: 0,
3144                calls: 0,
3145                rejected_calls: 0,
3146                failed_calls: 0,
3147                id: 0,
3148                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3149                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3150                key_specs: 0 as *const keySpec as *mut keySpec,
3151                legacy_range_key_spec: keySpec {
3152                    notes: 0 as *const libc::c_char,
3153                    flags: 0,
3154                    begin_search_type: KSPEC_BS_INVALID,
3155                    bs: C2RustUnnamed_3 {
3156                        index: C2RustUnnamed_5 { pos: 0 },
3157                    },
3158                    find_keys_type: KSPEC_FK_INVALID,
3159                    fk: C2RustUnnamed_0 {
3160                        range: C2RustUnnamed_2 {
3161                            lastkey: 0,
3162                            keystep: 0,
3163                            limit: 0,
3164                        },
3165                    },
3166                },
3167                num_args: 0,
3168                num_history: 0,
3169                num_tips: 0,
3170                key_specs_num: 0,
3171                key_specs_max: 0,
3172                subcommands_dict: 0 as *const dict as *mut dict,
3173                parent: 0 as *const redisCommand as *mut redisCommand,
3174                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3175            };
3176            init
3177        },
3178        {
3179            let mut init = redisCommand {
3180                declared_name: b"addslotsrange\0" as *const u8 as *const libc::c_char,
3181                summary: b"Assign new hash slots to receiving node\0" as *const u8
3182                    as *const libc::c_char,
3183                complexity: b"O(N) where N is the total number of the slots between the start slot and end slot arguments.\0"
3184                    as *const u8 as *const libc::c_char,
3185                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
3186                doc_flags: 0 as libc::c_int,
3187                replaced_by: 0 as *const libc::c_char,
3188                deprecated_since: 0 as *const libc::c_char,
3189                group: COMMAND_GROUP_CLUSTER,
3190                history: 0 as *const commandHistory as *mut commandHistory,
3191                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3192                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3193                arity: -(4 as libc::c_int),
3194                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3195                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3196                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3197                acl_categories: 0 as libc::c_int as uint64_t,
3198                key_specs_static: [keySpec {
3199                    notes: 0 as *const libc::c_char,
3200                    flags: 0,
3201                    begin_search_type: KSPEC_BS_INVALID,
3202                    bs: C2RustUnnamed_3 {
3203                        index: C2RustUnnamed_5 { pos: 0 },
3204                    },
3205                    find_keys_type: KSPEC_FK_INVALID,
3206                    fk: C2RustUnnamed_0 {
3207                        range: C2RustUnnamed_2 {
3208                            lastkey: 0,
3209                            keystep: 0,
3210                            limit: 0,
3211                        },
3212                    },
3213                }; 4],
3214                getkeys_proc: None,
3215                subcommands: 0 as *const redisCommand as *mut redisCommand,
3216                args: CLUSTER_ADDSLOTSRANGE_Args.as_ptr() as *mut _,
3217                microseconds: 0,
3218                calls: 0,
3219                rejected_calls: 0,
3220                failed_calls: 0,
3221                id: 0,
3222                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3223                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3224                key_specs: 0 as *const keySpec as *mut keySpec,
3225                legacy_range_key_spec: keySpec {
3226                    notes: 0 as *const libc::c_char,
3227                    flags: 0,
3228                    begin_search_type: KSPEC_BS_INVALID,
3229                    bs: C2RustUnnamed_3 {
3230                        index: C2RustUnnamed_5 { pos: 0 },
3231                    },
3232                    find_keys_type: KSPEC_FK_INVALID,
3233                    fk: C2RustUnnamed_0 {
3234                        range: C2RustUnnamed_2 {
3235                            lastkey: 0,
3236                            keystep: 0,
3237                            limit: 0,
3238                        },
3239                    },
3240                },
3241                num_args: 0,
3242                num_history: 0,
3243                num_tips: 0,
3244                key_specs_num: 0,
3245                key_specs_max: 0,
3246                subcommands_dict: 0 as *const dict as *mut dict,
3247                parent: 0 as *const redisCommand as *mut redisCommand,
3248                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3249            };
3250            init
3251        },
3252        {
3253            let mut init = redisCommand {
3254                declared_name: b"bumpepoch\0" as *const u8 as *const libc::c_char,
3255                summary: b"Advance the cluster config epoch\0" as *const u8
3256                    as *const libc::c_char,
3257                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3258                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3259                doc_flags: 0 as libc::c_int,
3260                replaced_by: 0 as *const libc::c_char,
3261                deprecated_since: 0 as *const libc::c_char,
3262                group: COMMAND_GROUP_CLUSTER,
3263                history: 0 as *const commandHistory as *mut commandHistory,
3264                tips: CLUSTER_BUMPEPOCH_tips.as_ptr() as *mut _,
3265                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3266                arity: 2 as libc::c_int,
3267                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3268                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3269                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3270                acl_categories: 0 as libc::c_int as uint64_t,
3271                key_specs_static: [keySpec {
3272                    notes: 0 as *const libc::c_char,
3273                    flags: 0,
3274                    begin_search_type: KSPEC_BS_INVALID,
3275                    bs: C2RustUnnamed_3 {
3276                        index: C2RustUnnamed_5 { pos: 0 },
3277                    },
3278                    find_keys_type: KSPEC_FK_INVALID,
3279                    fk: C2RustUnnamed_0 {
3280                        range: C2RustUnnamed_2 {
3281                            lastkey: 0,
3282                            keystep: 0,
3283                            limit: 0,
3284                        },
3285                    },
3286                }; 4],
3287                getkeys_proc: None,
3288                subcommands: 0 as *const redisCommand as *mut redisCommand,
3289                args: 0 as *const redisCommandArg as *mut redisCommandArg,
3290                microseconds: 0,
3291                calls: 0,
3292                rejected_calls: 0,
3293                failed_calls: 0,
3294                id: 0,
3295                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3296                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3297                key_specs: 0 as *const keySpec as *mut keySpec,
3298                legacy_range_key_spec: keySpec {
3299                    notes: 0 as *const libc::c_char,
3300                    flags: 0,
3301                    begin_search_type: KSPEC_BS_INVALID,
3302                    bs: C2RustUnnamed_3 {
3303                        index: C2RustUnnamed_5 { pos: 0 },
3304                    },
3305                    find_keys_type: KSPEC_FK_INVALID,
3306                    fk: C2RustUnnamed_0 {
3307                        range: C2RustUnnamed_2 {
3308                            lastkey: 0,
3309                            keystep: 0,
3310                            limit: 0,
3311                        },
3312                    },
3313                },
3314                num_args: 0,
3315                num_history: 0,
3316                num_tips: 0,
3317                key_specs_num: 0,
3318                key_specs_max: 0,
3319                subcommands_dict: 0 as *const dict as *mut dict,
3320                parent: 0 as *const redisCommand as *mut redisCommand,
3321                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3322            };
3323            init
3324        },
3325        {
3326            let mut init = redisCommand {
3327                declared_name: b"count-failure-reports\0" as *const u8
3328                    as *const libc::c_char,
3329                summary: b"Return the number of failure reports active for a given node\0"
3330                    as *const u8 as *const libc::c_char,
3331                complexity: b"O(N) where N is the number of failure reports\0"
3332                    as *const u8 as *const libc::c_char,
3333                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3334                doc_flags: 0 as libc::c_int,
3335                replaced_by: 0 as *const libc::c_char,
3336                deprecated_since: 0 as *const libc::c_char,
3337                group: COMMAND_GROUP_CLUSTER,
3338                history: 0 as *const commandHistory as *mut commandHistory,
3339                tips: CLUSTER_COUNT_FAILURE_REPORTS_tips.as_ptr() as *mut _,
3340                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3341                arity: 3 as libc::c_int,
3342                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
3343                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3344                acl_categories: 0 as libc::c_int as uint64_t,
3345                key_specs_static: [keySpec {
3346                    notes: 0 as *const libc::c_char,
3347                    flags: 0,
3348                    begin_search_type: KSPEC_BS_INVALID,
3349                    bs: C2RustUnnamed_3 {
3350                        index: C2RustUnnamed_5 { pos: 0 },
3351                    },
3352                    find_keys_type: KSPEC_FK_INVALID,
3353                    fk: C2RustUnnamed_0 {
3354                        range: C2RustUnnamed_2 {
3355                            lastkey: 0,
3356                            keystep: 0,
3357                            limit: 0,
3358                        },
3359                    },
3360                }; 4],
3361                getkeys_proc: None,
3362                subcommands: 0 as *const redisCommand as *mut redisCommand,
3363                args: CLUSTER_COUNT_FAILURE_REPORTS_Args.as_ptr() as *mut _,
3364                microseconds: 0,
3365                calls: 0,
3366                rejected_calls: 0,
3367                failed_calls: 0,
3368                id: 0,
3369                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3370                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3371                key_specs: 0 as *const keySpec as *mut keySpec,
3372                legacy_range_key_spec: keySpec {
3373                    notes: 0 as *const libc::c_char,
3374                    flags: 0,
3375                    begin_search_type: KSPEC_BS_INVALID,
3376                    bs: C2RustUnnamed_3 {
3377                        index: C2RustUnnamed_5 { pos: 0 },
3378                    },
3379                    find_keys_type: KSPEC_FK_INVALID,
3380                    fk: C2RustUnnamed_0 {
3381                        range: C2RustUnnamed_2 {
3382                            lastkey: 0,
3383                            keystep: 0,
3384                            limit: 0,
3385                        },
3386                    },
3387                },
3388                num_args: 0,
3389                num_history: 0,
3390                num_tips: 0,
3391                key_specs_num: 0,
3392                key_specs_max: 0,
3393                subcommands_dict: 0 as *const dict as *mut dict,
3394                parent: 0 as *const redisCommand as *mut redisCommand,
3395                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3396            };
3397            init
3398        },
3399        {
3400            let mut init = redisCommand {
3401                declared_name: b"countkeysinslot\0" as *const u8 as *const libc::c_char,
3402                summary: b"Return the number of local keys in the specified hash slot\0"
3403                    as *const u8 as *const libc::c_char,
3404                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3405                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3406                doc_flags: 0 as libc::c_int,
3407                replaced_by: 0 as *const libc::c_char,
3408                deprecated_since: 0 as *const libc::c_char,
3409                group: COMMAND_GROUP_CLUSTER,
3410                history: 0 as *const commandHistory as *mut commandHistory,
3411                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3412                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3413                arity: 3 as libc::c_int,
3414                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3415                acl_categories: 0 as libc::c_int as uint64_t,
3416                key_specs_static: [keySpec {
3417                    notes: 0 as *const libc::c_char,
3418                    flags: 0,
3419                    begin_search_type: KSPEC_BS_INVALID,
3420                    bs: C2RustUnnamed_3 {
3421                        index: C2RustUnnamed_5 { pos: 0 },
3422                    },
3423                    find_keys_type: KSPEC_FK_INVALID,
3424                    fk: C2RustUnnamed_0 {
3425                        range: C2RustUnnamed_2 {
3426                            lastkey: 0,
3427                            keystep: 0,
3428                            limit: 0,
3429                        },
3430                    },
3431                }; 4],
3432                getkeys_proc: None,
3433                subcommands: 0 as *const redisCommand as *mut redisCommand,
3434                args: CLUSTER_COUNTKEYSINSLOT_Args.as_ptr() as *mut _,
3435                microseconds: 0,
3436                calls: 0,
3437                rejected_calls: 0,
3438                failed_calls: 0,
3439                id: 0,
3440                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3441                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3442                key_specs: 0 as *const keySpec as *mut keySpec,
3443                legacy_range_key_spec: keySpec {
3444                    notes: 0 as *const libc::c_char,
3445                    flags: 0,
3446                    begin_search_type: KSPEC_BS_INVALID,
3447                    bs: C2RustUnnamed_3 {
3448                        index: C2RustUnnamed_5 { pos: 0 },
3449                    },
3450                    find_keys_type: KSPEC_FK_INVALID,
3451                    fk: C2RustUnnamed_0 {
3452                        range: C2RustUnnamed_2 {
3453                            lastkey: 0,
3454                            keystep: 0,
3455                            limit: 0,
3456                        },
3457                    },
3458                },
3459                num_args: 0,
3460                num_history: 0,
3461                num_tips: 0,
3462                key_specs_num: 0,
3463                key_specs_max: 0,
3464                subcommands_dict: 0 as *const dict as *mut dict,
3465                parent: 0 as *const redisCommand as *mut redisCommand,
3466                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3467            };
3468            init
3469        },
3470        {
3471            let mut init = redisCommand {
3472                declared_name: b"delslots\0" as *const u8 as *const libc::c_char,
3473                summary: b"Set hash slots as unbound in receiving node\0" as *const u8
3474                    as *const libc::c_char,
3475                complexity: b"O(N) where N is the total number of hash slot arguments\0"
3476                    as *const u8 as *const libc::c_char,
3477                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3478                doc_flags: 0 as libc::c_int,
3479                replaced_by: 0 as *const libc::c_char,
3480                deprecated_since: 0 as *const libc::c_char,
3481                group: COMMAND_GROUP_CLUSTER,
3482                history: 0 as *const commandHistory as *mut commandHistory,
3483                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3484                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3485                arity: -(3 as libc::c_int),
3486                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3487                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3488                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3489                acl_categories: 0 as libc::c_int as uint64_t,
3490                key_specs_static: [keySpec {
3491                    notes: 0 as *const libc::c_char,
3492                    flags: 0,
3493                    begin_search_type: KSPEC_BS_INVALID,
3494                    bs: C2RustUnnamed_3 {
3495                        index: C2RustUnnamed_5 { pos: 0 },
3496                    },
3497                    find_keys_type: KSPEC_FK_INVALID,
3498                    fk: C2RustUnnamed_0 {
3499                        range: C2RustUnnamed_2 {
3500                            lastkey: 0,
3501                            keystep: 0,
3502                            limit: 0,
3503                        },
3504                    },
3505                }; 4],
3506                getkeys_proc: None,
3507                subcommands: 0 as *const redisCommand as *mut redisCommand,
3508                args: CLUSTER_DELSLOTS_Args.as_ptr() as *mut _,
3509                microseconds: 0,
3510                calls: 0,
3511                rejected_calls: 0,
3512                failed_calls: 0,
3513                id: 0,
3514                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3515                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3516                key_specs: 0 as *const keySpec as *mut keySpec,
3517                legacy_range_key_spec: keySpec {
3518                    notes: 0 as *const libc::c_char,
3519                    flags: 0,
3520                    begin_search_type: KSPEC_BS_INVALID,
3521                    bs: C2RustUnnamed_3 {
3522                        index: C2RustUnnamed_5 { pos: 0 },
3523                    },
3524                    find_keys_type: KSPEC_FK_INVALID,
3525                    fk: C2RustUnnamed_0 {
3526                        range: C2RustUnnamed_2 {
3527                            lastkey: 0,
3528                            keystep: 0,
3529                            limit: 0,
3530                        },
3531                    },
3532                },
3533                num_args: 0,
3534                num_history: 0,
3535                num_tips: 0,
3536                key_specs_num: 0,
3537                key_specs_max: 0,
3538                subcommands_dict: 0 as *const dict as *mut dict,
3539                parent: 0 as *const redisCommand as *mut redisCommand,
3540                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3541            };
3542            init
3543        },
3544        {
3545            let mut init = redisCommand {
3546                declared_name: b"delslotsrange\0" as *const u8 as *const libc::c_char,
3547                summary: b"Set hash slots as unbound in receiving node\0" as *const u8
3548                    as *const libc::c_char,
3549                complexity: b"O(N) where N is the total number of the slots between the start slot and end slot arguments.\0"
3550                    as *const u8 as *const libc::c_char,
3551                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
3552                doc_flags: 0 as libc::c_int,
3553                replaced_by: 0 as *const libc::c_char,
3554                deprecated_since: 0 as *const libc::c_char,
3555                group: COMMAND_GROUP_CLUSTER,
3556                history: 0 as *const commandHistory as *mut commandHistory,
3557                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3558                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3559                arity: -(4 as libc::c_int),
3560                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3561                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3562                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3563                acl_categories: 0 as libc::c_int as uint64_t,
3564                key_specs_static: [keySpec {
3565                    notes: 0 as *const libc::c_char,
3566                    flags: 0,
3567                    begin_search_type: KSPEC_BS_INVALID,
3568                    bs: C2RustUnnamed_3 {
3569                        index: C2RustUnnamed_5 { pos: 0 },
3570                    },
3571                    find_keys_type: KSPEC_FK_INVALID,
3572                    fk: C2RustUnnamed_0 {
3573                        range: C2RustUnnamed_2 {
3574                            lastkey: 0,
3575                            keystep: 0,
3576                            limit: 0,
3577                        },
3578                    },
3579                }; 4],
3580                getkeys_proc: None,
3581                subcommands: 0 as *const redisCommand as *mut redisCommand,
3582                args: CLUSTER_DELSLOTSRANGE_Args.as_ptr() as *mut _,
3583                microseconds: 0,
3584                calls: 0,
3585                rejected_calls: 0,
3586                failed_calls: 0,
3587                id: 0,
3588                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3589                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3590                key_specs: 0 as *const keySpec as *mut keySpec,
3591                legacy_range_key_spec: keySpec {
3592                    notes: 0 as *const libc::c_char,
3593                    flags: 0,
3594                    begin_search_type: KSPEC_BS_INVALID,
3595                    bs: C2RustUnnamed_3 {
3596                        index: C2RustUnnamed_5 { pos: 0 },
3597                    },
3598                    find_keys_type: KSPEC_FK_INVALID,
3599                    fk: C2RustUnnamed_0 {
3600                        range: C2RustUnnamed_2 {
3601                            lastkey: 0,
3602                            keystep: 0,
3603                            limit: 0,
3604                        },
3605                    },
3606                },
3607                num_args: 0,
3608                num_history: 0,
3609                num_tips: 0,
3610                key_specs_num: 0,
3611                key_specs_max: 0,
3612                subcommands_dict: 0 as *const dict as *mut dict,
3613                parent: 0 as *const redisCommand as *mut redisCommand,
3614                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3615            };
3616            init
3617        },
3618        {
3619            let mut init = redisCommand {
3620                declared_name: b"failover\0" as *const u8 as *const libc::c_char,
3621                summary: b"Forces a replica to perform a manual failover of its master.\0"
3622                    as *const u8 as *const libc::c_char,
3623                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3624                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3625                doc_flags: 0 as libc::c_int,
3626                replaced_by: 0 as *const libc::c_char,
3627                deprecated_since: 0 as *const libc::c_char,
3628                group: COMMAND_GROUP_CLUSTER,
3629                history: 0 as *const commandHistory as *mut commandHistory,
3630                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3631                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3632                arity: -(2 as libc::c_int),
3633                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3634                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3635                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3636                acl_categories: 0 as libc::c_int as uint64_t,
3637                key_specs_static: [keySpec {
3638                    notes: 0 as *const libc::c_char,
3639                    flags: 0,
3640                    begin_search_type: KSPEC_BS_INVALID,
3641                    bs: C2RustUnnamed_3 {
3642                        index: C2RustUnnamed_5 { pos: 0 },
3643                    },
3644                    find_keys_type: KSPEC_FK_INVALID,
3645                    fk: C2RustUnnamed_0 {
3646                        range: C2RustUnnamed_2 {
3647                            lastkey: 0,
3648                            keystep: 0,
3649                            limit: 0,
3650                        },
3651                    },
3652                }; 4],
3653                getkeys_proc: None,
3654                subcommands: 0 as *const redisCommand as *mut redisCommand,
3655                args: CLUSTER_FAILOVER_Args.as_ptr() as *mut _,
3656                microseconds: 0,
3657                calls: 0,
3658                rejected_calls: 0,
3659                failed_calls: 0,
3660                id: 0,
3661                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3662                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3663                key_specs: 0 as *const keySpec as *mut keySpec,
3664                legacy_range_key_spec: keySpec {
3665                    notes: 0 as *const libc::c_char,
3666                    flags: 0,
3667                    begin_search_type: KSPEC_BS_INVALID,
3668                    bs: C2RustUnnamed_3 {
3669                        index: C2RustUnnamed_5 { pos: 0 },
3670                    },
3671                    find_keys_type: KSPEC_FK_INVALID,
3672                    fk: C2RustUnnamed_0 {
3673                        range: C2RustUnnamed_2 {
3674                            lastkey: 0,
3675                            keystep: 0,
3676                            limit: 0,
3677                        },
3678                    },
3679                },
3680                num_args: 0,
3681                num_history: 0,
3682                num_tips: 0,
3683                key_specs_num: 0,
3684                key_specs_max: 0,
3685                subcommands_dict: 0 as *const dict as *mut dict,
3686                parent: 0 as *const redisCommand as *mut redisCommand,
3687                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3688            };
3689            init
3690        },
3691        {
3692            let mut init = redisCommand {
3693                declared_name: b"flushslots\0" as *const u8 as *const libc::c_char,
3694                summary: b"Delete a node's own slots information\0" as *const u8
3695                    as *const libc::c_char,
3696                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3697                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3698                doc_flags: 0 as libc::c_int,
3699                replaced_by: 0 as *const libc::c_char,
3700                deprecated_since: 0 as *const libc::c_char,
3701                group: COMMAND_GROUP_CLUSTER,
3702                history: 0 as *const commandHistory as *mut commandHistory,
3703                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3704                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3705                arity: 2 as libc::c_int,
3706                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3707                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3708                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3709                acl_categories: 0 as libc::c_int as uint64_t,
3710                key_specs_static: [keySpec {
3711                    notes: 0 as *const libc::c_char,
3712                    flags: 0,
3713                    begin_search_type: KSPEC_BS_INVALID,
3714                    bs: C2RustUnnamed_3 {
3715                        index: C2RustUnnamed_5 { pos: 0 },
3716                    },
3717                    find_keys_type: KSPEC_FK_INVALID,
3718                    fk: C2RustUnnamed_0 {
3719                        range: C2RustUnnamed_2 {
3720                            lastkey: 0,
3721                            keystep: 0,
3722                            limit: 0,
3723                        },
3724                    },
3725                }; 4],
3726                getkeys_proc: None,
3727                subcommands: 0 as *const redisCommand as *mut redisCommand,
3728                args: 0 as *const redisCommandArg as *mut redisCommandArg,
3729                microseconds: 0,
3730                calls: 0,
3731                rejected_calls: 0,
3732                failed_calls: 0,
3733                id: 0,
3734                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3735                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3736                key_specs: 0 as *const keySpec as *mut keySpec,
3737                legacy_range_key_spec: keySpec {
3738                    notes: 0 as *const libc::c_char,
3739                    flags: 0,
3740                    begin_search_type: KSPEC_BS_INVALID,
3741                    bs: C2RustUnnamed_3 {
3742                        index: C2RustUnnamed_5 { pos: 0 },
3743                    },
3744                    find_keys_type: KSPEC_FK_INVALID,
3745                    fk: C2RustUnnamed_0 {
3746                        range: C2RustUnnamed_2 {
3747                            lastkey: 0,
3748                            keystep: 0,
3749                            limit: 0,
3750                        },
3751                    },
3752                },
3753                num_args: 0,
3754                num_history: 0,
3755                num_tips: 0,
3756                key_specs_num: 0,
3757                key_specs_max: 0,
3758                subcommands_dict: 0 as *const dict as *mut dict,
3759                parent: 0 as *const redisCommand as *mut redisCommand,
3760                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3761            };
3762            init
3763        },
3764        {
3765            let mut init = redisCommand {
3766                declared_name: b"forget\0" as *const u8 as *const libc::c_char,
3767                summary: b"Remove a node from the nodes table\0" as *const u8
3768                    as *const libc::c_char,
3769                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3770                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3771                doc_flags: 0 as libc::c_int,
3772                replaced_by: 0 as *const libc::c_char,
3773                deprecated_since: 0 as *const libc::c_char,
3774                group: COMMAND_GROUP_CLUSTER,
3775                history: 0 as *const commandHistory as *mut commandHistory,
3776                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3777                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3778                arity: 3 as libc::c_int,
3779                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
3780                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
3781                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3782                acl_categories: 0 as libc::c_int as uint64_t,
3783                key_specs_static: [keySpec {
3784                    notes: 0 as *const libc::c_char,
3785                    flags: 0,
3786                    begin_search_type: KSPEC_BS_INVALID,
3787                    bs: C2RustUnnamed_3 {
3788                        index: C2RustUnnamed_5 { pos: 0 },
3789                    },
3790                    find_keys_type: KSPEC_FK_INVALID,
3791                    fk: C2RustUnnamed_0 {
3792                        range: C2RustUnnamed_2 {
3793                            lastkey: 0,
3794                            keystep: 0,
3795                            limit: 0,
3796                        },
3797                    },
3798                }; 4],
3799                getkeys_proc: None,
3800                subcommands: 0 as *const redisCommand as *mut redisCommand,
3801                args: CLUSTER_FORGET_Args.as_ptr() as *mut _,
3802                microseconds: 0,
3803                calls: 0,
3804                rejected_calls: 0,
3805                failed_calls: 0,
3806                id: 0,
3807                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3808                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3809                key_specs: 0 as *const keySpec as *mut keySpec,
3810                legacy_range_key_spec: keySpec {
3811                    notes: 0 as *const libc::c_char,
3812                    flags: 0,
3813                    begin_search_type: KSPEC_BS_INVALID,
3814                    bs: C2RustUnnamed_3 {
3815                        index: C2RustUnnamed_5 { pos: 0 },
3816                    },
3817                    find_keys_type: KSPEC_FK_INVALID,
3818                    fk: C2RustUnnamed_0 {
3819                        range: C2RustUnnamed_2 {
3820                            lastkey: 0,
3821                            keystep: 0,
3822                            limit: 0,
3823                        },
3824                    },
3825                },
3826                num_args: 0,
3827                num_history: 0,
3828                num_tips: 0,
3829                key_specs_num: 0,
3830                key_specs_max: 0,
3831                subcommands_dict: 0 as *const dict as *mut dict,
3832                parent: 0 as *const redisCommand as *mut redisCommand,
3833                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3834            };
3835            init
3836        },
3837        {
3838            let mut init = redisCommand {
3839                declared_name: b"getkeysinslot\0" as *const u8 as *const libc::c_char,
3840                summary: b"Return local key names in the specified hash slot\0"
3841                    as *const u8 as *const libc::c_char,
3842                complexity: b"O(log(N)) where N is the number of requested keys\0"
3843                    as *const u8 as *const libc::c_char,
3844                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3845                doc_flags: 0 as libc::c_int,
3846                replaced_by: 0 as *const libc::c_char,
3847                deprecated_since: 0 as *const libc::c_char,
3848                group: COMMAND_GROUP_CLUSTER,
3849                history: 0 as *const commandHistory as *mut commandHistory,
3850                tips: CLUSTER_GETKEYSINSLOT_tips.as_ptr() as *mut _,
3851                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3852                arity: 4 as libc::c_int,
3853                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3854                acl_categories: 0 as libc::c_int as uint64_t,
3855                key_specs_static: [keySpec {
3856                    notes: 0 as *const libc::c_char,
3857                    flags: 0,
3858                    begin_search_type: KSPEC_BS_INVALID,
3859                    bs: C2RustUnnamed_3 {
3860                        index: C2RustUnnamed_5 { pos: 0 },
3861                    },
3862                    find_keys_type: KSPEC_FK_INVALID,
3863                    fk: C2RustUnnamed_0 {
3864                        range: C2RustUnnamed_2 {
3865                            lastkey: 0,
3866                            keystep: 0,
3867                            limit: 0,
3868                        },
3869                    },
3870                }; 4],
3871                getkeys_proc: None,
3872                subcommands: 0 as *const redisCommand as *mut redisCommand,
3873                args: CLUSTER_GETKEYSINSLOT_Args.as_ptr() as *mut _,
3874                microseconds: 0,
3875                calls: 0,
3876                rejected_calls: 0,
3877                failed_calls: 0,
3878                id: 0,
3879                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3880                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3881                key_specs: 0 as *const keySpec as *mut keySpec,
3882                legacy_range_key_spec: keySpec {
3883                    notes: 0 as *const libc::c_char,
3884                    flags: 0,
3885                    begin_search_type: KSPEC_BS_INVALID,
3886                    bs: C2RustUnnamed_3 {
3887                        index: C2RustUnnamed_5 { pos: 0 },
3888                    },
3889                    find_keys_type: KSPEC_FK_INVALID,
3890                    fk: C2RustUnnamed_0 {
3891                        range: C2RustUnnamed_2 {
3892                            lastkey: 0,
3893                            keystep: 0,
3894                            limit: 0,
3895                        },
3896                    },
3897                },
3898                num_args: 0,
3899                num_history: 0,
3900                num_tips: 0,
3901                key_specs_num: 0,
3902                key_specs_max: 0,
3903                subcommands_dict: 0 as *const dict as *mut dict,
3904                parent: 0 as *const redisCommand as *mut redisCommand,
3905                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3906            };
3907            init
3908        },
3909        {
3910            let mut init = redisCommand {
3911                declared_name: b"help\0" as *const u8 as *const libc::c_char,
3912                summary: b"Show helpful text about the different subcommands\0"
3913                    as *const u8 as *const libc::c_char,
3914                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3915                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
3916                doc_flags: 0 as libc::c_int,
3917                replaced_by: 0 as *const libc::c_char,
3918                deprecated_since: 0 as *const libc::c_char,
3919                group: COMMAND_GROUP_CLUSTER,
3920                history: 0 as *const commandHistory as *mut commandHistory,
3921                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
3922                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3923                arity: 2 as libc::c_int,
3924                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
3925                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3926                acl_categories: 0 as libc::c_int as uint64_t,
3927                key_specs_static: [keySpec {
3928                    notes: 0 as *const libc::c_char,
3929                    flags: 0,
3930                    begin_search_type: KSPEC_BS_INVALID,
3931                    bs: C2RustUnnamed_3 {
3932                        index: C2RustUnnamed_5 { pos: 0 },
3933                    },
3934                    find_keys_type: KSPEC_FK_INVALID,
3935                    fk: C2RustUnnamed_0 {
3936                        range: C2RustUnnamed_2 {
3937                            lastkey: 0,
3938                            keystep: 0,
3939                            limit: 0,
3940                        },
3941                    },
3942                }; 4],
3943                getkeys_proc: None,
3944                subcommands: 0 as *const redisCommand as *mut redisCommand,
3945                args: 0 as *const redisCommandArg as *mut redisCommandArg,
3946                microseconds: 0,
3947                calls: 0,
3948                rejected_calls: 0,
3949                failed_calls: 0,
3950                id: 0,
3951                fullname: 0 as *const libc::c_char as *mut libc::c_char,
3952                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
3953                key_specs: 0 as *const keySpec as *mut keySpec,
3954                legacy_range_key_spec: keySpec {
3955                    notes: 0 as *const libc::c_char,
3956                    flags: 0,
3957                    begin_search_type: KSPEC_BS_INVALID,
3958                    bs: C2RustUnnamed_3 {
3959                        index: C2RustUnnamed_5 { pos: 0 },
3960                    },
3961                    find_keys_type: KSPEC_FK_INVALID,
3962                    fk: C2RustUnnamed_0 {
3963                        range: C2RustUnnamed_2 {
3964                            lastkey: 0,
3965                            keystep: 0,
3966                            limit: 0,
3967                        },
3968                    },
3969                },
3970                num_args: 0,
3971                num_history: 0,
3972                num_tips: 0,
3973                key_specs_num: 0,
3974                key_specs_max: 0,
3975                subcommands_dict: 0 as *const dict as *mut dict,
3976                parent: 0 as *const redisCommand as *mut redisCommand,
3977                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
3978            };
3979            init
3980        },
3981        {
3982            let mut init = redisCommand {
3983                declared_name: b"info\0" as *const u8 as *const libc::c_char,
3984                summary: b"Provides info about Redis Cluster node state\0" as *const u8
3985                    as *const libc::c_char,
3986                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
3987                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
3988                doc_flags: 0 as libc::c_int,
3989                replaced_by: 0 as *const libc::c_char,
3990                deprecated_since: 0 as *const libc::c_char,
3991                group: COMMAND_GROUP_CLUSTER,
3992                history: 0 as *const commandHistory as *mut commandHistory,
3993                tips: CLUSTER_INFO_tips.as_ptr() as *mut _,
3994                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
3995                arity: 2 as libc::c_int,
3996                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
3997                acl_categories: 0 as libc::c_int as uint64_t,
3998                key_specs_static: [keySpec {
3999                    notes: 0 as *const libc::c_char,
4000                    flags: 0,
4001                    begin_search_type: KSPEC_BS_INVALID,
4002                    bs: C2RustUnnamed_3 {
4003                        index: C2RustUnnamed_5 { pos: 0 },
4004                    },
4005                    find_keys_type: KSPEC_FK_INVALID,
4006                    fk: C2RustUnnamed_0 {
4007                        range: C2RustUnnamed_2 {
4008                            lastkey: 0,
4009                            keystep: 0,
4010                            limit: 0,
4011                        },
4012                    },
4013                }; 4],
4014                getkeys_proc: None,
4015                subcommands: 0 as *const redisCommand as *mut redisCommand,
4016                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4017                microseconds: 0,
4018                calls: 0,
4019                rejected_calls: 0,
4020                failed_calls: 0,
4021                id: 0,
4022                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4023                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4024                key_specs: 0 as *const keySpec as *mut keySpec,
4025                legacy_range_key_spec: keySpec {
4026                    notes: 0 as *const libc::c_char,
4027                    flags: 0,
4028                    begin_search_type: KSPEC_BS_INVALID,
4029                    bs: C2RustUnnamed_3 {
4030                        index: C2RustUnnamed_5 { pos: 0 },
4031                    },
4032                    find_keys_type: KSPEC_FK_INVALID,
4033                    fk: C2RustUnnamed_0 {
4034                        range: C2RustUnnamed_2 {
4035                            lastkey: 0,
4036                            keystep: 0,
4037                            limit: 0,
4038                        },
4039                    },
4040                },
4041                num_args: 0,
4042                num_history: 0,
4043                num_tips: 0,
4044                key_specs_num: 0,
4045                key_specs_max: 0,
4046                subcommands_dict: 0 as *const dict as *mut dict,
4047                parent: 0 as *const redisCommand as *mut redisCommand,
4048                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4049            };
4050            init
4051        },
4052        {
4053            let mut init = redisCommand {
4054                declared_name: b"keyslot\0" as *const u8 as *const libc::c_char,
4055                summary: b"Returns the hash slot of the specified key\0" as *const u8
4056                    as *const libc::c_char,
4057                complexity: b"O(N) where N is the number of bytes in the key\0"
4058                    as *const u8 as *const libc::c_char,
4059                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4060                doc_flags: 0 as libc::c_int,
4061                replaced_by: 0 as *const libc::c_char,
4062                deprecated_since: 0 as *const libc::c_char,
4063                group: COMMAND_GROUP_CLUSTER,
4064                history: 0 as *const commandHistory as *mut commandHistory,
4065                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4066                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4067                arity: 3 as libc::c_int,
4068                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4069                acl_categories: 0 as libc::c_int as uint64_t,
4070                key_specs_static: [keySpec {
4071                    notes: 0 as *const libc::c_char,
4072                    flags: 0,
4073                    begin_search_type: KSPEC_BS_INVALID,
4074                    bs: C2RustUnnamed_3 {
4075                        index: C2RustUnnamed_5 { pos: 0 },
4076                    },
4077                    find_keys_type: KSPEC_FK_INVALID,
4078                    fk: C2RustUnnamed_0 {
4079                        range: C2RustUnnamed_2 {
4080                            lastkey: 0,
4081                            keystep: 0,
4082                            limit: 0,
4083                        },
4084                    },
4085                }; 4],
4086                getkeys_proc: None,
4087                subcommands: 0 as *const redisCommand as *mut redisCommand,
4088                args: CLUSTER_KEYSLOT_Args.as_ptr() as *mut _,
4089                microseconds: 0,
4090                calls: 0,
4091                rejected_calls: 0,
4092                failed_calls: 0,
4093                id: 0,
4094                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4095                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4096                key_specs: 0 as *const keySpec as *mut keySpec,
4097                legacy_range_key_spec: keySpec {
4098                    notes: 0 as *const libc::c_char,
4099                    flags: 0,
4100                    begin_search_type: KSPEC_BS_INVALID,
4101                    bs: C2RustUnnamed_3 {
4102                        index: C2RustUnnamed_5 { pos: 0 },
4103                    },
4104                    find_keys_type: KSPEC_FK_INVALID,
4105                    fk: C2RustUnnamed_0 {
4106                        range: C2RustUnnamed_2 {
4107                            lastkey: 0,
4108                            keystep: 0,
4109                            limit: 0,
4110                        },
4111                    },
4112                },
4113                num_args: 0,
4114                num_history: 0,
4115                num_tips: 0,
4116                key_specs_num: 0,
4117                key_specs_max: 0,
4118                subcommands_dict: 0 as *const dict as *mut dict,
4119                parent: 0 as *const redisCommand as *mut redisCommand,
4120                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4121            };
4122            init
4123        },
4124        {
4125            let mut init = redisCommand {
4126                declared_name: b"links\0" as *const u8 as *const libc::c_char,
4127                summary: b"Returns a list of all TCP links to and from peer nodes in cluster\0"
4128                    as *const u8 as *const libc::c_char,
4129                complexity: b"O(N) where N is the total number of Cluster nodes\0"
4130                    as *const u8 as *const libc::c_char,
4131                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
4132                doc_flags: 0 as libc::c_int,
4133                replaced_by: 0 as *const libc::c_char,
4134                deprecated_since: 0 as *const libc::c_char,
4135                group: COMMAND_GROUP_CLUSTER,
4136                history: 0 as *const commandHistory as *mut commandHistory,
4137                tips: CLUSTER_LINKS_tips.as_ptr() as *mut _,
4138                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4139                arity: 2 as libc::c_int,
4140                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4141                acl_categories: 0 as libc::c_int as uint64_t,
4142                key_specs_static: [keySpec {
4143                    notes: 0 as *const libc::c_char,
4144                    flags: 0,
4145                    begin_search_type: KSPEC_BS_INVALID,
4146                    bs: C2RustUnnamed_3 {
4147                        index: C2RustUnnamed_5 { pos: 0 },
4148                    },
4149                    find_keys_type: KSPEC_FK_INVALID,
4150                    fk: C2RustUnnamed_0 {
4151                        range: C2RustUnnamed_2 {
4152                            lastkey: 0,
4153                            keystep: 0,
4154                            limit: 0,
4155                        },
4156                    },
4157                }; 4],
4158                getkeys_proc: None,
4159                subcommands: 0 as *const redisCommand as *mut redisCommand,
4160                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4161                microseconds: 0,
4162                calls: 0,
4163                rejected_calls: 0,
4164                failed_calls: 0,
4165                id: 0,
4166                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4167                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4168                key_specs: 0 as *const keySpec as *mut keySpec,
4169                legacy_range_key_spec: keySpec {
4170                    notes: 0 as *const libc::c_char,
4171                    flags: 0,
4172                    begin_search_type: KSPEC_BS_INVALID,
4173                    bs: C2RustUnnamed_3 {
4174                        index: C2RustUnnamed_5 { pos: 0 },
4175                    },
4176                    find_keys_type: KSPEC_FK_INVALID,
4177                    fk: C2RustUnnamed_0 {
4178                        range: C2RustUnnamed_2 {
4179                            lastkey: 0,
4180                            keystep: 0,
4181                            limit: 0,
4182                        },
4183                    },
4184                },
4185                num_args: 0,
4186                num_history: 0,
4187                num_tips: 0,
4188                key_specs_num: 0,
4189                key_specs_max: 0,
4190                subcommands_dict: 0 as *const dict as *mut dict,
4191                parent: 0 as *const redisCommand as *mut redisCommand,
4192                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4193            };
4194            init
4195        },
4196        {
4197            let mut init = redisCommand {
4198                declared_name: b"meet\0" as *const u8 as *const libc::c_char,
4199                summary: b"Force a node cluster to handshake with another node\0"
4200                    as *const u8 as *const libc::c_char,
4201                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4202                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4203                doc_flags: 0 as libc::c_int,
4204                replaced_by: 0 as *const libc::c_char,
4205                deprecated_since: 0 as *const libc::c_char,
4206                group: COMMAND_GROUP_CLUSTER,
4207                history: CLUSTER_MEET_History.as_ptr() as *mut _,
4208                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4209                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4210                arity: -(4 as libc::c_int),
4211                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
4212                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
4213                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4214                acl_categories: 0 as libc::c_int as uint64_t,
4215                key_specs_static: [keySpec {
4216                    notes: 0 as *const libc::c_char,
4217                    flags: 0,
4218                    begin_search_type: KSPEC_BS_INVALID,
4219                    bs: C2RustUnnamed_3 {
4220                        index: C2RustUnnamed_5 { pos: 0 },
4221                    },
4222                    find_keys_type: KSPEC_FK_INVALID,
4223                    fk: C2RustUnnamed_0 {
4224                        range: C2RustUnnamed_2 {
4225                            lastkey: 0,
4226                            keystep: 0,
4227                            limit: 0,
4228                        },
4229                    },
4230                }; 4],
4231                getkeys_proc: None,
4232                subcommands: 0 as *const redisCommand as *mut redisCommand,
4233                args: CLUSTER_MEET_Args.as_ptr() as *mut _,
4234                microseconds: 0,
4235                calls: 0,
4236                rejected_calls: 0,
4237                failed_calls: 0,
4238                id: 0,
4239                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4240                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4241                key_specs: 0 as *const keySpec as *mut keySpec,
4242                legacy_range_key_spec: keySpec {
4243                    notes: 0 as *const libc::c_char,
4244                    flags: 0,
4245                    begin_search_type: KSPEC_BS_INVALID,
4246                    bs: C2RustUnnamed_3 {
4247                        index: C2RustUnnamed_5 { pos: 0 },
4248                    },
4249                    find_keys_type: KSPEC_FK_INVALID,
4250                    fk: C2RustUnnamed_0 {
4251                        range: C2RustUnnamed_2 {
4252                            lastkey: 0,
4253                            keystep: 0,
4254                            limit: 0,
4255                        },
4256                    },
4257                },
4258                num_args: 0,
4259                num_history: 0,
4260                num_tips: 0,
4261                key_specs_num: 0,
4262                key_specs_max: 0,
4263                subcommands_dict: 0 as *const dict as *mut dict,
4264                parent: 0 as *const redisCommand as *mut redisCommand,
4265                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4266            };
4267            init
4268        },
4269        {
4270            let mut init = redisCommand {
4271                declared_name: b"myid\0" as *const u8 as *const libc::c_char,
4272                summary: b"Return the node id\0" as *const u8 as *const libc::c_char,
4273                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4274                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4275                doc_flags: 0 as libc::c_int,
4276                replaced_by: 0 as *const libc::c_char,
4277                deprecated_since: 0 as *const libc::c_char,
4278                group: COMMAND_GROUP_CLUSTER,
4279                history: 0 as *const commandHistory as *mut commandHistory,
4280                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4281                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4282                arity: 2 as libc::c_int,
4283                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4284                acl_categories: 0 as libc::c_int as uint64_t,
4285                key_specs_static: [keySpec {
4286                    notes: 0 as *const libc::c_char,
4287                    flags: 0,
4288                    begin_search_type: KSPEC_BS_INVALID,
4289                    bs: C2RustUnnamed_3 {
4290                        index: C2RustUnnamed_5 { pos: 0 },
4291                    },
4292                    find_keys_type: KSPEC_FK_INVALID,
4293                    fk: C2RustUnnamed_0 {
4294                        range: C2RustUnnamed_2 {
4295                            lastkey: 0,
4296                            keystep: 0,
4297                            limit: 0,
4298                        },
4299                    },
4300                }; 4],
4301                getkeys_proc: None,
4302                subcommands: 0 as *const redisCommand as *mut redisCommand,
4303                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4304                microseconds: 0,
4305                calls: 0,
4306                rejected_calls: 0,
4307                failed_calls: 0,
4308                id: 0,
4309                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4310                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4311                key_specs: 0 as *const keySpec as *mut keySpec,
4312                legacy_range_key_spec: keySpec {
4313                    notes: 0 as *const libc::c_char,
4314                    flags: 0,
4315                    begin_search_type: KSPEC_BS_INVALID,
4316                    bs: C2RustUnnamed_3 {
4317                        index: C2RustUnnamed_5 { pos: 0 },
4318                    },
4319                    find_keys_type: KSPEC_FK_INVALID,
4320                    fk: C2RustUnnamed_0 {
4321                        range: C2RustUnnamed_2 {
4322                            lastkey: 0,
4323                            keystep: 0,
4324                            limit: 0,
4325                        },
4326                    },
4327                },
4328                num_args: 0,
4329                num_history: 0,
4330                num_tips: 0,
4331                key_specs_num: 0,
4332                key_specs_max: 0,
4333                subcommands_dict: 0 as *const dict as *mut dict,
4334                parent: 0 as *const redisCommand as *mut redisCommand,
4335                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4336            };
4337            init
4338        },
4339        {
4340            let mut init = redisCommand {
4341                declared_name: b"nodes\0" as *const u8 as *const libc::c_char,
4342                summary: b"Get Cluster config for the node\0" as *const u8
4343                    as *const libc::c_char,
4344                complexity: b"O(N) where N is the total number of Cluster nodes\0"
4345                    as *const u8 as *const libc::c_char,
4346                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4347                doc_flags: 0 as libc::c_int,
4348                replaced_by: 0 as *const libc::c_char,
4349                deprecated_since: 0 as *const libc::c_char,
4350                group: COMMAND_GROUP_CLUSTER,
4351                history: 0 as *const commandHistory as *mut commandHistory,
4352                tips: CLUSTER_NODES_tips.as_ptr() as *mut _,
4353                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4354                arity: 2 as libc::c_int,
4355                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4356                acl_categories: 0 as libc::c_int as uint64_t,
4357                key_specs_static: [keySpec {
4358                    notes: 0 as *const libc::c_char,
4359                    flags: 0,
4360                    begin_search_type: KSPEC_BS_INVALID,
4361                    bs: C2RustUnnamed_3 {
4362                        index: C2RustUnnamed_5 { pos: 0 },
4363                    },
4364                    find_keys_type: KSPEC_FK_INVALID,
4365                    fk: C2RustUnnamed_0 {
4366                        range: C2RustUnnamed_2 {
4367                            lastkey: 0,
4368                            keystep: 0,
4369                            limit: 0,
4370                        },
4371                    },
4372                }; 4],
4373                getkeys_proc: None,
4374                subcommands: 0 as *const redisCommand as *mut redisCommand,
4375                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4376                microseconds: 0,
4377                calls: 0,
4378                rejected_calls: 0,
4379                failed_calls: 0,
4380                id: 0,
4381                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4382                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4383                key_specs: 0 as *const keySpec as *mut keySpec,
4384                legacy_range_key_spec: keySpec {
4385                    notes: 0 as *const libc::c_char,
4386                    flags: 0,
4387                    begin_search_type: KSPEC_BS_INVALID,
4388                    bs: C2RustUnnamed_3 {
4389                        index: C2RustUnnamed_5 { pos: 0 },
4390                    },
4391                    find_keys_type: KSPEC_FK_INVALID,
4392                    fk: C2RustUnnamed_0 {
4393                        range: C2RustUnnamed_2 {
4394                            lastkey: 0,
4395                            keystep: 0,
4396                            limit: 0,
4397                        },
4398                    },
4399                },
4400                num_args: 0,
4401                num_history: 0,
4402                num_tips: 0,
4403                key_specs_num: 0,
4404                key_specs_max: 0,
4405                subcommands_dict: 0 as *const dict as *mut dict,
4406                parent: 0 as *const redisCommand as *mut redisCommand,
4407                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4408            };
4409            init
4410        },
4411        {
4412            let mut init = redisCommand {
4413                declared_name: b"replicas\0" as *const u8 as *const libc::c_char,
4414                summary: b"List replica nodes of the specified master node\0"
4415                    as *const u8 as *const libc::c_char,
4416                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4417                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
4418                doc_flags: 0 as libc::c_int,
4419                replaced_by: 0 as *const libc::c_char,
4420                deprecated_since: 0 as *const libc::c_char,
4421                group: COMMAND_GROUP_CLUSTER,
4422                history: 0 as *const commandHistory as *mut commandHistory,
4423                tips: CLUSTER_REPLICAS_tips.as_ptr() as *mut _,
4424                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4425                arity: 3 as libc::c_int,
4426                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
4427                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4428                acl_categories: 0 as libc::c_int as uint64_t,
4429                key_specs_static: [keySpec {
4430                    notes: 0 as *const libc::c_char,
4431                    flags: 0,
4432                    begin_search_type: KSPEC_BS_INVALID,
4433                    bs: C2RustUnnamed_3 {
4434                        index: C2RustUnnamed_5 { pos: 0 },
4435                    },
4436                    find_keys_type: KSPEC_FK_INVALID,
4437                    fk: C2RustUnnamed_0 {
4438                        range: C2RustUnnamed_2 {
4439                            lastkey: 0,
4440                            keystep: 0,
4441                            limit: 0,
4442                        },
4443                    },
4444                }; 4],
4445                getkeys_proc: None,
4446                subcommands: 0 as *const redisCommand as *mut redisCommand,
4447                args: CLUSTER_REPLICAS_Args.as_ptr() as *mut _,
4448                microseconds: 0,
4449                calls: 0,
4450                rejected_calls: 0,
4451                failed_calls: 0,
4452                id: 0,
4453                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4454                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4455                key_specs: 0 as *const keySpec as *mut keySpec,
4456                legacy_range_key_spec: keySpec {
4457                    notes: 0 as *const libc::c_char,
4458                    flags: 0,
4459                    begin_search_type: KSPEC_BS_INVALID,
4460                    bs: C2RustUnnamed_3 {
4461                        index: C2RustUnnamed_5 { pos: 0 },
4462                    },
4463                    find_keys_type: KSPEC_FK_INVALID,
4464                    fk: C2RustUnnamed_0 {
4465                        range: C2RustUnnamed_2 {
4466                            lastkey: 0,
4467                            keystep: 0,
4468                            limit: 0,
4469                        },
4470                    },
4471                },
4472                num_args: 0,
4473                num_history: 0,
4474                num_tips: 0,
4475                key_specs_num: 0,
4476                key_specs_max: 0,
4477                subcommands_dict: 0 as *const dict as *mut dict,
4478                parent: 0 as *const redisCommand as *mut redisCommand,
4479                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4480            };
4481            init
4482        },
4483        {
4484            let mut init = redisCommand {
4485                declared_name: b"replicate\0" as *const u8 as *const libc::c_char,
4486                summary: b"Reconfigure a node as a replica of the specified master node\0"
4487                    as *const u8 as *const libc::c_char,
4488                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4489                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4490                doc_flags: 0 as libc::c_int,
4491                replaced_by: 0 as *const libc::c_char,
4492                deprecated_since: 0 as *const libc::c_char,
4493                group: COMMAND_GROUP_CLUSTER,
4494                history: 0 as *const commandHistory as *mut commandHistory,
4495                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4496                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4497                arity: 3 as libc::c_int,
4498                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
4499                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
4500                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4501                acl_categories: 0 as libc::c_int as uint64_t,
4502                key_specs_static: [keySpec {
4503                    notes: 0 as *const libc::c_char,
4504                    flags: 0,
4505                    begin_search_type: KSPEC_BS_INVALID,
4506                    bs: C2RustUnnamed_3 {
4507                        index: C2RustUnnamed_5 { pos: 0 },
4508                    },
4509                    find_keys_type: KSPEC_FK_INVALID,
4510                    fk: C2RustUnnamed_0 {
4511                        range: C2RustUnnamed_2 {
4512                            lastkey: 0,
4513                            keystep: 0,
4514                            limit: 0,
4515                        },
4516                    },
4517                }; 4],
4518                getkeys_proc: None,
4519                subcommands: 0 as *const redisCommand as *mut redisCommand,
4520                args: CLUSTER_REPLICATE_Args.as_ptr() as *mut _,
4521                microseconds: 0,
4522                calls: 0,
4523                rejected_calls: 0,
4524                failed_calls: 0,
4525                id: 0,
4526                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4527                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4528                key_specs: 0 as *const keySpec as *mut keySpec,
4529                legacy_range_key_spec: keySpec {
4530                    notes: 0 as *const libc::c_char,
4531                    flags: 0,
4532                    begin_search_type: KSPEC_BS_INVALID,
4533                    bs: C2RustUnnamed_3 {
4534                        index: C2RustUnnamed_5 { pos: 0 },
4535                    },
4536                    find_keys_type: KSPEC_FK_INVALID,
4537                    fk: C2RustUnnamed_0 {
4538                        range: C2RustUnnamed_2 {
4539                            lastkey: 0,
4540                            keystep: 0,
4541                            limit: 0,
4542                        },
4543                    },
4544                },
4545                num_args: 0,
4546                num_history: 0,
4547                num_tips: 0,
4548                key_specs_num: 0,
4549                key_specs_max: 0,
4550                subcommands_dict: 0 as *const dict as *mut dict,
4551                parent: 0 as *const redisCommand as *mut redisCommand,
4552                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4553            };
4554            init
4555        },
4556        {
4557            let mut init = redisCommand {
4558                declared_name: b"reset\0" as *const u8 as *const libc::c_char,
4559                summary: b"Reset a Redis Cluster node\0" as *const u8
4560                    as *const libc::c_char,
4561                complexity: b"O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.\0"
4562                    as *const u8 as *const libc::c_char,
4563                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4564                doc_flags: 0 as libc::c_int,
4565                replaced_by: 0 as *const libc::c_char,
4566                deprecated_since: 0 as *const libc::c_char,
4567                group: COMMAND_GROUP_CLUSTER,
4568                history: 0 as *const commandHistory as *mut commandHistory,
4569                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4570                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4571                arity: -(2 as libc::c_int),
4572                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
4573                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
4574                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
4575                acl_categories: 0 as libc::c_int as uint64_t,
4576                key_specs_static: [keySpec {
4577                    notes: 0 as *const libc::c_char,
4578                    flags: 0,
4579                    begin_search_type: KSPEC_BS_INVALID,
4580                    bs: C2RustUnnamed_3 {
4581                        index: C2RustUnnamed_5 { pos: 0 },
4582                    },
4583                    find_keys_type: KSPEC_FK_INVALID,
4584                    fk: C2RustUnnamed_0 {
4585                        range: C2RustUnnamed_2 {
4586                            lastkey: 0,
4587                            keystep: 0,
4588                            limit: 0,
4589                        },
4590                    },
4591                }; 4],
4592                getkeys_proc: None,
4593                subcommands: 0 as *const redisCommand as *mut redisCommand,
4594                args: CLUSTER_RESET_Args.as_ptr() as *mut _,
4595                microseconds: 0,
4596                calls: 0,
4597                rejected_calls: 0,
4598                failed_calls: 0,
4599                id: 0,
4600                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4601                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4602                key_specs: 0 as *const keySpec as *mut keySpec,
4603                legacy_range_key_spec: keySpec {
4604                    notes: 0 as *const libc::c_char,
4605                    flags: 0,
4606                    begin_search_type: KSPEC_BS_INVALID,
4607                    bs: C2RustUnnamed_3 {
4608                        index: C2RustUnnamed_5 { pos: 0 },
4609                    },
4610                    find_keys_type: KSPEC_FK_INVALID,
4611                    fk: C2RustUnnamed_0 {
4612                        range: C2RustUnnamed_2 {
4613                            lastkey: 0,
4614                            keystep: 0,
4615                            limit: 0,
4616                        },
4617                    },
4618                },
4619                num_args: 0,
4620                num_history: 0,
4621                num_tips: 0,
4622                key_specs_num: 0,
4623                key_specs_max: 0,
4624                subcommands_dict: 0 as *const dict as *mut dict,
4625                parent: 0 as *const redisCommand as *mut redisCommand,
4626                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4627            };
4628            init
4629        },
4630        {
4631            let mut init = redisCommand {
4632                declared_name: b"saveconfig\0" as *const u8 as *const libc::c_char,
4633                summary: b"Forces the node to save cluster state on disk\0" as *const u8
4634                    as *const libc::c_char,
4635                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4636                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4637                doc_flags: 0 as libc::c_int,
4638                replaced_by: 0 as *const libc::c_char,
4639                deprecated_since: 0 as *const libc::c_char,
4640                group: COMMAND_GROUP_CLUSTER,
4641                history: 0 as *const commandHistory as *mut commandHistory,
4642                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4643                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4644                arity: 2 as libc::c_int,
4645                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
4646                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
4647                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4648                acl_categories: 0 as libc::c_int as uint64_t,
4649                key_specs_static: [keySpec {
4650                    notes: 0 as *const libc::c_char,
4651                    flags: 0,
4652                    begin_search_type: KSPEC_BS_INVALID,
4653                    bs: C2RustUnnamed_3 {
4654                        index: C2RustUnnamed_5 { pos: 0 },
4655                    },
4656                    find_keys_type: KSPEC_FK_INVALID,
4657                    fk: C2RustUnnamed_0 {
4658                        range: C2RustUnnamed_2 {
4659                            lastkey: 0,
4660                            keystep: 0,
4661                            limit: 0,
4662                        },
4663                    },
4664                }; 4],
4665                getkeys_proc: None,
4666                subcommands: 0 as *const redisCommand as *mut redisCommand,
4667                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4668                microseconds: 0,
4669                calls: 0,
4670                rejected_calls: 0,
4671                failed_calls: 0,
4672                id: 0,
4673                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4674                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4675                key_specs: 0 as *const keySpec as *mut keySpec,
4676                legacy_range_key_spec: keySpec {
4677                    notes: 0 as *const libc::c_char,
4678                    flags: 0,
4679                    begin_search_type: KSPEC_BS_INVALID,
4680                    bs: C2RustUnnamed_3 {
4681                        index: C2RustUnnamed_5 { pos: 0 },
4682                    },
4683                    find_keys_type: KSPEC_FK_INVALID,
4684                    fk: C2RustUnnamed_0 {
4685                        range: C2RustUnnamed_2 {
4686                            lastkey: 0,
4687                            keystep: 0,
4688                            limit: 0,
4689                        },
4690                    },
4691                },
4692                num_args: 0,
4693                num_history: 0,
4694                num_tips: 0,
4695                key_specs_num: 0,
4696                key_specs_max: 0,
4697                subcommands_dict: 0 as *const dict as *mut dict,
4698                parent: 0 as *const redisCommand as *mut redisCommand,
4699                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4700            };
4701            init
4702        },
4703        {
4704            let mut init = redisCommand {
4705                declared_name: b"set-config-epoch\0" as *const u8 as *const libc::c_char,
4706                summary: b"Set the configuration epoch in a new node\0" as *const u8
4707                    as *const libc::c_char,
4708                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4709                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4710                doc_flags: 0 as libc::c_int,
4711                replaced_by: 0 as *const libc::c_char,
4712                deprecated_since: 0 as *const libc::c_char,
4713                group: COMMAND_GROUP_CLUSTER,
4714                history: 0 as *const commandHistory as *mut commandHistory,
4715                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4716                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4717                arity: 3 as libc::c_int,
4718                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
4719                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
4720                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4721                acl_categories: 0 as libc::c_int as uint64_t,
4722                key_specs_static: [keySpec {
4723                    notes: 0 as *const libc::c_char,
4724                    flags: 0,
4725                    begin_search_type: KSPEC_BS_INVALID,
4726                    bs: C2RustUnnamed_3 {
4727                        index: C2RustUnnamed_5 { pos: 0 },
4728                    },
4729                    find_keys_type: KSPEC_FK_INVALID,
4730                    fk: C2RustUnnamed_0 {
4731                        range: C2RustUnnamed_2 {
4732                            lastkey: 0,
4733                            keystep: 0,
4734                            limit: 0,
4735                        },
4736                    },
4737                }; 4],
4738                getkeys_proc: None,
4739                subcommands: 0 as *const redisCommand as *mut redisCommand,
4740                args: CLUSTER_SET_CONFIG_EPOCH_Args.as_ptr() as *mut _,
4741                microseconds: 0,
4742                calls: 0,
4743                rejected_calls: 0,
4744                failed_calls: 0,
4745                id: 0,
4746                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4747                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4748                key_specs: 0 as *const keySpec as *mut keySpec,
4749                legacy_range_key_spec: keySpec {
4750                    notes: 0 as *const libc::c_char,
4751                    flags: 0,
4752                    begin_search_type: KSPEC_BS_INVALID,
4753                    bs: C2RustUnnamed_3 {
4754                        index: C2RustUnnamed_5 { pos: 0 },
4755                    },
4756                    find_keys_type: KSPEC_FK_INVALID,
4757                    fk: C2RustUnnamed_0 {
4758                        range: C2RustUnnamed_2 {
4759                            lastkey: 0,
4760                            keystep: 0,
4761                            limit: 0,
4762                        },
4763                    },
4764                },
4765                num_args: 0,
4766                num_history: 0,
4767                num_tips: 0,
4768                key_specs_num: 0,
4769                key_specs_max: 0,
4770                subcommands_dict: 0 as *const dict as *mut dict,
4771                parent: 0 as *const redisCommand as *mut redisCommand,
4772                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4773            };
4774            init
4775        },
4776        {
4777            let mut init = redisCommand {
4778                declared_name: b"setslot\0" as *const u8 as *const libc::c_char,
4779                summary: b"Bind a hash slot to a specific node\0" as *const u8
4780                    as *const libc::c_char,
4781                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4782                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4783                doc_flags: 0 as libc::c_int,
4784                replaced_by: 0 as *const libc::c_char,
4785                deprecated_since: 0 as *const libc::c_char,
4786                group: COMMAND_GROUP_CLUSTER,
4787                history: 0 as *const commandHistory as *mut commandHistory,
4788                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
4789                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4790                arity: -(4 as libc::c_int),
4791                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
4792                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
4793                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4794                acl_categories: 0 as libc::c_int as uint64_t,
4795                key_specs_static: [keySpec {
4796                    notes: 0 as *const libc::c_char,
4797                    flags: 0,
4798                    begin_search_type: KSPEC_BS_INVALID,
4799                    bs: C2RustUnnamed_3 {
4800                        index: C2RustUnnamed_5 { pos: 0 },
4801                    },
4802                    find_keys_type: KSPEC_FK_INVALID,
4803                    fk: C2RustUnnamed_0 {
4804                        range: C2RustUnnamed_2 {
4805                            lastkey: 0,
4806                            keystep: 0,
4807                            limit: 0,
4808                        },
4809                    },
4810                }; 4],
4811                getkeys_proc: None,
4812                subcommands: 0 as *const redisCommand as *mut redisCommand,
4813                args: CLUSTER_SETSLOT_Args.as_ptr() as *mut _,
4814                microseconds: 0,
4815                calls: 0,
4816                rejected_calls: 0,
4817                failed_calls: 0,
4818                id: 0,
4819                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4820                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4821                key_specs: 0 as *const keySpec as *mut keySpec,
4822                legacy_range_key_spec: keySpec {
4823                    notes: 0 as *const libc::c_char,
4824                    flags: 0,
4825                    begin_search_type: KSPEC_BS_INVALID,
4826                    bs: C2RustUnnamed_3 {
4827                        index: C2RustUnnamed_5 { pos: 0 },
4828                    },
4829                    find_keys_type: KSPEC_FK_INVALID,
4830                    fk: C2RustUnnamed_0 {
4831                        range: C2RustUnnamed_2 {
4832                            lastkey: 0,
4833                            keystep: 0,
4834                            limit: 0,
4835                        },
4836                    },
4837                },
4838                num_args: 0,
4839                num_history: 0,
4840                num_tips: 0,
4841                key_specs_num: 0,
4842                key_specs_max: 0,
4843                subcommands_dict: 0 as *const dict as *mut dict,
4844                parent: 0 as *const redisCommand as *mut redisCommand,
4845                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4846            };
4847            init
4848        },
4849        {
4850            let mut init = redisCommand {
4851                declared_name: b"shards\0" as *const u8 as *const libc::c_char,
4852                summary: b"Get array of cluster slots to node mappings\0" as *const u8
4853                    as *const libc::c_char,
4854                complexity: b"O(N) where N is the total number of cluster nodes\0"
4855                    as *const u8 as *const libc::c_char,
4856                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
4857                doc_flags: 0 as libc::c_int,
4858                replaced_by: 0 as *const libc::c_char,
4859                deprecated_since: 0 as *const libc::c_char,
4860                group: COMMAND_GROUP_CLUSTER,
4861                history: 0 as *const commandHistory as *mut commandHistory,
4862                tips: CLUSTER_SHARDS_tips.as_ptr() as *mut _,
4863                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4864                arity: 2 as libc::c_int,
4865                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4866                acl_categories: 0 as libc::c_int as uint64_t,
4867                key_specs_static: [keySpec {
4868                    notes: 0 as *const libc::c_char,
4869                    flags: 0,
4870                    begin_search_type: KSPEC_BS_INVALID,
4871                    bs: C2RustUnnamed_3 {
4872                        index: C2RustUnnamed_5 { pos: 0 },
4873                    },
4874                    find_keys_type: KSPEC_FK_INVALID,
4875                    fk: C2RustUnnamed_0 {
4876                        range: C2RustUnnamed_2 {
4877                            lastkey: 0,
4878                            keystep: 0,
4879                            limit: 0,
4880                        },
4881                    },
4882                }; 4],
4883                getkeys_proc: None,
4884                subcommands: 0 as *const redisCommand as *mut redisCommand,
4885                args: 0 as *const redisCommandArg as *mut redisCommandArg,
4886                microseconds: 0,
4887                calls: 0,
4888                rejected_calls: 0,
4889                failed_calls: 0,
4890                id: 0,
4891                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4892                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4893                key_specs: 0 as *const keySpec as *mut keySpec,
4894                legacy_range_key_spec: keySpec {
4895                    notes: 0 as *const libc::c_char,
4896                    flags: 0,
4897                    begin_search_type: KSPEC_BS_INVALID,
4898                    bs: C2RustUnnamed_3 {
4899                        index: C2RustUnnamed_5 { pos: 0 },
4900                    },
4901                    find_keys_type: KSPEC_FK_INVALID,
4902                    fk: C2RustUnnamed_0 {
4903                        range: C2RustUnnamed_2 {
4904                            lastkey: 0,
4905                            keystep: 0,
4906                            limit: 0,
4907                        },
4908                    },
4909                },
4910                num_args: 0,
4911                num_history: 0,
4912                num_tips: 0,
4913                key_specs_num: 0,
4914                key_specs_max: 0,
4915                subcommands_dict: 0 as *const dict as *mut dict,
4916                parent: 0 as *const redisCommand as *mut redisCommand,
4917                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4918            };
4919            init
4920        },
4921        {
4922            let mut init = redisCommand {
4923                declared_name: b"slaves\0" as *const u8 as *const libc::c_char,
4924                summary: b"List replica nodes of the specified master node\0"
4925                    as *const u8 as *const libc::c_char,
4926                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
4927                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
4928                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
4929                replaced_by: b"`CLUSTER REPLICAS`\0" as *const u8 as *const libc::c_char,
4930                deprecated_since: b"5.0.0\0" as *const u8 as *const libc::c_char,
4931                group: COMMAND_GROUP_CLUSTER,
4932                history: 0 as *const commandHistory as *mut commandHistory,
4933                tips: CLUSTER_SLAVES_tips.as_ptr() as *mut _,
4934                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
4935                arity: 3 as libc::c_int,
4936                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
4937                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
4938                acl_categories: 0 as libc::c_int as uint64_t,
4939                key_specs_static: [keySpec {
4940                    notes: 0 as *const libc::c_char,
4941                    flags: 0,
4942                    begin_search_type: KSPEC_BS_INVALID,
4943                    bs: C2RustUnnamed_3 {
4944                        index: C2RustUnnamed_5 { pos: 0 },
4945                    },
4946                    find_keys_type: KSPEC_FK_INVALID,
4947                    fk: C2RustUnnamed_0 {
4948                        range: C2RustUnnamed_2 {
4949                            lastkey: 0,
4950                            keystep: 0,
4951                            limit: 0,
4952                        },
4953                    },
4954                }; 4],
4955                getkeys_proc: None,
4956                subcommands: 0 as *const redisCommand as *mut redisCommand,
4957                args: CLUSTER_SLAVES_Args.as_ptr() as *mut _,
4958                microseconds: 0,
4959                calls: 0,
4960                rejected_calls: 0,
4961                failed_calls: 0,
4962                id: 0,
4963                fullname: 0 as *const libc::c_char as *mut libc::c_char,
4964                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
4965                key_specs: 0 as *const keySpec as *mut keySpec,
4966                legacy_range_key_spec: keySpec {
4967                    notes: 0 as *const libc::c_char,
4968                    flags: 0,
4969                    begin_search_type: KSPEC_BS_INVALID,
4970                    bs: C2RustUnnamed_3 {
4971                        index: C2RustUnnamed_5 { pos: 0 },
4972                    },
4973                    find_keys_type: KSPEC_FK_INVALID,
4974                    fk: C2RustUnnamed_0 {
4975                        range: C2RustUnnamed_2 {
4976                            lastkey: 0,
4977                            keystep: 0,
4978                            limit: 0,
4979                        },
4980                    },
4981                },
4982                num_args: 0,
4983                num_history: 0,
4984                num_tips: 0,
4985                key_specs_num: 0,
4986                key_specs_max: 0,
4987                subcommands_dict: 0 as *const dict as *mut dict,
4988                parent: 0 as *const redisCommand as *mut redisCommand,
4989                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
4990            };
4991            init
4992        },
4993        {
4994            let mut init = redisCommand {
4995                declared_name: b"slots\0" as *const u8 as *const libc::c_char,
4996                summary: b"Get array of Cluster slot to node mappings\0" as *const u8
4997                    as *const libc::c_char,
4998                complexity: b"O(N) where N is the total number of Cluster nodes\0"
4999                    as *const u8 as *const libc::c_char,
5000                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
5001                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
5002                replaced_by: b"`CLUSTER SHARDS`\0" as *const u8 as *const libc::c_char,
5003                deprecated_since: b"7.0.0\0" as *const u8 as *const libc::c_char,
5004                group: COMMAND_GROUP_CLUSTER,
5005                history: CLUSTER_SLOTS_History.as_ptr() as *mut _,
5006                tips: CLUSTER_SLOTS_tips.as_ptr() as *mut _,
5007                proc_0: Some(clusterCommand as unsafe extern "C" fn(*mut client) -> ()),
5008                arity: 2 as libc::c_int,
5009                flags: ((1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
5010                acl_categories: 0 as libc::c_int as uint64_t,
5011                key_specs_static: [keySpec {
5012                    notes: 0 as *const libc::c_char,
5013                    flags: 0,
5014                    begin_search_type: KSPEC_BS_INVALID,
5015                    bs: C2RustUnnamed_3 {
5016                        index: C2RustUnnamed_5 { pos: 0 },
5017                    },
5018                    find_keys_type: KSPEC_FK_INVALID,
5019                    fk: C2RustUnnamed_0 {
5020                        range: C2RustUnnamed_2 {
5021                            lastkey: 0,
5022                            keystep: 0,
5023                            limit: 0,
5024                        },
5025                    },
5026                }; 4],
5027                getkeys_proc: None,
5028                subcommands: 0 as *const redisCommand as *mut redisCommand,
5029                args: 0 as *const redisCommandArg as *mut redisCommandArg,
5030                microseconds: 0,
5031                calls: 0,
5032                rejected_calls: 0,
5033                failed_calls: 0,
5034                id: 0,
5035                fullname: 0 as *const libc::c_char as *mut libc::c_char,
5036                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
5037                key_specs: 0 as *const keySpec as *mut keySpec,
5038                legacy_range_key_spec: keySpec {
5039                    notes: 0 as *const libc::c_char,
5040                    flags: 0,
5041                    begin_search_type: KSPEC_BS_INVALID,
5042                    bs: C2RustUnnamed_3 {
5043                        index: C2RustUnnamed_5 { pos: 0 },
5044                    },
5045                    find_keys_type: KSPEC_FK_INVALID,
5046                    fk: C2RustUnnamed_0 {
5047                        range: C2RustUnnamed_2 {
5048                            lastkey: 0,
5049                            keystep: 0,
5050                            limit: 0,
5051                        },
5052                    },
5053                },
5054                num_args: 0,
5055                num_history: 0,
5056                num_tips: 0,
5057                key_specs_num: 0,
5058                key_specs_max: 0,
5059                subcommands_dict: 0 as *const dict as *mut dict,
5060                parent: 0 as *const redisCommand as *mut redisCommand,
5061                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
5062            };
5063            init
5064        },
5065        {
5066            let mut init = redisCommand {
5067                declared_name: 0 as *const libc::c_char,
5068                summary: 0 as *const libc::c_char,
5069                complexity: 0 as *const libc::c_char,
5070                since: 0 as *const libc::c_char,
5071                doc_flags: 0,
5072                replaced_by: 0 as *const libc::c_char,
5073                deprecated_since: 0 as *const libc::c_char,
5074                group: COMMAND_GROUP_GENERIC,
5075                history: 0 as *const commandHistory as *mut commandHistory,
5076                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
5077                proc_0: None,
5078                arity: 0,
5079                flags: 0,
5080                acl_categories: 0,
5081                key_specs_static: [keySpec {
5082                    notes: 0 as *const libc::c_char,
5083                    flags: 0,
5084                    begin_search_type: KSPEC_BS_INVALID,
5085                    bs: C2RustUnnamed_3 {
5086                        index: C2RustUnnamed_5 { pos: 0 },
5087                    },
5088                    find_keys_type: KSPEC_FK_INVALID,
5089                    fk: C2RustUnnamed_0 {
5090                        range: C2RustUnnamed_2 {
5091                            lastkey: 0,
5092                            keystep: 0,
5093                            limit: 0,
5094                        },
5095                    },
5096                }; 4],
5097                getkeys_proc: None,
5098                subcommands: 0 as *const redisCommand as *mut redisCommand,
5099                args: 0 as *const redisCommandArg as *mut redisCommandArg,
5100                microseconds: 0,
5101                calls: 0,
5102                rejected_calls: 0,
5103                failed_calls: 0,
5104                id: 0,
5105                fullname: 0 as *const libc::c_char as *mut libc::c_char,
5106                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
5107                key_specs: 0 as *const keySpec as *mut keySpec,
5108                legacy_range_key_spec: keySpec {
5109                    notes: 0 as *const libc::c_char,
5110                    flags: 0,
5111                    begin_search_type: KSPEC_BS_INVALID,
5112                    bs: C2RustUnnamed_3 {
5113                        index: C2RustUnnamed_5 { pos: 0 },
5114                    },
5115                    find_keys_type: KSPEC_FK_INVALID,
5116                    fk: C2RustUnnamed_0 {
5117                        range: C2RustUnnamed_2 {
5118                            lastkey: 0,
5119                            keystep: 0,
5120                            limit: 0,
5121                        },
5122                    },
5123                },
5124                num_args: 0,
5125                num_history: 0,
5126                num_tips: 0,
5127                key_specs_num: 0,
5128                key_specs_max: 0,
5129                subcommands_dict: 0 as *const dict as *mut dict,
5130                parent: 0 as *const redisCommand as *mut redisCommand,
5131                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
5132            };
5133            init
5134        },
5135    ]
5136};
5137#[no_mangle]
5138pub static mut AUTH_History: [commandHistory; 2] = [
5139    {
5140        let mut init = commandHistory {
5141            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
5142            changes: b"Added ACL style (username and password).\0" as *const u8
5143                as *const libc::c_char,
5144        };
5145        init
5146    },
5147    {
5148        let mut init = commandHistory {
5149            since: 0 as *const libc::c_char,
5150            changes: 0 as *const libc::c_char,
5151        };
5152        init
5153    },
5154];
5155#[no_mangle]
5156pub static mut AUTH_Args: [redisCommandArg; 3] = [
5157    {
5158        let mut init = redisCommandArg {
5159            name: b"username\0" as *const u8 as *const libc::c_char,
5160            type_0: ARG_TYPE_STRING,
5161            key_spec_index: -(1 as libc::c_int),
5162            token: 0 as *const libc::c_char,
5163            summary: 0 as *const libc::c_char,
5164            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
5165            flags: (1 as libc::c_int) << 0 as libc::c_int,
5166            deprecated_since: 0 as *const libc::c_char,
5167            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5168            num_args: 0,
5169        };
5170        init
5171    },
5172    {
5173        let mut init = redisCommandArg {
5174            name: b"password\0" as *const u8 as *const libc::c_char,
5175            type_0: ARG_TYPE_STRING,
5176            key_spec_index: -(1 as libc::c_int),
5177            token: 0 as *const libc::c_char,
5178            summary: 0 as *const libc::c_char,
5179            since: 0 as *const libc::c_char,
5180            flags: 0 as libc::c_int,
5181            deprecated_since: 0 as *const libc::c_char,
5182            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5183            num_args: 0,
5184        };
5185        init
5186    },
5187    {
5188        let mut init = redisCommandArg {
5189            name: 0 as *const libc::c_char,
5190            type_0: ARG_TYPE_STRING,
5191            key_spec_index: 0,
5192            token: 0 as *const libc::c_char,
5193            summary: 0 as *const libc::c_char,
5194            since: 0 as *const libc::c_char,
5195            flags: 0,
5196            deprecated_since: 0 as *const libc::c_char,
5197            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5198            num_args: 0,
5199        };
5200        init
5201    },
5202];
5203#[no_mangle]
5204pub static mut CLIENT_CACHING_mode_Subargs: [redisCommandArg; 3] = [
5205    {
5206        let mut init = redisCommandArg {
5207            name: b"yes\0" as *const u8 as *const libc::c_char,
5208            type_0: ARG_TYPE_PURE_TOKEN,
5209            key_spec_index: -(1 as libc::c_int),
5210            token: b"YES\0" as *const u8 as *const libc::c_char,
5211            summary: 0 as *const libc::c_char,
5212            since: 0 as *const libc::c_char,
5213            flags: 0 as libc::c_int,
5214            deprecated_since: 0 as *const libc::c_char,
5215            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5216            num_args: 0,
5217        };
5218        init
5219    },
5220    {
5221        let mut init = redisCommandArg {
5222            name: b"no\0" as *const u8 as *const libc::c_char,
5223            type_0: ARG_TYPE_PURE_TOKEN,
5224            key_spec_index: -(1 as libc::c_int),
5225            token: b"NO\0" as *const u8 as *const libc::c_char,
5226            summary: 0 as *const libc::c_char,
5227            since: 0 as *const libc::c_char,
5228            flags: 0 as libc::c_int,
5229            deprecated_since: 0 as *const libc::c_char,
5230            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5231            num_args: 0,
5232        };
5233        init
5234    },
5235    {
5236        let mut init = redisCommandArg {
5237            name: 0 as *const libc::c_char,
5238            type_0: ARG_TYPE_STRING,
5239            key_spec_index: 0,
5240            token: 0 as *const libc::c_char,
5241            summary: 0 as *const libc::c_char,
5242            since: 0 as *const libc::c_char,
5243            flags: 0,
5244            deprecated_since: 0 as *const libc::c_char,
5245            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5246            num_args: 0,
5247        };
5248        init
5249    },
5250];
5251#[no_mangle]
5252pub static mut CLIENT_CACHING_Args: [redisCommandArg; 2] = unsafe {
5253    [
5254        {
5255            let mut init = redisCommandArg {
5256                name: b"mode\0" as *const u8 as *const libc::c_char,
5257                type_0: ARG_TYPE_ONEOF,
5258                key_spec_index: -(1 as libc::c_int),
5259                token: 0 as *const libc::c_char,
5260                summary: 0 as *const libc::c_char,
5261                since: 0 as *const libc::c_char,
5262                flags: 0 as libc::c_int,
5263                deprecated_since: 0 as *const libc::c_char,
5264                subargs: CLIENT_CACHING_mode_Subargs.as_ptr() as *mut _,
5265                num_args: 0,
5266            };
5267            init
5268        },
5269        {
5270            let mut init = redisCommandArg {
5271                name: 0 as *const libc::c_char,
5272                type_0: ARG_TYPE_STRING,
5273                key_spec_index: 0,
5274                token: 0 as *const libc::c_char,
5275                summary: 0 as *const libc::c_char,
5276                since: 0 as *const libc::c_char,
5277                flags: 0,
5278                deprecated_since: 0 as *const libc::c_char,
5279                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5280                num_args: 0,
5281            };
5282            init
5283        },
5284    ]
5285};
5286#[no_mangle]
5287pub static mut CLIENT_INFO_tips: [*const libc::c_char; 2] = [
5288    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
5289    0 as *const libc::c_char,
5290];
5291#[no_mangle]
5292pub static mut CLIENT_KILL_History: [commandHistory; 6] = [
5293    {
5294        let mut init = commandHistory {
5295            since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5296            changes: b"Added new filter format.\0" as *const u8 as *const libc::c_char,
5297        };
5298        init
5299    },
5300    {
5301        let mut init = commandHistory {
5302            since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5303            changes: b"`ID` option.\0" as *const u8 as *const libc::c_char,
5304        };
5305        init
5306    },
5307    {
5308        let mut init = commandHistory {
5309            since: b"3.2.0\0" as *const u8 as *const libc::c_char,
5310            changes: b"Added `master` type in for `TYPE` option.\0" as *const u8
5311                as *const libc::c_char,
5312        };
5313        init
5314    },
5315    {
5316        let mut init = commandHistory {
5317            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
5318            changes: b"Replaced `slave` `TYPE` with `replica`. `slave` still supported for backward compatibility.\0"
5319                as *const u8 as *const libc::c_char,
5320        };
5321        init
5322    },
5323    {
5324        let mut init = commandHistory {
5325            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
5326            changes: b"`LADDR` option.\0" as *const u8 as *const libc::c_char,
5327        };
5328        init
5329    },
5330    {
5331        let mut init = commandHistory {
5332            since: 0 as *const libc::c_char,
5333            changes: 0 as *const libc::c_char,
5334        };
5335        init
5336    },
5337];
5338#[no_mangle]
5339pub static mut CLIENT_KILL_filter_new_format_normal_master_slave_pubsub_Subargs: [redisCommandArg; 6] = [
5340    {
5341        let mut init = redisCommandArg {
5342            name: b"normal\0" as *const u8 as *const libc::c_char,
5343            type_0: ARG_TYPE_PURE_TOKEN,
5344            key_spec_index: -(1 as libc::c_int),
5345            token: b"NORMAL\0" as *const u8 as *const libc::c_char,
5346            summary: 0 as *const libc::c_char,
5347            since: 0 as *const libc::c_char,
5348            flags: 0 as libc::c_int,
5349            deprecated_since: 0 as *const libc::c_char,
5350            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5351            num_args: 0,
5352        };
5353        init
5354    },
5355    {
5356        let mut init = redisCommandArg {
5357            name: b"master\0" as *const u8 as *const libc::c_char,
5358            type_0: ARG_TYPE_PURE_TOKEN,
5359            key_spec_index: -(1 as libc::c_int),
5360            token: b"MASTER\0" as *const u8 as *const libc::c_char,
5361            summary: 0 as *const libc::c_char,
5362            since: b"3.2.0\0" as *const u8 as *const libc::c_char,
5363            flags: 0 as libc::c_int,
5364            deprecated_since: 0 as *const libc::c_char,
5365            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5366            num_args: 0,
5367        };
5368        init
5369    },
5370    {
5371        let mut init = redisCommandArg {
5372            name: b"slave\0" as *const u8 as *const libc::c_char,
5373            type_0: ARG_TYPE_PURE_TOKEN,
5374            key_spec_index: -(1 as libc::c_int),
5375            token: b"SLAVE\0" as *const u8 as *const libc::c_char,
5376            summary: 0 as *const libc::c_char,
5377            since: 0 as *const libc::c_char,
5378            flags: 0 as libc::c_int,
5379            deprecated_since: 0 as *const libc::c_char,
5380            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5381            num_args: 0,
5382        };
5383        init
5384    },
5385    {
5386        let mut init = redisCommandArg {
5387            name: b"replica\0" as *const u8 as *const libc::c_char,
5388            type_0: ARG_TYPE_PURE_TOKEN,
5389            key_spec_index: -(1 as libc::c_int),
5390            token: b"REPLICA\0" as *const u8 as *const libc::c_char,
5391            summary: 0 as *const libc::c_char,
5392            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
5393            flags: 0 as libc::c_int,
5394            deprecated_since: 0 as *const libc::c_char,
5395            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5396            num_args: 0,
5397        };
5398        init
5399    },
5400    {
5401        let mut init = redisCommandArg {
5402            name: b"pubsub\0" as *const u8 as *const libc::c_char,
5403            type_0: ARG_TYPE_PURE_TOKEN,
5404            key_spec_index: -(1 as libc::c_int),
5405            token: b"PUBSUB\0" as *const u8 as *const libc::c_char,
5406            summary: 0 as *const libc::c_char,
5407            since: 0 as *const libc::c_char,
5408            flags: 0 as libc::c_int,
5409            deprecated_since: 0 as *const libc::c_char,
5410            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5411            num_args: 0,
5412        };
5413        init
5414    },
5415    {
5416        let mut init = redisCommandArg {
5417            name: 0 as *const libc::c_char,
5418            type_0: ARG_TYPE_STRING,
5419            key_spec_index: 0,
5420            token: 0 as *const libc::c_char,
5421            summary: 0 as *const libc::c_char,
5422            since: 0 as *const libc::c_char,
5423            flags: 0,
5424            deprecated_since: 0 as *const libc::c_char,
5425            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5426            num_args: 0,
5427        };
5428        init
5429    },
5430];
5431#[no_mangle]
5432pub static mut CLIENT_KILL_filter_new_format_Subargs: [redisCommandArg; 7] = unsafe {
5433    [
5434        {
5435            let mut init = redisCommandArg {
5436                name: b"client-id\0" as *const u8 as *const libc::c_char,
5437                type_0: ARG_TYPE_INTEGER,
5438                key_spec_index: -(1 as libc::c_int),
5439                token: b"ID\0" as *const u8 as *const libc::c_char,
5440                summary: 0 as *const libc::c_char,
5441                since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5442                flags: (1 as libc::c_int) << 0 as libc::c_int,
5443                deprecated_since: 0 as *const libc::c_char,
5444                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5445                num_args: 0,
5446            };
5447            init
5448        },
5449        {
5450            let mut init = redisCommandArg {
5451                name: b"normal_master_slave_pubsub\0" as *const u8
5452                    as *const libc::c_char,
5453                type_0: ARG_TYPE_ONEOF,
5454                key_spec_index: -(1 as libc::c_int),
5455                token: b"TYPE\0" as *const u8 as *const libc::c_char,
5456                summary: 0 as *const libc::c_char,
5457                since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5458                flags: (1 as libc::c_int) << 0 as libc::c_int,
5459                deprecated_since: 0 as *const libc::c_char,
5460                subargs: CLIENT_KILL_filter_new_format_normal_master_slave_pubsub_Subargs
5461                    .as_ptr() as *mut _,
5462                num_args: 0,
5463            };
5464            init
5465        },
5466        {
5467            let mut init = redisCommandArg {
5468                name: b"username\0" as *const u8 as *const libc::c_char,
5469                type_0: ARG_TYPE_STRING,
5470                key_spec_index: -(1 as libc::c_int),
5471                token: b"USER\0" as *const u8 as *const libc::c_char,
5472                summary: 0 as *const libc::c_char,
5473                since: 0 as *const libc::c_char,
5474                flags: (1 as libc::c_int) << 0 as libc::c_int,
5475                deprecated_since: 0 as *const libc::c_char,
5476                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5477                num_args: 0,
5478            };
5479            init
5480        },
5481        {
5482            let mut init = redisCommandArg {
5483                name: b"ip:port\0" as *const u8 as *const libc::c_char,
5484                type_0: ARG_TYPE_STRING,
5485                key_spec_index: -(1 as libc::c_int),
5486                token: b"ADDR\0" as *const u8 as *const libc::c_char,
5487                summary: 0 as *const libc::c_char,
5488                since: 0 as *const libc::c_char,
5489                flags: (1 as libc::c_int) << 0 as libc::c_int,
5490                deprecated_since: 0 as *const libc::c_char,
5491                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5492                num_args: 0,
5493            };
5494            init
5495        },
5496        {
5497            let mut init = redisCommandArg {
5498                name: b"ip:port\0" as *const u8 as *const libc::c_char,
5499                type_0: ARG_TYPE_STRING,
5500                key_spec_index: -(1 as libc::c_int),
5501                token: b"LADDR\0" as *const u8 as *const libc::c_char,
5502                summary: 0 as *const libc::c_char,
5503                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
5504                flags: (1 as libc::c_int) << 0 as libc::c_int,
5505                deprecated_since: 0 as *const libc::c_char,
5506                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5507                num_args: 0,
5508            };
5509            init
5510        },
5511        {
5512            let mut init = redisCommandArg {
5513                name: b"yes/no\0" as *const u8 as *const libc::c_char,
5514                type_0: ARG_TYPE_STRING,
5515                key_spec_index: -(1 as libc::c_int),
5516                token: b"SKIPME\0" as *const u8 as *const libc::c_char,
5517                summary: 0 as *const libc::c_char,
5518                since: 0 as *const libc::c_char,
5519                flags: (1 as libc::c_int) << 0 as libc::c_int,
5520                deprecated_since: 0 as *const libc::c_char,
5521                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5522                num_args: 0,
5523            };
5524            init
5525        },
5526        {
5527            let mut init = redisCommandArg {
5528                name: 0 as *const libc::c_char,
5529                type_0: ARG_TYPE_STRING,
5530                key_spec_index: 0,
5531                token: 0 as *const libc::c_char,
5532                summary: 0 as *const libc::c_char,
5533                since: 0 as *const libc::c_char,
5534                flags: 0,
5535                deprecated_since: 0 as *const libc::c_char,
5536                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5537                num_args: 0,
5538            };
5539            init
5540        },
5541    ]
5542};
5543#[no_mangle]
5544pub static mut CLIENT_KILL_filter_Subargs: [redisCommandArg; 3] = unsafe {
5545    [
5546        {
5547            let mut init = redisCommandArg {
5548                name: b"ip:port\0" as *const u8 as *const libc::c_char,
5549                type_0: ARG_TYPE_STRING,
5550                key_spec_index: -(1 as libc::c_int),
5551                token: 0 as *const libc::c_char,
5552                summary: 0 as *const libc::c_char,
5553                since: 0 as *const libc::c_char,
5554                flags: 0 as libc::c_int,
5555                deprecated_since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5556                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5557                num_args: 0,
5558            };
5559            init
5560        },
5561        {
5562            let mut init = redisCommandArg {
5563                name: b"new-format\0" as *const u8 as *const libc::c_char,
5564                type_0: ARG_TYPE_ONEOF,
5565                key_spec_index: -(1 as libc::c_int),
5566                token: 0 as *const libc::c_char,
5567                summary: 0 as *const libc::c_char,
5568                since: 0 as *const libc::c_char,
5569                flags: (1 as libc::c_int) << 1 as libc::c_int,
5570                deprecated_since: 0 as *const libc::c_char,
5571                subargs: CLIENT_KILL_filter_new_format_Subargs.as_ptr() as *mut _,
5572                num_args: 0,
5573            };
5574            init
5575        },
5576        {
5577            let mut init = redisCommandArg {
5578                name: 0 as *const libc::c_char,
5579                type_0: ARG_TYPE_STRING,
5580                key_spec_index: 0,
5581                token: 0 as *const libc::c_char,
5582                summary: 0 as *const libc::c_char,
5583                since: 0 as *const libc::c_char,
5584                flags: 0,
5585                deprecated_since: 0 as *const libc::c_char,
5586                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5587                num_args: 0,
5588            };
5589            init
5590        },
5591    ]
5592};
5593#[no_mangle]
5594pub static mut CLIENT_KILL_Args: [redisCommandArg; 2] = unsafe {
5595    [
5596        {
5597            let mut init = redisCommandArg {
5598                name: b"filter\0" as *const u8 as *const libc::c_char,
5599                type_0: ARG_TYPE_ONEOF,
5600                key_spec_index: -(1 as libc::c_int),
5601                token: 0 as *const libc::c_char,
5602                summary: 0 as *const libc::c_char,
5603                since: 0 as *const libc::c_char,
5604                flags: 0 as libc::c_int,
5605                deprecated_since: 0 as *const libc::c_char,
5606                subargs: CLIENT_KILL_filter_Subargs.as_ptr() as *mut _,
5607                num_args: 0,
5608            };
5609            init
5610        },
5611        {
5612            let mut init = redisCommandArg {
5613                name: 0 as *const libc::c_char,
5614                type_0: ARG_TYPE_STRING,
5615                key_spec_index: 0,
5616                token: 0 as *const libc::c_char,
5617                summary: 0 as *const libc::c_char,
5618                since: 0 as *const libc::c_char,
5619                flags: 0,
5620                deprecated_since: 0 as *const libc::c_char,
5621                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5622                num_args: 0,
5623            };
5624            init
5625        },
5626    ]
5627};
5628#[no_mangle]
5629pub static mut CLIENT_LIST_History: [commandHistory; 4] = [
5630    {
5631        let mut init = commandHistory {
5632            since: b"2.8.12\0" as *const u8 as *const libc::c_char,
5633            changes: b"Added unique client `id` field.\0" as *const u8
5634                as *const libc::c_char,
5635        };
5636        init
5637    },
5638    {
5639        let mut init = commandHistory {
5640            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
5641            changes: b"Added optional `TYPE` filter.\0" as *const u8
5642                as *const libc::c_char,
5643        };
5644        init
5645    },
5646    {
5647        let mut init = commandHistory {
5648            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
5649            changes: b"Added `laddr` field and the optional `ID` filter.\0" as *const u8
5650                as *const libc::c_char,
5651        };
5652        init
5653    },
5654    {
5655        let mut init = commandHistory {
5656            since: 0 as *const libc::c_char,
5657            changes: 0 as *const libc::c_char,
5658        };
5659        init
5660    },
5661];
5662#[no_mangle]
5663pub static mut CLIENT_LIST_tips: [*const libc::c_char; 2] = [
5664    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
5665    0 as *const libc::c_char,
5666];
5667#[no_mangle]
5668pub static mut CLIENT_LIST_normal_master_replica_pubsub_Subargs: [redisCommandArg; 5] = [
5669    {
5670        let mut init = redisCommandArg {
5671            name: b"normal\0" as *const u8 as *const libc::c_char,
5672            type_0: ARG_TYPE_PURE_TOKEN,
5673            key_spec_index: -(1 as libc::c_int),
5674            token: b"NORMAL\0" as *const u8 as *const libc::c_char,
5675            summary: 0 as *const libc::c_char,
5676            since: 0 as *const libc::c_char,
5677            flags: 0 as libc::c_int,
5678            deprecated_since: 0 as *const libc::c_char,
5679            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5680            num_args: 0,
5681        };
5682        init
5683    },
5684    {
5685        let mut init = redisCommandArg {
5686            name: b"master\0" as *const u8 as *const libc::c_char,
5687            type_0: ARG_TYPE_PURE_TOKEN,
5688            key_spec_index: -(1 as libc::c_int),
5689            token: b"MASTER\0" as *const u8 as *const libc::c_char,
5690            summary: 0 as *const libc::c_char,
5691            since: 0 as *const libc::c_char,
5692            flags: 0 as libc::c_int,
5693            deprecated_since: 0 as *const libc::c_char,
5694            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5695            num_args: 0,
5696        };
5697        init
5698    },
5699    {
5700        let mut init = redisCommandArg {
5701            name: b"replica\0" as *const u8 as *const libc::c_char,
5702            type_0: ARG_TYPE_PURE_TOKEN,
5703            key_spec_index: -(1 as libc::c_int),
5704            token: b"REPLICA\0" as *const u8 as *const libc::c_char,
5705            summary: 0 as *const libc::c_char,
5706            since: 0 as *const libc::c_char,
5707            flags: 0 as libc::c_int,
5708            deprecated_since: 0 as *const libc::c_char,
5709            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5710            num_args: 0,
5711        };
5712        init
5713    },
5714    {
5715        let mut init = redisCommandArg {
5716            name: b"pubsub\0" as *const u8 as *const libc::c_char,
5717            type_0: ARG_TYPE_PURE_TOKEN,
5718            key_spec_index: -(1 as libc::c_int),
5719            token: b"PUBSUB\0" as *const u8 as *const libc::c_char,
5720            summary: 0 as *const libc::c_char,
5721            since: 0 as *const libc::c_char,
5722            flags: 0 as libc::c_int,
5723            deprecated_since: 0 as *const libc::c_char,
5724            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5725            num_args: 0,
5726        };
5727        init
5728    },
5729    {
5730        let mut init = redisCommandArg {
5731            name: 0 as *const libc::c_char,
5732            type_0: ARG_TYPE_STRING,
5733            key_spec_index: 0,
5734            token: 0 as *const libc::c_char,
5735            summary: 0 as *const libc::c_char,
5736            since: 0 as *const libc::c_char,
5737            flags: 0,
5738            deprecated_since: 0 as *const libc::c_char,
5739            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5740            num_args: 0,
5741        };
5742        init
5743    },
5744];
5745#[no_mangle]
5746pub static mut CLIENT_LIST_id_Subargs: [redisCommandArg; 2] = [
5747    {
5748        let mut init = redisCommandArg {
5749            name: b"client-id\0" as *const u8 as *const libc::c_char,
5750            type_0: ARG_TYPE_INTEGER,
5751            key_spec_index: -(1 as libc::c_int),
5752            token: 0 as *const libc::c_char,
5753            summary: 0 as *const libc::c_char,
5754            since: 0 as *const libc::c_char,
5755            flags: (1 as libc::c_int) << 1 as libc::c_int,
5756            deprecated_since: 0 as *const libc::c_char,
5757            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5758            num_args: 0,
5759        };
5760        init
5761    },
5762    {
5763        let mut init = redisCommandArg {
5764            name: 0 as *const libc::c_char,
5765            type_0: ARG_TYPE_STRING,
5766            key_spec_index: 0,
5767            token: 0 as *const libc::c_char,
5768            summary: 0 as *const libc::c_char,
5769            since: 0 as *const libc::c_char,
5770            flags: 0,
5771            deprecated_since: 0 as *const libc::c_char,
5772            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5773            num_args: 0,
5774        };
5775        init
5776    },
5777];
5778#[no_mangle]
5779pub static mut CLIENT_LIST_Args: [redisCommandArg; 3] = unsafe {
5780    [
5781        {
5782            let mut init = redisCommandArg {
5783                name: b"normal_master_replica_pubsub\0" as *const u8
5784                    as *const libc::c_char,
5785                type_0: ARG_TYPE_ONEOF,
5786                key_spec_index: -(1 as libc::c_int),
5787                token: b"TYPE\0" as *const u8 as *const libc::c_char,
5788                summary: 0 as *const libc::c_char,
5789                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
5790                flags: (1 as libc::c_int) << 0 as libc::c_int,
5791                deprecated_since: 0 as *const libc::c_char,
5792                subargs: CLIENT_LIST_normal_master_replica_pubsub_Subargs.as_ptr()
5793                    as *mut _,
5794                num_args: 0,
5795            };
5796            init
5797        },
5798        {
5799            let mut init = redisCommandArg {
5800                name: b"id\0" as *const u8 as *const libc::c_char,
5801                type_0: ARG_TYPE_BLOCK,
5802                key_spec_index: -(1 as libc::c_int),
5803                token: b"ID\0" as *const u8 as *const libc::c_char,
5804                summary: 0 as *const libc::c_char,
5805                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
5806                flags: (1 as libc::c_int) << 0 as libc::c_int,
5807                deprecated_since: 0 as *const libc::c_char,
5808                subargs: CLIENT_LIST_id_Subargs.as_ptr() as *mut _,
5809                num_args: 0,
5810            };
5811            init
5812        },
5813        {
5814            let mut init = redisCommandArg {
5815                name: 0 as *const libc::c_char,
5816                type_0: ARG_TYPE_STRING,
5817                key_spec_index: 0,
5818                token: 0 as *const libc::c_char,
5819                summary: 0 as *const libc::c_char,
5820                since: 0 as *const libc::c_char,
5821                flags: 0,
5822                deprecated_since: 0 as *const libc::c_char,
5823                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5824                num_args: 0,
5825            };
5826            init
5827        },
5828    ]
5829};
5830#[no_mangle]
5831pub static mut CLIENT_NO_EVICT_enabled_Subargs: [redisCommandArg; 3] = [
5832    {
5833        let mut init = redisCommandArg {
5834            name: b"on\0" as *const u8 as *const libc::c_char,
5835            type_0: ARG_TYPE_PURE_TOKEN,
5836            key_spec_index: -(1 as libc::c_int),
5837            token: b"ON\0" as *const u8 as *const libc::c_char,
5838            summary: 0 as *const libc::c_char,
5839            since: 0 as *const libc::c_char,
5840            flags: 0 as libc::c_int,
5841            deprecated_since: 0 as *const libc::c_char,
5842            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5843            num_args: 0,
5844        };
5845        init
5846    },
5847    {
5848        let mut init = redisCommandArg {
5849            name: b"off\0" as *const u8 as *const libc::c_char,
5850            type_0: ARG_TYPE_PURE_TOKEN,
5851            key_spec_index: -(1 as libc::c_int),
5852            token: b"OFF\0" as *const u8 as *const libc::c_char,
5853            summary: 0 as *const libc::c_char,
5854            since: 0 as *const libc::c_char,
5855            flags: 0 as libc::c_int,
5856            deprecated_since: 0 as *const libc::c_char,
5857            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5858            num_args: 0,
5859        };
5860        init
5861    },
5862    {
5863        let mut init = redisCommandArg {
5864            name: 0 as *const libc::c_char,
5865            type_0: ARG_TYPE_STRING,
5866            key_spec_index: 0,
5867            token: 0 as *const libc::c_char,
5868            summary: 0 as *const libc::c_char,
5869            since: 0 as *const libc::c_char,
5870            flags: 0,
5871            deprecated_since: 0 as *const libc::c_char,
5872            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5873            num_args: 0,
5874        };
5875        init
5876    },
5877];
5878#[no_mangle]
5879pub static mut CLIENT_NO_EVICT_Args: [redisCommandArg; 2] = unsafe {
5880    [
5881        {
5882            let mut init = redisCommandArg {
5883                name: b"enabled\0" as *const u8 as *const libc::c_char,
5884                type_0: ARG_TYPE_ONEOF,
5885                key_spec_index: -(1 as libc::c_int),
5886                token: 0 as *const libc::c_char,
5887                summary: 0 as *const libc::c_char,
5888                since: 0 as *const libc::c_char,
5889                flags: 0 as libc::c_int,
5890                deprecated_since: 0 as *const libc::c_char,
5891                subargs: CLIENT_NO_EVICT_enabled_Subargs.as_ptr() as *mut _,
5892                num_args: 0,
5893            };
5894            init
5895        },
5896        {
5897            let mut init = redisCommandArg {
5898                name: 0 as *const libc::c_char,
5899                type_0: ARG_TYPE_STRING,
5900                key_spec_index: 0,
5901                token: 0 as *const libc::c_char,
5902                summary: 0 as *const libc::c_char,
5903                since: 0 as *const libc::c_char,
5904                flags: 0,
5905                deprecated_since: 0 as *const libc::c_char,
5906                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5907                num_args: 0,
5908            };
5909            init
5910        },
5911    ]
5912};
5913#[no_mangle]
5914pub static mut CLIENT_PAUSE_History: [commandHistory; 2] = [
5915    {
5916        let mut init = commandHistory {
5917            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
5918            changes: b"`CLIENT PAUSE WRITE` mode added along with the `mode` option.\0"
5919                as *const u8 as *const libc::c_char,
5920        };
5921        init
5922    },
5923    {
5924        let mut init = commandHistory {
5925            since: 0 as *const libc::c_char,
5926            changes: 0 as *const libc::c_char,
5927        };
5928        init
5929    },
5930];
5931#[no_mangle]
5932pub static mut CLIENT_PAUSE_mode_Subargs: [redisCommandArg; 3] = [
5933    {
5934        let mut init = redisCommandArg {
5935            name: b"write\0" as *const u8 as *const libc::c_char,
5936            type_0: ARG_TYPE_PURE_TOKEN,
5937            key_spec_index: -(1 as libc::c_int),
5938            token: b"WRITE\0" as *const u8 as *const libc::c_char,
5939            summary: 0 as *const libc::c_char,
5940            since: 0 as *const libc::c_char,
5941            flags: 0 as libc::c_int,
5942            deprecated_since: 0 as *const libc::c_char,
5943            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5944            num_args: 0,
5945        };
5946        init
5947    },
5948    {
5949        let mut init = redisCommandArg {
5950            name: b"all\0" as *const u8 as *const libc::c_char,
5951            type_0: ARG_TYPE_PURE_TOKEN,
5952            key_spec_index: -(1 as libc::c_int),
5953            token: b"ALL\0" as *const u8 as *const libc::c_char,
5954            summary: 0 as *const libc::c_char,
5955            since: 0 as *const libc::c_char,
5956            flags: 0 as libc::c_int,
5957            deprecated_since: 0 as *const libc::c_char,
5958            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5959            num_args: 0,
5960        };
5961        init
5962    },
5963    {
5964        let mut init = redisCommandArg {
5965            name: 0 as *const libc::c_char,
5966            type_0: ARG_TYPE_STRING,
5967            key_spec_index: 0,
5968            token: 0 as *const libc::c_char,
5969            summary: 0 as *const libc::c_char,
5970            since: 0 as *const libc::c_char,
5971            flags: 0,
5972            deprecated_since: 0 as *const libc::c_char,
5973            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5974            num_args: 0,
5975        };
5976        init
5977    },
5978];
5979#[no_mangle]
5980pub static mut CLIENT_PAUSE_Args: [redisCommandArg; 3] = unsafe {
5981    [
5982        {
5983            let mut init = redisCommandArg {
5984                name: b"timeout\0" as *const u8 as *const libc::c_char,
5985                type_0: ARG_TYPE_INTEGER,
5986                key_spec_index: -(1 as libc::c_int),
5987                token: 0 as *const libc::c_char,
5988                summary: 0 as *const libc::c_char,
5989                since: 0 as *const libc::c_char,
5990                flags: 0 as libc::c_int,
5991                deprecated_since: 0 as *const libc::c_char,
5992                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
5993                num_args: 0,
5994            };
5995            init
5996        },
5997        {
5998            let mut init = redisCommandArg {
5999                name: b"mode\0" as *const u8 as *const libc::c_char,
6000                type_0: ARG_TYPE_ONEOF,
6001                key_spec_index: -(1 as libc::c_int),
6002                token: 0 as *const libc::c_char,
6003                summary: 0 as *const libc::c_char,
6004                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
6005                flags: (1 as libc::c_int) << 0 as libc::c_int,
6006                deprecated_since: 0 as *const libc::c_char,
6007                subargs: CLIENT_PAUSE_mode_Subargs.as_ptr() as *mut _,
6008                num_args: 0,
6009            };
6010            init
6011        },
6012        {
6013            let mut init = redisCommandArg {
6014                name: 0 as *const libc::c_char,
6015                type_0: ARG_TYPE_STRING,
6016                key_spec_index: 0,
6017                token: 0 as *const libc::c_char,
6018                summary: 0 as *const libc::c_char,
6019                since: 0 as *const libc::c_char,
6020                flags: 0,
6021                deprecated_since: 0 as *const libc::c_char,
6022                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6023                num_args: 0,
6024            };
6025            init
6026        },
6027    ]
6028};
6029#[no_mangle]
6030pub static mut CLIENT_REPLY_on_off_skip_Subargs: [redisCommandArg; 4] = [
6031    {
6032        let mut init = redisCommandArg {
6033            name: b"on\0" as *const u8 as *const libc::c_char,
6034            type_0: ARG_TYPE_PURE_TOKEN,
6035            key_spec_index: -(1 as libc::c_int),
6036            token: b"ON\0" as *const u8 as *const libc::c_char,
6037            summary: 0 as *const libc::c_char,
6038            since: 0 as *const libc::c_char,
6039            flags: 0 as libc::c_int,
6040            deprecated_since: 0 as *const libc::c_char,
6041            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6042            num_args: 0,
6043        };
6044        init
6045    },
6046    {
6047        let mut init = redisCommandArg {
6048            name: b"off\0" as *const u8 as *const libc::c_char,
6049            type_0: ARG_TYPE_PURE_TOKEN,
6050            key_spec_index: -(1 as libc::c_int),
6051            token: b"OFF\0" as *const u8 as *const libc::c_char,
6052            summary: 0 as *const libc::c_char,
6053            since: 0 as *const libc::c_char,
6054            flags: 0 as libc::c_int,
6055            deprecated_since: 0 as *const libc::c_char,
6056            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6057            num_args: 0,
6058        };
6059        init
6060    },
6061    {
6062        let mut init = redisCommandArg {
6063            name: b"skip\0" as *const u8 as *const libc::c_char,
6064            type_0: ARG_TYPE_PURE_TOKEN,
6065            key_spec_index: -(1 as libc::c_int),
6066            token: b"SKIP\0" as *const u8 as *const libc::c_char,
6067            summary: 0 as *const libc::c_char,
6068            since: 0 as *const libc::c_char,
6069            flags: 0 as libc::c_int,
6070            deprecated_since: 0 as *const libc::c_char,
6071            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6072            num_args: 0,
6073        };
6074        init
6075    },
6076    {
6077        let mut init = redisCommandArg {
6078            name: 0 as *const libc::c_char,
6079            type_0: ARG_TYPE_STRING,
6080            key_spec_index: 0,
6081            token: 0 as *const libc::c_char,
6082            summary: 0 as *const libc::c_char,
6083            since: 0 as *const libc::c_char,
6084            flags: 0,
6085            deprecated_since: 0 as *const libc::c_char,
6086            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6087            num_args: 0,
6088        };
6089        init
6090    },
6091];
6092#[no_mangle]
6093pub static mut CLIENT_REPLY_Args: [redisCommandArg; 2] = unsafe {
6094    [
6095        {
6096            let mut init = redisCommandArg {
6097                name: b"on_off_skip\0" as *const u8 as *const libc::c_char,
6098                type_0: ARG_TYPE_ONEOF,
6099                key_spec_index: -(1 as libc::c_int),
6100                token: 0 as *const libc::c_char,
6101                summary: 0 as *const libc::c_char,
6102                since: 0 as *const libc::c_char,
6103                flags: 0 as libc::c_int,
6104                deprecated_since: 0 as *const libc::c_char,
6105                subargs: CLIENT_REPLY_on_off_skip_Subargs.as_ptr() as *mut _,
6106                num_args: 0,
6107            };
6108            init
6109        },
6110        {
6111            let mut init = redisCommandArg {
6112                name: 0 as *const libc::c_char,
6113                type_0: ARG_TYPE_STRING,
6114                key_spec_index: 0,
6115                token: 0 as *const libc::c_char,
6116                summary: 0 as *const libc::c_char,
6117                since: 0 as *const libc::c_char,
6118                flags: 0,
6119                deprecated_since: 0 as *const libc::c_char,
6120                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6121                num_args: 0,
6122            };
6123            init
6124        },
6125    ]
6126};
6127#[no_mangle]
6128pub static mut CLIENT_SETNAME_Args: [redisCommandArg; 2] = [
6129    {
6130        let mut init = redisCommandArg {
6131            name: b"connection-name\0" as *const u8 as *const libc::c_char,
6132            type_0: ARG_TYPE_STRING,
6133            key_spec_index: -(1 as libc::c_int),
6134            token: 0 as *const libc::c_char,
6135            summary: 0 as *const libc::c_char,
6136            since: 0 as *const libc::c_char,
6137            flags: 0 as libc::c_int,
6138            deprecated_since: 0 as *const libc::c_char,
6139            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6140            num_args: 0,
6141        };
6142        init
6143    },
6144    {
6145        let mut init = redisCommandArg {
6146            name: 0 as *const libc::c_char,
6147            type_0: ARG_TYPE_STRING,
6148            key_spec_index: 0,
6149            token: 0 as *const libc::c_char,
6150            summary: 0 as *const libc::c_char,
6151            since: 0 as *const libc::c_char,
6152            flags: 0,
6153            deprecated_since: 0 as *const libc::c_char,
6154            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6155            num_args: 0,
6156        };
6157        init
6158    },
6159];
6160#[no_mangle]
6161pub static mut CLIENT_TRACKING_status_Subargs: [redisCommandArg; 3] = [
6162    {
6163        let mut init = redisCommandArg {
6164            name: b"on\0" as *const u8 as *const libc::c_char,
6165            type_0: ARG_TYPE_PURE_TOKEN,
6166            key_spec_index: -(1 as libc::c_int),
6167            token: b"ON\0" as *const u8 as *const libc::c_char,
6168            summary: 0 as *const libc::c_char,
6169            since: 0 as *const libc::c_char,
6170            flags: 0 as libc::c_int,
6171            deprecated_since: 0 as *const libc::c_char,
6172            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6173            num_args: 0,
6174        };
6175        init
6176    },
6177    {
6178        let mut init = redisCommandArg {
6179            name: b"off\0" as *const u8 as *const libc::c_char,
6180            type_0: ARG_TYPE_PURE_TOKEN,
6181            key_spec_index: -(1 as libc::c_int),
6182            token: b"OFF\0" as *const u8 as *const libc::c_char,
6183            summary: 0 as *const libc::c_char,
6184            since: 0 as *const libc::c_char,
6185            flags: 0 as libc::c_int,
6186            deprecated_since: 0 as *const libc::c_char,
6187            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6188            num_args: 0,
6189        };
6190        init
6191    },
6192    {
6193        let mut init = redisCommandArg {
6194            name: 0 as *const libc::c_char,
6195            type_0: ARG_TYPE_STRING,
6196            key_spec_index: 0,
6197            token: 0 as *const libc::c_char,
6198            summary: 0 as *const libc::c_char,
6199            since: 0 as *const libc::c_char,
6200            flags: 0,
6201            deprecated_since: 0 as *const libc::c_char,
6202            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6203            num_args: 0,
6204        };
6205        init
6206    },
6207];
6208#[no_mangle]
6209pub static mut CLIENT_TRACKING_Args: [redisCommandArg; 8] = unsafe {
6210    [
6211        {
6212            let mut init = redisCommandArg {
6213                name: b"status\0" as *const u8 as *const libc::c_char,
6214                type_0: ARG_TYPE_ONEOF,
6215                key_spec_index: -(1 as libc::c_int),
6216                token: 0 as *const libc::c_char,
6217                summary: 0 as *const libc::c_char,
6218                since: 0 as *const libc::c_char,
6219                flags: 0 as libc::c_int,
6220                deprecated_since: 0 as *const libc::c_char,
6221                subargs: CLIENT_TRACKING_status_Subargs.as_ptr() as *mut _,
6222                num_args: 0,
6223            };
6224            init
6225        },
6226        {
6227            let mut init = redisCommandArg {
6228                name: b"client-id\0" as *const u8 as *const libc::c_char,
6229                type_0: ARG_TYPE_INTEGER,
6230                key_spec_index: -(1 as libc::c_int),
6231                token: b"REDIRECT\0" as *const u8 as *const libc::c_char,
6232                summary: 0 as *const libc::c_char,
6233                since: 0 as *const libc::c_char,
6234                flags: (1 as libc::c_int) << 0 as libc::c_int,
6235                deprecated_since: 0 as *const libc::c_char,
6236                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6237                num_args: 0,
6238            };
6239            init
6240        },
6241        {
6242            let mut init = redisCommandArg {
6243                name: b"prefix\0" as *const u8 as *const libc::c_char,
6244                type_0: ARG_TYPE_STRING,
6245                key_spec_index: -(1 as libc::c_int),
6246                token: b"PREFIX\0" as *const u8 as *const libc::c_char,
6247                summary: 0 as *const libc::c_char,
6248                since: 0 as *const libc::c_char,
6249                flags: (1 as libc::c_int) << 0 as libc::c_int
6250                    | (1 as libc::c_int) << 1 as libc::c_int
6251                    | (1 as libc::c_int) << 2 as libc::c_int,
6252                deprecated_since: 0 as *const libc::c_char,
6253                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6254                num_args: 0,
6255            };
6256            init
6257        },
6258        {
6259            let mut init = redisCommandArg {
6260                name: b"bcast\0" as *const u8 as *const libc::c_char,
6261                type_0: ARG_TYPE_PURE_TOKEN,
6262                key_spec_index: -(1 as libc::c_int),
6263                token: b"BCAST\0" as *const u8 as *const libc::c_char,
6264                summary: 0 as *const libc::c_char,
6265                since: 0 as *const libc::c_char,
6266                flags: (1 as libc::c_int) << 0 as libc::c_int,
6267                deprecated_since: 0 as *const libc::c_char,
6268                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6269                num_args: 0,
6270            };
6271            init
6272        },
6273        {
6274            let mut init = redisCommandArg {
6275                name: b"optin\0" as *const u8 as *const libc::c_char,
6276                type_0: ARG_TYPE_PURE_TOKEN,
6277                key_spec_index: -(1 as libc::c_int),
6278                token: b"OPTIN\0" as *const u8 as *const libc::c_char,
6279                summary: 0 as *const libc::c_char,
6280                since: 0 as *const libc::c_char,
6281                flags: (1 as libc::c_int) << 0 as libc::c_int,
6282                deprecated_since: 0 as *const libc::c_char,
6283                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6284                num_args: 0,
6285            };
6286            init
6287        },
6288        {
6289            let mut init = redisCommandArg {
6290                name: b"optout\0" as *const u8 as *const libc::c_char,
6291                type_0: ARG_TYPE_PURE_TOKEN,
6292                key_spec_index: -(1 as libc::c_int),
6293                token: b"OPTOUT\0" as *const u8 as *const libc::c_char,
6294                summary: 0 as *const libc::c_char,
6295                since: 0 as *const libc::c_char,
6296                flags: (1 as libc::c_int) << 0 as libc::c_int,
6297                deprecated_since: 0 as *const libc::c_char,
6298                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6299                num_args: 0,
6300            };
6301            init
6302        },
6303        {
6304            let mut init = redisCommandArg {
6305                name: b"noloop\0" as *const u8 as *const libc::c_char,
6306                type_0: ARG_TYPE_PURE_TOKEN,
6307                key_spec_index: -(1 as libc::c_int),
6308                token: b"NOLOOP\0" as *const u8 as *const libc::c_char,
6309                summary: 0 as *const libc::c_char,
6310                since: 0 as *const libc::c_char,
6311                flags: (1 as libc::c_int) << 0 as libc::c_int,
6312                deprecated_since: 0 as *const libc::c_char,
6313                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6314                num_args: 0,
6315            };
6316            init
6317        },
6318        {
6319            let mut init = redisCommandArg {
6320                name: 0 as *const libc::c_char,
6321                type_0: ARG_TYPE_STRING,
6322                key_spec_index: 0,
6323                token: 0 as *const libc::c_char,
6324                summary: 0 as *const libc::c_char,
6325                since: 0 as *const libc::c_char,
6326                flags: 0,
6327                deprecated_since: 0 as *const libc::c_char,
6328                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6329                num_args: 0,
6330            };
6331            init
6332        },
6333    ]
6334};
6335#[no_mangle]
6336pub static mut CLIENT_UNBLOCK_timeout_error_Subargs: [redisCommandArg; 3] = [
6337    {
6338        let mut init = redisCommandArg {
6339            name: b"timeout\0" as *const u8 as *const libc::c_char,
6340            type_0: ARG_TYPE_PURE_TOKEN,
6341            key_spec_index: -(1 as libc::c_int),
6342            token: b"TIMEOUT\0" as *const u8 as *const libc::c_char,
6343            summary: 0 as *const libc::c_char,
6344            since: 0 as *const libc::c_char,
6345            flags: 0 as libc::c_int,
6346            deprecated_since: 0 as *const libc::c_char,
6347            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6348            num_args: 0,
6349        };
6350        init
6351    },
6352    {
6353        let mut init = redisCommandArg {
6354            name: b"error\0" as *const u8 as *const libc::c_char,
6355            type_0: ARG_TYPE_PURE_TOKEN,
6356            key_spec_index: -(1 as libc::c_int),
6357            token: b"ERROR\0" as *const u8 as *const libc::c_char,
6358            summary: 0 as *const libc::c_char,
6359            since: 0 as *const libc::c_char,
6360            flags: 0 as libc::c_int,
6361            deprecated_since: 0 as *const libc::c_char,
6362            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6363            num_args: 0,
6364        };
6365        init
6366    },
6367    {
6368        let mut init = redisCommandArg {
6369            name: 0 as *const libc::c_char,
6370            type_0: ARG_TYPE_STRING,
6371            key_spec_index: 0,
6372            token: 0 as *const libc::c_char,
6373            summary: 0 as *const libc::c_char,
6374            since: 0 as *const libc::c_char,
6375            flags: 0,
6376            deprecated_since: 0 as *const libc::c_char,
6377            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6378            num_args: 0,
6379        };
6380        init
6381    },
6382];
6383#[no_mangle]
6384pub static mut CLIENT_UNBLOCK_Args: [redisCommandArg; 3] = unsafe {
6385    [
6386        {
6387            let mut init = redisCommandArg {
6388                name: b"client-id\0" as *const u8 as *const libc::c_char,
6389                type_0: ARG_TYPE_INTEGER,
6390                key_spec_index: -(1 as libc::c_int),
6391                token: 0 as *const libc::c_char,
6392                summary: 0 as *const libc::c_char,
6393                since: 0 as *const libc::c_char,
6394                flags: 0 as libc::c_int,
6395                deprecated_since: 0 as *const libc::c_char,
6396                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6397                num_args: 0,
6398            };
6399            init
6400        },
6401        {
6402            let mut init = redisCommandArg {
6403                name: b"timeout_error\0" as *const u8 as *const libc::c_char,
6404                type_0: ARG_TYPE_ONEOF,
6405                key_spec_index: -(1 as libc::c_int),
6406                token: 0 as *const libc::c_char,
6407                summary: 0 as *const libc::c_char,
6408                since: 0 as *const libc::c_char,
6409                flags: (1 as libc::c_int) << 0 as libc::c_int,
6410                deprecated_since: 0 as *const libc::c_char,
6411                subargs: CLIENT_UNBLOCK_timeout_error_Subargs.as_ptr() as *mut _,
6412                num_args: 0,
6413            };
6414            init
6415        },
6416        {
6417            let mut init = redisCommandArg {
6418                name: 0 as *const libc::c_char,
6419                type_0: ARG_TYPE_STRING,
6420                key_spec_index: 0,
6421                token: 0 as *const libc::c_char,
6422                summary: 0 as *const libc::c_char,
6423                since: 0 as *const libc::c_char,
6424                flags: 0,
6425                deprecated_since: 0 as *const libc::c_char,
6426                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
6427                num_args: 0,
6428            };
6429            init
6430        },
6431    ]
6432};
6433#[no_mangle]
6434pub static mut CLIENT_Subcommands: [redisCommand; 17] = unsafe {
6435    [
6436        {
6437            let mut init = redisCommand {
6438                declared_name: b"caching\0" as *const u8 as *const libc::c_char,
6439                summary: b"Instruct the server about tracking or not keys in the next request\0"
6440                    as *const u8 as *const libc::c_char,
6441                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6442                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
6443                doc_flags: 0 as libc::c_int,
6444                replaced_by: 0 as *const libc::c_char,
6445                deprecated_since: 0 as *const libc::c_char,
6446                group: COMMAND_GROUP_CONNECTION,
6447                history: 0 as *const commandHistory as *mut commandHistory,
6448                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6449                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6450                arity: 3 as libc::c_int,
6451                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
6452                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6453                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6454                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6455                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6456                    as uint64_t,
6457                key_specs_static: [keySpec {
6458                    notes: 0 as *const libc::c_char,
6459                    flags: 0,
6460                    begin_search_type: KSPEC_BS_INVALID,
6461                    bs: C2RustUnnamed_3 {
6462                        index: C2RustUnnamed_5 { pos: 0 },
6463                    },
6464                    find_keys_type: KSPEC_FK_INVALID,
6465                    fk: C2RustUnnamed_0 {
6466                        range: C2RustUnnamed_2 {
6467                            lastkey: 0,
6468                            keystep: 0,
6469                            limit: 0,
6470                        },
6471                    },
6472                }; 4],
6473                getkeys_proc: None,
6474                subcommands: 0 as *const redisCommand as *mut redisCommand,
6475                args: CLIENT_CACHING_Args.as_ptr() as *mut _,
6476                microseconds: 0,
6477                calls: 0,
6478                rejected_calls: 0,
6479                failed_calls: 0,
6480                id: 0,
6481                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6482                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6483                key_specs: 0 as *const keySpec as *mut keySpec,
6484                legacy_range_key_spec: keySpec {
6485                    notes: 0 as *const libc::c_char,
6486                    flags: 0,
6487                    begin_search_type: KSPEC_BS_INVALID,
6488                    bs: C2RustUnnamed_3 {
6489                        index: C2RustUnnamed_5 { pos: 0 },
6490                    },
6491                    find_keys_type: KSPEC_FK_INVALID,
6492                    fk: C2RustUnnamed_0 {
6493                        range: C2RustUnnamed_2 {
6494                            lastkey: 0,
6495                            keystep: 0,
6496                            limit: 0,
6497                        },
6498                    },
6499                },
6500                num_args: 0,
6501                num_history: 0,
6502                num_tips: 0,
6503                key_specs_num: 0,
6504                key_specs_max: 0,
6505                subcommands_dict: 0 as *const dict as *mut dict,
6506                parent: 0 as *const redisCommand as *mut redisCommand,
6507                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6508            };
6509            init
6510        },
6511        {
6512            let mut init = redisCommand {
6513                declared_name: b"getname\0" as *const u8 as *const libc::c_char,
6514                summary: b"Get the current connection name\0" as *const u8
6515                    as *const libc::c_char,
6516                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6517                since: b"2.6.9\0" as *const u8 as *const libc::c_char,
6518                doc_flags: 0 as libc::c_int,
6519                replaced_by: 0 as *const libc::c_char,
6520                deprecated_since: 0 as *const libc::c_char,
6521                group: COMMAND_GROUP_CONNECTION,
6522                history: 0 as *const commandHistory as *mut commandHistory,
6523                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6524                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6525                arity: 2 as libc::c_int,
6526                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
6527                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6528                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6529                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6530                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6531                    as uint64_t,
6532                key_specs_static: [keySpec {
6533                    notes: 0 as *const libc::c_char,
6534                    flags: 0,
6535                    begin_search_type: KSPEC_BS_INVALID,
6536                    bs: C2RustUnnamed_3 {
6537                        index: C2RustUnnamed_5 { pos: 0 },
6538                    },
6539                    find_keys_type: KSPEC_FK_INVALID,
6540                    fk: C2RustUnnamed_0 {
6541                        range: C2RustUnnamed_2 {
6542                            lastkey: 0,
6543                            keystep: 0,
6544                            limit: 0,
6545                        },
6546                    },
6547                }; 4],
6548                getkeys_proc: None,
6549                subcommands: 0 as *const redisCommand as *mut redisCommand,
6550                args: 0 as *const redisCommandArg as *mut redisCommandArg,
6551                microseconds: 0,
6552                calls: 0,
6553                rejected_calls: 0,
6554                failed_calls: 0,
6555                id: 0,
6556                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6557                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6558                key_specs: 0 as *const keySpec as *mut keySpec,
6559                legacy_range_key_spec: keySpec {
6560                    notes: 0 as *const libc::c_char,
6561                    flags: 0,
6562                    begin_search_type: KSPEC_BS_INVALID,
6563                    bs: C2RustUnnamed_3 {
6564                        index: C2RustUnnamed_5 { pos: 0 },
6565                    },
6566                    find_keys_type: KSPEC_FK_INVALID,
6567                    fk: C2RustUnnamed_0 {
6568                        range: C2RustUnnamed_2 {
6569                            lastkey: 0,
6570                            keystep: 0,
6571                            limit: 0,
6572                        },
6573                    },
6574                },
6575                num_args: 0,
6576                num_history: 0,
6577                num_tips: 0,
6578                key_specs_num: 0,
6579                key_specs_max: 0,
6580                subcommands_dict: 0 as *const dict as *mut dict,
6581                parent: 0 as *const redisCommand as *mut redisCommand,
6582                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6583            };
6584            init
6585        },
6586        {
6587            let mut init = redisCommand {
6588                declared_name: b"getredir\0" as *const u8 as *const libc::c_char,
6589                summary: b"Get tracking notifications redirection client ID if any\0"
6590                    as *const u8 as *const libc::c_char,
6591                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6592                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
6593                doc_flags: 0 as libc::c_int,
6594                replaced_by: 0 as *const libc::c_char,
6595                deprecated_since: 0 as *const libc::c_char,
6596                group: COMMAND_GROUP_CONNECTION,
6597                history: 0 as *const commandHistory as *mut commandHistory,
6598                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6599                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6600                arity: 2 as libc::c_int,
6601                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
6602                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6603                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6604                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6605                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6606                    as uint64_t,
6607                key_specs_static: [keySpec {
6608                    notes: 0 as *const libc::c_char,
6609                    flags: 0,
6610                    begin_search_type: KSPEC_BS_INVALID,
6611                    bs: C2RustUnnamed_3 {
6612                        index: C2RustUnnamed_5 { pos: 0 },
6613                    },
6614                    find_keys_type: KSPEC_FK_INVALID,
6615                    fk: C2RustUnnamed_0 {
6616                        range: C2RustUnnamed_2 {
6617                            lastkey: 0,
6618                            keystep: 0,
6619                            limit: 0,
6620                        },
6621                    },
6622                }; 4],
6623                getkeys_proc: None,
6624                subcommands: 0 as *const redisCommand as *mut redisCommand,
6625                args: 0 as *const redisCommandArg as *mut redisCommandArg,
6626                microseconds: 0,
6627                calls: 0,
6628                rejected_calls: 0,
6629                failed_calls: 0,
6630                id: 0,
6631                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6632                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6633                key_specs: 0 as *const keySpec as *mut keySpec,
6634                legacy_range_key_spec: keySpec {
6635                    notes: 0 as *const libc::c_char,
6636                    flags: 0,
6637                    begin_search_type: KSPEC_BS_INVALID,
6638                    bs: C2RustUnnamed_3 {
6639                        index: C2RustUnnamed_5 { pos: 0 },
6640                    },
6641                    find_keys_type: KSPEC_FK_INVALID,
6642                    fk: C2RustUnnamed_0 {
6643                        range: C2RustUnnamed_2 {
6644                            lastkey: 0,
6645                            keystep: 0,
6646                            limit: 0,
6647                        },
6648                    },
6649                },
6650                num_args: 0,
6651                num_history: 0,
6652                num_tips: 0,
6653                key_specs_num: 0,
6654                key_specs_max: 0,
6655                subcommands_dict: 0 as *const dict as *mut dict,
6656                parent: 0 as *const redisCommand as *mut redisCommand,
6657                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6658            };
6659            init
6660        },
6661        {
6662            let mut init = redisCommand {
6663                declared_name: b"help\0" as *const u8 as *const libc::c_char,
6664                summary: b"Show helpful text about the different subcommands\0"
6665                    as *const u8 as *const libc::c_char,
6666                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6667                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
6668                doc_flags: 0 as libc::c_int,
6669                replaced_by: 0 as *const libc::c_char,
6670                deprecated_since: 0 as *const libc::c_char,
6671                group: COMMAND_GROUP_CONNECTION,
6672                history: 0 as *const commandHistory as *mut commandHistory,
6673                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6674                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6675                arity: 2 as libc::c_int,
6676                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
6677                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6678                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6679                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6680                    as uint64_t,
6681                key_specs_static: [keySpec {
6682                    notes: 0 as *const libc::c_char,
6683                    flags: 0,
6684                    begin_search_type: KSPEC_BS_INVALID,
6685                    bs: C2RustUnnamed_3 {
6686                        index: C2RustUnnamed_5 { pos: 0 },
6687                    },
6688                    find_keys_type: KSPEC_FK_INVALID,
6689                    fk: C2RustUnnamed_0 {
6690                        range: C2RustUnnamed_2 {
6691                            lastkey: 0,
6692                            keystep: 0,
6693                            limit: 0,
6694                        },
6695                    },
6696                }; 4],
6697                getkeys_proc: None,
6698                subcommands: 0 as *const redisCommand as *mut redisCommand,
6699                args: 0 as *const redisCommandArg as *mut redisCommandArg,
6700                microseconds: 0,
6701                calls: 0,
6702                rejected_calls: 0,
6703                failed_calls: 0,
6704                id: 0,
6705                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6706                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6707                key_specs: 0 as *const keySpec as *mut keySpec,
6708                legacy_range_key_spec: keySpec {
6709                    notes: 0 as *const libc::c_char,
6710                    flags: 0,
6711                    begin_search_type: KSPEC_BS_INVALID,
6712                    bs: C2RustUnnamed_3 {
6713                        index: C2RustUnnamed_5 { pos: 0 },
6714                    },
6715                    find_keys_type: KSPEC_FK_INVALID,
6716                    fk: C2RustUnnamed_0 {
6717                        range: C2RustUnnamed_2 {
6718                            lastkey: 0,
6719                            keystep: 0,
6720                            limit: 0,
6721                        },
6722                    },
6723                },
6724                num_args: 0,
6725                num_history: 0,
6726                num_tips: 0,
6727                key_specs_num: 0,
6728                key_specs_max: 0,
6729                subcommands_dict: 0 as *const dict as *mut dict,
6730                parent: 0 as *const redisCommand as *mut redisCommand,
6731                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6732            };
6733            init
6734        },
6735        {
6736            let mut init = redisCommand {
6737                declared_name: b"id\0" as *const u8 as *const libc::c_char,
6738                summary: b"Returns the client ID for the current connection\0"
6739                    as *const u8 as *const libc::c_char,
6740                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6741                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
6742                doc_flags: 0 as libc::c_int,
6743                replaced_by: 0 as *const libc::c_char,
6744                deprecated_since: 0 as *const libc::c_char,
6745                group: COMMAND_GROUP_CONNECTION,
6746                history: 0 as *const commandHistory as *mut commandHistory,
6747                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6748                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6749                arity: 2 as libc::c_int,
6750                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
6751                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6752                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6753                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6754                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6755                    as uint64_t,
6756                key_specs_static: [keySpec {
6757                    notes: 0 as *const libc::c_char,
6758                    flags: 0,
6759                    begin_search_type: KSPEC_BS_INVALID,
6760                    bs: C2RustUnnamed_3 {
6761                        index: C2RustUnnamed_5 { pos: 0 },
6762                    },
6763                    find_keys_type: KSPEC_FK_INVALID,
6764                    fk: C2RustUnnamed_0 {
6765                        range: C2RustUnnamed_2 {
6766                            lastkey: 0,
6767                            keystep: 0,
6768                            limit: 0,
6769                        },
6770                    },
6771                }; 4],
6772                getkeys_proc: None,
6773                subcommands: 0 as *const redisCommand as *mut redisCommand,
6774                args: 0 as *const redisCommandArg as *mut redisCommandArg,
6775                microseconds: 0,
6776                calls: 0,
6777                rejected_calls: 0,
6778                failed_calls: 0,
6779                id: 0,
6780                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6781                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6782                key_specs: 0 as *const keySpec as *mut keySpec,
6783                legacy_range_key_spec: keySpec {
6784                    notes: 0 as *const libc::c_char,
6785                    flags: 0,
6786                    begin_search_type: KSPEC_BS_INVALID,
6787                    bs: C2RustUnnamed_3 {
6788                        index: C2RustUnnamed_5 { pos: 0 },
6789                    },
6790                    find_keys_type: KSPEC_FK_INVALID,
6791                    fk: C2RustUnnamed_0 {
6792                        range: C2RustUnnamed_2 {
6793                            lastkey: 0,
6794                            keystep: 0,
6795                            limit: 0,
6796                        },
6797                    },
6798                },
6799                num_args: 0,
6800                num_history: 0,
6801                num_tips: 0,
6802                key_specs_num: 0,
6803                key_specs_max: 0,
6804                subcommands_dict: 0 as *const dict as *mut dict,
6805                parent: 0 as *const redisCommand as *mut redisCommand,
6806                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6807            };
6808            init
6809        },
6810        {
6811            let mut init = redisCommand {
6812                declared_name: b"info\0" as *const u8 as *const libc::c_char,
6813                summary: b"Returns information about the current client connection.\0"
6814                    as *const u8 as *const libc::c_char,
6815                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
6816                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
6817                doc_flags: 0 as libc::c_int,
6818                replaced_by: 0 as *const libc::c_char,
6819                deprecated_since: 0 as *const libc::c_char,
6820                group: COMMAND_GROUP_CONNECTION,
6821                history: 0 as *const commandHistory as *mut commandHistory,
6822                tips: CLIENT_INFO_tips.as_ptr() as *mut _,
6823                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6824                arity: 2 as libc::c_int,
6825                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
6826                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6827                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6828                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6829                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6830                    as uint64_t,
6831                key_specs_static: [keySpec {
6832                    notes: 0 as *const libc::c_char,
6833                    flags: 0,
6834                    begin_search_type: KSPEC_BS_INVALID,
6835                    bs: C2RustUnnamed_3 {
6836                        index: C2RustUnnamed_5 { pos: 0 },
6837                    },
6838                    find_keys_type: KSPEC_FK_INVALID,
6839                    fk: C2RustUnnamed_0 {
6840                        range: C2RustUnnamed_2 {
6841                            lastkey: 0,
6842                            keystep: 0,
6843                            limit: 0,
6844                        },
6845                    },
6846                }; 4],
6847                getkeys_proc: None,
6848                subcommands: 0 as *const redisCommand as *mut redisCommand,
6849                args: 0 as *const redisCommandArg as *mut redisCommandArg,
6850                microseconds: 0,
6851                calls: 0,
6852                rejected_calls: 0,
6853                failed_calls: 0,
6854                id: 0,
6855                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6856                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6857                key_specs: 0 as *const keySpec as *mut keySpec,
6858                legacy_range_key_spec: keySpec {
6859                    notes: 0 as *const libc::c_char,
6860                    flags: 0,
6861                    begin_search_type: KSPEC_BS_INVALID,
6862                    bs: C2RustUnnamed_3 {
6863                        index: C2RustUnnamed_5 { pos: 0 },
6864                    },
6865                    find_keys_type: KSPEC_FK_INVALID,
6866                    fk: C2RustUnnamed_0 {
6867                        range: C2RustUnnamed_2 {
6868                            lastkey: 0,
6869                            keystep: 0,
6870                            limit: 0,
6871                        },
6872                    },
6873                },
6874                num_args: 0,
6875                num_history: 0,
6876                num_tips: 0,
6877                key_specs_num: 0,
6878                key_specs_max: 0,
6879                subcommands_dict: 0 as *const dict as *mut dict,
6880                parent: 0 as *const redisCommand as *mut redisCommand,
6881                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6882            };
6883            init
6884        },
6885        {
6886            let mut init = redisCommand {
6887                declared_name: b"kill\0" as *const u8 as *const libc::c_char,
6888                summary: b"Kill the connection of a client\0" as *const u8
6889                    as *const libc::c_char,
6890                complexity: b"O(N) where N is the number of client connections\0"
6891                    as *const u8 as *const libc::c_char,
6892                since: b"2.4.0\0" as *const u8 as *const libc::c_char,
6893                doc_flags: 0 as libc::c_int,
6894                replaced_by: 0 as *const libc::c_char,
6895                deprecated_since: 0 as *const libc::c_char,
6896                group: COMMAND_GROUP_CONNECTION,
6897                history: CLIENT_KILL_History.as_ptr() as *mut _,
6898                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
6899                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6900                arity: -(3 as libc::c_int),
6901                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
6902                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
6903                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6904                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6905                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6906                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6907                    as uint64_t,
6908                key_specs_static: [keySpec {
6909                    notes: 0 as *const libc::c_char,
6910                    flags: 0,
6911                    begin_search_type: KSPEC_BS_INVALID,
6912                    bs: C2RustUnnamed_3 {
6913                        index: C2RustUnnamed_5 { pos: 0 },
6914                    },
6915                    find_keys_type: KSPEC_FK_INVALID,
6916                    fk: C2RustUnnamed_0 {
6917                        range: C2RustUnnamed_2 {
6918                            lastkey: 0,
6919                            keystep: 0,
6920                            limit: 0,
6921                        },
6922                    },
6923                }; 4],
6924                getkeys_proc: None,
6925                subcommands: 0 as *const redisCommand as *mut redisCommand,
6926                args: CLIENT_KILL_Args.as_ptr() as *mut _,
6927                microseconds: 0,
6928                calls: 0,
6929                rejected_calls: 0,
6930                failed_calls: 0,
6931                id: 0,
6932                fullname: 0 as *const libc::c_char as *mut libc::c_char,
6933                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
6934                key_specs: 0 as *const keySpec as *mut keySpec,
6935                legacy_range_key_spec: keySpec {
6936                    notes: 0 as *const libc::c_char,
6937                    flags: 0,
6938                    begin_search_type: KSPEC_BS_INVALID,
6939                    bs: C2RustUnnamed_3 {
6940                        index: C2RustUnnamed_5 { pos: 0 },
6941                    },
6942                    find_keys_type: KSPEC_FK_INVALID,
6943                    fk: C2RustUnnamed_0 {
6944                        range: C2RustUnnamed_2 {
6945                            lastkey: 0,
6946                            keystep: 0,
6947                            limit: 0,
6948                        },
6949                    },
6950                },
6951                num_args: 0,
6952                num_history: 0,
6953                num_tips: 0,
6954                key_specs_num: 0,
6955                key_specs_max: 0,
6956                subcommands_dict: 0 as *const dict as *mut dict,
6957                parent: 0 as *const redisCommand as *mut redisCommand,
6958                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
6959            };
6960            init
6961        },
6962        {
6963            let mut init = redisCommand {
6964                declared_name: b"list\0" as *const u8 as *const libc::c_char,
6965                summary: b"Get the list of client connections\0" as *const u8
6966                    as *const libc::c_char,
6967                complexity: b"O(N) where N is the number of client connections\0"
6968                    as *const u8 as *const libc::c_char,
6969                since: b"2.4.0\0" as *const u8 as *const libc::c_char,
6970                doc_flags: 0 as libc::c_int,
6971                replaced_by: 0 as *const libc::c_char,
6972                deprecated_since: 0 as *const libc::c_char,
6973                group: COMMAND_GROUP_CONNECTION,
6974                history: CLIENT_LIST_History.as_ptr() as *mut _,
6975                tips: CLIENT_LIST_tips.as_ptr() as *mut _,
6976                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
6977                arity: -(2 as libc::c_int),
6978                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
6979                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
6980                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
6981                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
6982                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
6983                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
6984                    as uint64_t,
6985                key_specs_static: [keySpec {
6986                    notes: 0 as *const libc::c_char,
6987                    flags: 0,
6988                    begin_search_type: KSPEC_BS_INVALID,
6989                    bs: C2RustUnnamed_3 {
6990                        index: C2RustUnnamed_5 { pos: 0 },
6991                    },
6992                    find_keys_type: KSPEC_FK_INVALID,
6993                    fk: C2RustUnnamed_0 {
6994                        range: C2RustUnnamed_2 {
6995                            lastkey: 0,
6996                            keystep: 0,
6997                            limit: 0,
6998                        },
6999                    },
7000                }; 4],
7001                getkeys_proc: None,
7002                subcommands: 0 as *const redisCommand as *mut redisCommand,
7003                args: CLIENT_LIST_Args.as_ptr() as *mut _,
7004                microseconds: 0,
7005                calls: 0,
7006                rejected_calls: 0,
7007                failed_calls: 0,
7008                id: 0,
7009                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7010                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7011                key_specs: 0 as *const keySpec as *mut keySpec,
7012                legacy_range_key_spec: keySpec {
7013                    notes: 0 as *const libc::c_char,
7014                    flags: 0,
7015                    begin_search_type: KSPEC_BS_INVALID,
7016                    bs: C2RustUnnamed_3 {
7017                        index: C2RustUnnamed_5 { pos: 0 },
7018                    },
7019                    find_keys_type: KSPEC_FK_INVALID,
7020                    fk: C2RustUnnamed_0 {
7021                        range: C2RustUnnamed_2 {
7022                            lastkey: 0,
7023                            keystep: 0,
7024                            limit: 0,
7025                        },
7026                    },
7027                },
7028                num_args: 0,
7029                num_history: 0,
7030                num_tips: 0,
7031                key_specs_num: 0,
7032                key_specs_max: 0,
7033                subcommands_dict: 0 as *const dict as *mut dict,
7034                parent: 0 as *const redisCommand as *mut redisCommand,
7035                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7036            };
7037            init
7038        },
7039        {
7040            let mut init = redisCommand {
7041                declared_name: b"no-evict\0" as *const u8 as *const libc::c_char,
7042                summary: b"Set client eviction mode for the current connection\0"
7043                    as *const u8 as *const libc::c_char,
7044                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
7045                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
7046                doc_flags: 0 as libc::c_int,
7047                replaced_by: 0 as *const libc::c_char,
7048                deprecated_since: 0 as *const libc::c_char,
7049                group: COMMAND_GROUP_CONNECTION,
7050                history: 0 as *const commandHistory as *mut commandHistory,
7051                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7052                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7053                arity: 3 as libc::c_int,
7054                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
7055                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
7056                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7057                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7058                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7059                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7060                    as uint64_t,
7061                key_specs_static: [keySpec {
7062                    notes: 0 as *const libc::c_char,
7063                    flags: 0,
7064                    begin_search_type: KSPEC_BS_INVALID,
7065                    bs: C2RustUnnamed_3 {
7066                        index: C2RustUnnamed_5 { pos: 0 },
7067                    },
7068                    find_keys_type: KSPEC_FK_INVALID,
7069                    fk: C2RustUnnamed_0 {
7070                        range: C2RustUnnamed_2 {
7071                            lastkey: 0,
7072                            keystep: 0,
7073                            limit: 0,
7074                        },
7075                    },
7076                }; 4],
7077                getkeys_proc: None,
7078                subcommands: 0 as *const redisCommand as *mut redisCommand,
7079                args: CLIENT_NO_EVICT_Args.as_ptr() as *mut _,
7080                microseconds: 0,
7081                calls: 0,
7082                rejected_calls: 0,
7083                failed_calls: 0,
7084                id: 0,
7085                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7086                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7087                key_specs: 0 as *const keySpec as *mut keySpec,
7088                legacy_range_key_spec: keySpec {
7089                    notes: 0 as *const libc::c_char,
7090                    flags: 0,
7091                    begin_search_type: KSPEC_BS_INVALID,
7092                    bs: C2RustUnnamed_3 {
7093                        index: C2RustUnnamed_5 { pos: 0 },
7094                    },
7095                    find_keys_type: KSPEC_FK_INVALID,
7096                    fk: C2RustUnnamed_0 {
7097                        range: C2RustUnnamed_2 {
7098                            lastkey: 0,
7099                            keystep: 0,
7100                            limit: 0,
7101                        },
7102                    },
7103                },
7104                num_args: 0,
7105                num_history: 0,
7106                num_tips: 0,
7107                key_specs_num: 0,
7108                key_specs_max: 0,
7109                subcommands_dict: 0 as *const dict as *mut dict,
7110                parent: 0 as *const redisCommand as *mut redisCommand,
7111                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7112            };
7113            init
7114        },
7115        {
7116            let mut init = redisCommand {
7117                declared_name: b"pause\0" as *const u8 as *const libc::c_char,
7118                summary: b"Stop processing commands from clients for some time\0"
7119                    as *const u8 as *const libc::c_char,
7120                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
7121                since: b"2.9.50\0" as *const u8 as *const libc::c_char,
7122                doc_flags: 0 as libc::c_int,
7123                replaced_by: 0 as *const libc::c_char,
7124                deprecated_since: 0 as *const libc::c_char,
7125                group: COMMAND_GROUP_CONNECTION,
7126                history: CLIENT_PAUSE_History.as_ptr() as *mut _,
7127                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7128                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7129                arity: -(3 as libc::c_int),
7130                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
7131                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
7132                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7133                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7134                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7135                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7136                    as uint64_t,
7137                key_specs_static: [keySpec {
7138                    notes: 0 as *const libc::c_char,
7139                    flags: 0,
7140                    begin_search_type: KSPEC_BS_INVALID,
7141                    bs: C2RustUnnamed_3 {
7142                        index: C2RustUnnamed_5 { pos: 0 },
7143                    },
7144                    find_keys_type: KSPEC_FK_INVALID,
7145                    fk: C2RustUnnamed_0 {
7146                        range: C2RustUnnamed_2 {
7147                            lastkey: 0,
7148                            keystep: 0,
7149                            limit: 0,
7150                        },
7151                    },
7152                }; 4],
7153                getkeys_proc: None,
7154                subcommands: 0 as *const redisCommand as *mut redisCommand,
7155                args: CLIENT_PAUSE_Args.as_ptr() as *mut _,
7156                microseconds: 0,
7157                calls: 0,
7158                rejected_calls: 0,
7159                failed_calls: 0,
7160                id: 0,
7161                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7162                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7163                key_specs: 0 as *const keySpec as *mut keySpec,
7164                legacy_range_key_spec: keySpec {
7165                    notes: 0 as *const libc::c_char,
7166                    flags: 0,
7167                    begin_search_type: KSPEC_BS_INVALID,
7168                    bs: C2RustUnnamed_3 {
7169                        index: C2RustUnnamed_5 { pos: 0 },
7170                    },
7171                    find_keys_type: KSPEC_FK_INVALID,
7172                    fk: C2RustUnnamed_0 {
7173                        range: C2RustUnnamed_2 {
7174                            lastkey: 0,
7175                            keystep: 0,
7176                            limit: 0,
7177                        },
7178                    },
7179                },
7180                num_args: 0,
7181                num_history: 0,
7182                num_tips: 0,
7183                key_specs_num: 0,
7184                key_specs_max: 0,
7185                subcommands_dict: 0 as *const dict as *mut dict,
7186                parent: 0 as *const redisCommand as *mut redisCommand,
7187                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7188            };
7189            init
7190        },
7191        {
7192            let mut init = redisCommand {
7193                declared_name: b"reply\0" as *const u8 as *const libc::c_char,
7194                summary: b"Instruct the server whether to reply to commands\0"
7195                    as *const u8 as *const libc::c_char,
7196                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
7197                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
7198                doc_flags: 0 as libc::c_int,
7199                replaced_by: 0 as *const libc::c_char,
7200                deprecated_since: 0 as *const libc::c_char,
7201                group: COMMAND_GROUP_CONNECTION,
7202                history: 0 as *const commandHistory as *mut commandHistory,
7203                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7204                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7205                arity: 3 as libc::c_int,
7206                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
7207                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7208                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7209                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7210                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7211                    as uint64_t,
7212                key_specs_static: [keySpec {
7213                    notes: 0 as *const libc::c_char,
7214                    flags: 0,
7215                    begin_search_type: KSPEC_BS_INVALID,
7216                    bs: C2RustUnnamed_3 {
7217                        index: C2RustUnnamed_5 { pos: 0 },
7218                    },
7219                    find_keys_type: KSPEC_FK_INVALID,
7220                    fk: C2RustUnnamed_0 {
7221                        range: C2RustUnnamed_2 {
7222                            lastkey: 0,
7223                            keystep: 0,
7224                            limit: 0,
7225                        },
7226                    },
7227                }; 4],
7228                getkeys_proc: None,
7229                subcommands: 0 as *const redisCommand as *mut redisCommand,
7230                args: CLIENT_REPLY_Args.as_ptr() as *mut _,
7231                microseconds: 0,
7232                calls: 0,
7233                rejected_calls: 0,
7234                failed_calls: 0,
7235                id: 0,
7236                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7237                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7238                key_specs: 0 as *const keySpec as *mut keySpec,
7239                legacy_range_key_spec: keySpec {
7240                    notes: 0 as *const libc::c_char,
7241                    flags: 0,
7242                    begin_search_type: KSPEC_BS_INVALID,
7243                    bs: C2RustUnnamed_3 {
7244                        index: C2RustUnnamed_5 { pos: 0 },
7245                    },
7246                    find_keys_type: KSPEC_FK_INVALID,
7247                    fk: C2RustUnnamed_0 {
7248                        range: C2RustUnnamed_2 {
7249                            lastkey: 0,
7250                            keystep: 0,
7251                            limit: 0,
7252                        },
7253                    },
7254                },
7255                num_args: 0,
7256                num_history: 0,
7257                num_tips: 0,
7258                key_specs_num: 0,
7259                key_specs_max: 0,
7260                subcommands_dict: 0 as *const dict as *mut dict,
7261                parent: 0 as *const redisCommand as *mut redisCommand,
7262                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7263            };
7264            init
7265        },
7266        {
7267            let mut init = redisCommand {
7268                declared_name: b"setname\0" as *const u8 as *const libc::c_char,
7269                summary: b"Set the current connection name\0" as *const u8
7270                    as *const libc::c_char,
7271                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
7272                since: b"2.6.9\0" as *const u8 as *const libc::c_char,
7273                doc_flags: 0 as libc::c_int,
7274                replaced_by: 0 as *const libc::c_char,
7275                deprecated_since: 0 as *const libc::c_char,
7276                group: COMMAND_GROUP_CONNECTION,
7277                history: 0 as *const commandHistory as *mut commandHistory,
7278                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7279                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7280                arity: 3 as libc::c_int,
7281                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
7282                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7283                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7284                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7285                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7286                    as uint64_t,
7287                key_specs_static: [keySpec {
7288                    notes: 0 as *const libc::c_char,
7289                    flags: 0,
7290                    begin_search_type: KSPEC_BS_INVALID,
7291                    bs: C2RustUnnamed_3 {
7292                        index: C2RustUnnamed_5 { pos: 0 },
7293                    },
7294                    find_keys_type: KSPEC_FK_INVALID,
7295                    fk: C2RustUnnamed_0 {
7296                        range: C2RustUnnamed_2 {
7297                            lastkey: 0,
7298                            keystep: 0,
7299                            limit: 0,
7300                        },
7301                    },
7302                }; 4],
7303                getkeys_proc: None,
7304                subcommands: 0 as *const redisCommand as *mut redisCommand,
7305                args: CLIENT_SETNAME_Args.as_ptr() as *mut _,
7306                microseconds: 0,
7307                calls: 0,
7308                rejected_calls: 0,
7309                failed_calls: 0,
7310                id: 0,
7311                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7312                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7313                key_specs: 0 as *const keySpec as *mut keySpec,
7314                legacy_range_key_spec: keySpec {
7315                    notes: 0 as *const libc::c_char,
7316                    flags: 0,
7317                    begin_search_type: KSPEC_BS_INVALID,
7318                    bs: C2RustUnnamed_3 {
7319                        index: C2RustUnnamed_5 { pos: 0 },
7320                    },
7321                    find_keys_type: KSPEC_FK_INVALID,
7322                    fk: C2RustUnnamed_0 {
7323                        range: C2RustUnnamed_2 {
7324                            lastkey: 0,
7325                            keystep: 0,
7326                            limit: 0,
7327                        },
7328                    },
7329                },
7330                num_args: 0,
7331                num_history: 0,
7332                num_tips: 0,
7333                key_specs_num: 0,
7334                key_specs_max: 0,
7335                subcommands_dict: 0 as *const dict as *mut dict,
7336                parent: 0 as *const redisCommand as *mut redisCommand,
7337                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7338            };
7339            init
7340        },
7341        {
7342            let mut init = redisCommand {
7343                declared_name: b"tracking\0" as *const u8 as *const libc::c_char,
7344                summary: b"Enable or disable server assisted client side caching support\0"
7345                    as *const u8 as *const libc::c_char,
7346                complexity: b"O(1). Some options may introduce additional complexity.\0"
7347                    as *const u8 as *const libc::c_char,
7348                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
7349                doc_flags: 0 as libc::c_int,
7350                replaced_by: 0 as *const libc::c_char,
7351                deprecated_since: 0 as *const libc::c_char,
7352                group: COMMAND_GROUP_CONNECTION,
7353                history: 0 as *const commandHistory as *mut commandHistory,
7354                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7355                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7356                arity: -(3 as libc::c_int),
7357                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
7358                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7359                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7360                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7361                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7362                    as uint64_t,
7363                key_specs_static: [keySpec {
7364                    notes: 0 as *const libc::c_char,
7365                    flags: 0,
7366                    begin_search_type: KSPEC_BS_INVALID,
7367                    bs: C2RustUnnamed_3 {
7368                        index: C2RustUnnamed_5 { pos: 0 },
7369                    },
7370                    find_keys_type: KSPEC_FK_INVALID,
7371                    fk: C2RustUnnamed_0 {
7372                        range: C2RustUnnamed_2 {
7373                            lastkey: 0,
7374                            keystep: 0,
7375                            limit: 0,
7376                        },
7377                    },
7378                }; 4],
7379                getkeys_proc: None,
7380                subcommands: 0 as *const redisCommand as *mut redisCommand,
7381                args: CLIENT_TRACKING_Args.as_ptr() as *mut _,
7382                microseconds: 0,
7383                calls: 0,
7384                rejected_calls: 0,
7385                failed_calls: 0,
7386                id: 0,
7387                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7388                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7389                key_specs: 0 as *const keySpec as *mut keySpec,
7390                legacy_range_key_spec: keySpec {
7391                    notes: 0 as *const libc::c_char,
7392                    flags: 0,
7393                    begin_search_type: KSPEC_BS_INVALID,
7394                    bs: C2RustUnnamed_3 {
7395                        index: C2RustUnnamed_5 { pos: 0 },
7396                    },
7397                    find_keys_type: KSPEC_FK_INVALID,
7398                    fk: C2RustUnnamed_0 {
7399                        range: C2RustUnnamed_2 {
7400                            lastkey: 0,
7401                            keystep: 0,
7402                            limit: 0,
7403                        },
7404                    },
7405                },
7406                num_args: 0,
7407                num_history: 0,
7408                num_tips: 0,
7409                key_specs_num: 0,
7410                key_specs_max: 0,
7411                subcommands_dict: 0 as *const dict as *mut dict,
7412                parent: 0 as *const redisCommand as *mut redisCommand,
7413                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7414            };
7415            init
7416        },
7417        {
7418            let mut init = redisCommand {
7419                declared_name: b"trackinginfo\0" as *const u8 as *const libc::c_char,
7420                summary: b"Return information about server assisted client side caching for the current connection\0"
7421                    as *const u8 as *const libc::c_char,
7422                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
7423                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
7424                doc_flags: 0 as libc::c_int,
7425                replaced_by: 0 as *const libc::c_char,
7426                deprecated_since: 0 as *const libc::c_char,
7427                group: COMMAND_GROUP_CONNECTION,
7428                history: 0 as *const commandHistory as *mut commandHistory,
7429                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7430                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7431                arity: 2 as libc::c_int,
7432                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
7433                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7434                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7435                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7436                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7437                    as uint64_t,
7438                key_specs_static: [keySpec {
7439                    notes: 0 as *const libc::c_char,
7440                    flags: 0,
7441                    begin_search_type: KSPEC_BS_INVALID,
7442                    bs: C2RustUnnamed_3 {
7443                        index: C2RustUnnamed_5 { pos: 0 },
7444                    },
7445                    find_keys_type: KSPEC_FK_INVALID,
7446                    fk: C2RustUnnamed_0 {
7447                        range: C2RustUnnamed_2 {
7448                            lastkey: 0,
7449                            keystep: 0,
7450                            limit: 0,
7451                        },
7452                    },
7453                }; 4],
7454                getkeys_proc: None,
7455                subcommands: 0 as *const redisCommand as *mut redisCommand,
7456                args: 0 as *const redisCommandArg as *mut redisCommandArg,
7457                microseconds: 0,
7458                calls: 0,
7459                rejected_calls: 0,
7460                failed_calls: 0,
7461                id: 0,
7462                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7463                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7464                key_specs: 0 as *const keySpec as *mut keySpec,
7465                legacy_range_key_spec: keySpec {
7466                    notes: 0 as *const libc::c_char,
7467                    flags: 0,
7468                    begin_search_type: KSPEC_BS_INVALID,
7469                    bs: C2RustUnnamed_3 {
7470                        index: C2RustUnnamed_5 { pos: 0 },
7471                    },
7472                    find_keys_type: KSPEC_FK_INVALID,
7473                    fk: C2RustUnnamed_0 {
7474                        range: C2RustUnnamed_2 {
7475                            lastkey: 0,
7476                            keystep: 0,
7477                            limit: 0,
7478                        },
7479                    },
7480                },
7481                num_args: 0,
7482                num_history: 0,
7483                num_tips: 0,
7484                key_specs_num: 0,
7485                key_specs_max: 0,
7486                subcommands_dict: 0 as *const dict as *mut dict,
7487                parent: 0 as *const redisCommand as *mut redisCommand,
7488                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7489            };
7490            init
7491        },
7492        {
7493            let mut init = redisCommand {
7494                declared_name: b"unblock\0" as *const u8 as *const libc::c_char,
7495                summary: b"Unblock a client blocked in a blocking command from a different connection\0"
7496                    as *const u8 as *const libc::c_char,
7497                complexity: b"O(log N) where N is the number of client connections\0"
7498                    as *const u8 as *const libc::c_char,
7499                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
7500                doc_flags: 0 as libc::c_int,
7501                replaced_by: 0 as *const libc::c_char,
7502                deprecated_since: 0 as *const libc::c_char,
7503                group: COMMAND_GROUP_CONNECTION,
7504                history: 0 as *const commandHistory as *mut commandHistory,
7505                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7506                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7507                arity: -(3 as libc::c_int),
7508                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
7509                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
7510                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7511                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7512                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7513                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7514                    as uint64_t,
7515                key_specs_static: [keySpec {
7516                    notes: 0 as *const libc::c_char,
7517                    flags: 0,
7518                    begin_search_type: KSPEC_BS_INVALID,
7519                    bs: C2RustUnnamed_3 {
7520                        index: C2RustUnnamed_5 { pos: 0 },
7521                    },
7522                    find_keys_type: KSPEC_FK_INVALID,
7523                    fk: C2RustUnnamed_0 {
7524                        range: C2RustUnnamed_2 {
7525                            lastkey: 0,
7526                            keystep: 0,
7527                            limit: 0,
7528                        },
7529                    },
7530                }; 4],
7531                getkeys_proc: None,
7532                subcommands: 0 as *const redisCommand as *mut redisCommand,
7533                args: CLIENT_UNBLOCK_Args.as_ptr() as *mut _,
7534                microseconds: 0,
7535                calls: 0,
7536                rejected_calls: 0,
7537                failed_calls: 0,
7538                id: 0,
7539                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7540                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7541                key_specs: 0 as *const keySpec as *mut keySpec,
7542                legacy_range_key_spec: keySpec {
7543                    notes: 0 as *const libc::c_char,
7544                    flags: 0,
7545                    begin_search_type: KSPEC_BS_INVALID,
7546                    bs: C2RustUnnamed_3 {
7547                        index: C2RustUnnamed_5 { pos: 0 },
7548                    },
7549                    find_keys_type: KSPEC_FK_INVALID,
7550                    fk: C2RustUnnamed_0 {
7551                        range: C2RustUnnamed_2 {
7552                            lastkey: 0,
7553                            keystep: 0,
7554                            limit: 0,
7555                        },
7556                    },
7557                },
7558                num_args: 0,
7559                num_history: 0,
7560                num_tips: 0,
7561                key_specs_num: 0,
7562                key_specs_max: 0,
7563                subcommands_dict: 0 as *const dict as *mut dict,
7564                parent: 0 as *const redisCommand as *mut redisCommand,
7565                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7566            };
7567            init
7568        },
7569        {
7570            let mut init = redisCommand {
7571                declared_name: b"unpause\0" as *const u8 as *const libc::c_char,
7572                summary: b"Resume processing of clients that were paused\0" as *const u8
7573                    as *const libc::c_char,
7574                complexity: b"O(N) Where N is the number of paused clients\0"
7575                    as *const u8 as *const libc::c_char,
7576                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
7577                doc_flags: 0 as libc::c_int,
7578                replaced_by: 0 as *const libc::c_char,
7579                deprecated_since: 0 as *const libc::c_char,
7580                group: COMMAND_GROUP_CONNECTION,
7581                history: 0 as *const commandHistory as *mut commandHistory,
7582                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7583                proc_0: Some(clientCommand as unsafe extern "C" fn(*mut client) -> ()),
7584                arity: 2 as libc::c_int,
7585                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
7586                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
7587                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
7588                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
7589                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
7590                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
7591                    as uint64_t,
7592                key_specs_static: [keySpec {
7593                    notes: 0 as *const libc::c_char,
7594                    flags: 0,
7595                    begin_search_type: KSPEC_BS_INVALID,
7596                    bs: C2RustUnnamed_3 {
7597                        index: C2RustUnnamed_5 { pos: 0 },
7598                    },
7599                    find_keys_type: KSPEC_FK_INVALID,
7600                    fk: C2RustUnnamed_0 {
7601                        range: C2RustUnnamed_2 {
7602                            lastkey: 0,
7603                            keystep: 0,
7604                            limit: 0,
7605                        },
7606                    },
7607                }; 4],
7608                getkeys_proc: None,
7609                subcommands: 0 as *const redisCommand as *mut redisCommand,
7610                args: 0 as *const redisCommandArg as *mut redisCommandArg,
7611                microseconds: 0,
7612                calls: 0,
7613                rejected_calls: 0,
7614                failed_calls: 0,
7615                id: 0,
7616                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7617                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7618                key_specs: 0 as *const keySpec as *mut keySpec,
7619                legacy_range_key_spec: keySpec {
7620                    notes: 0 as *const libc::c_char,
7621                    flags: 0,
7622                    begin_search_type: KSPEC_BS_INVALID,
7623                    bs: C2RustUnnamed_3 {
7624                        index: C2RustUnnamed_5 { pos: 0 },
7625                    },
7626                    find_keys_type: KSPEC_FK_INVALID,
7627                    fk: C2RustUnnamed_0 {
7628                        range: C2RustUnnamed_2 {
7629                            lastkey: 0,
7630                            keystep: 0,
7631                            limit: 0,
7632                        },
7633                    },
7634                },
7635                num_args: 0,
7636                num_history: 0,
7637                num_tips: 0,
7638                key_specs_num: 0,
7639                key_specs_max: 0,
7640                subcommands_dict: 0 as *const dict as *mut dict,
7641                parent: 0 as *const redisCommand as *mut redisCommand,
7642                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7643            };
7644            init
7645        },
7646        {
7647            let mut init = redisCommand {
7648                declared_name: 0 as *const libc::c_char,
7649                summary: 0 as *const libc::c_char,
7650                complexity: 0 as *const libc::c_char,
7651                since: 0 as *const libc::c_char,
7652                doc_flags: 0,
7653                replaced_by: 0 as *const libc::c_char,
7654                deprecated_since: 0 as *const libc::c_char,
7655                group: COMMAND_GROUP_GENERIC,
7656                history: 0 as *const commandHistory as *mut commandHistory,
7657                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
7658                proc_0: None,
7659                arity: 0,
7660                flags: 0,
7661                acl_categories: 0,
7662                key_specs_static: [keySpec {
7663                    notes: 0 as *const libc::c_char,
7664                    flags: 0,
7665                    begin_search_type: KSPEC_BS_INVALID,
7666                    bs: C2RustUnnamed_3 {
7667                        index: C2RustUnnamed_5 { pos: 0 },
7668                    },
7669                    find_keys_type: KSPEC_FK_INVALID,
7670                    fk: C2RustUnnamed_0 {
7671                        range: C2RustUnnamed_2 {
7672                            lastkey: 0,
7673                            keystep: 0,
7674                            limit: 0,
7675                        },
7676                    },
7677                }; 4],
7678                getkeys_proc: None,
7679                subcommands: 0 as *const redisCommand as *mut redisCommand,
7680                args: 0 as *const redisCommandArg as *mut redisCommandArg,
7681                microseconds: 0,
7682                calls: 0,
7683                rejected_calls: 0,
7684                failed_calls: 0,
7685                id: 0,
7686                fullname: 0 as *const libc::c_char as *mut libc::c_char,
7687                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
7688                key_specs: 0 as *const keySpec as *mut keySpec,
7689                legacy_range_key_spec: keySpec {
7690                    notes: 0 as *const libc::c_char,
7691                    flags: 0,
7692                    begin_search_type: KSPEC_BS_INVALID,
7693                    bs: C2RustUnnamed_3 {
7694                        index: C2RustUnnamed_5 { pos: 0 },
7695                    },
7696                    find_keys_type: KSPEC_FK_INVALID,
7697                    fk: C2RustUnnamed_0 {
7698                        range: C2RustUnnamed_2 {
7699                            lastkey: 0,
7700                            keystep: 0,
7701                            limit: 0,
7702                        },
7703                    },
7704                },
7705                num_args: 0,
7706                num_history: 0,
7707                num_tips: 0,
7708                key_specs_num: 0,
7709                key_specs_max: 0,
7710                subcommands_dict: 0 as *const dict as *mut dict,
7711                parent: 0 as *const redisCommand as *mut redisCommand,
7712                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
7713            };
7714            init
7715        },
7716    ]
7717};
7718#[no_mangle]
7719pub static mut ECHO_Args: [redisCommandArg; 2] = [
7720    {
7721        let mut init = redisCommandArg {
7722            name: b"message\0" as *const u8 as *const libc::c_char,
7723            type_0: ARG_TYPE_STRING,
7724            key_spec_index: -(1 as libc::c_int),
7725            token: 0 as *const libc::c_char,
7726            summary: 0 as *const libc::c_char,
7727            since: 0 as *const libc::c_char,
7728            flags: 0 as libc::c_int,
7729            deprecated_since: 0 as *const libc::c_char,
7730            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7731            num_args: 0,
7732        };
7733        init
7734    },
7735    {
7736        let mut init = redisCommandArg {
7737            name: 0 as *const libc::c_char,
7738            type_0: ARG_TYPE_STRING,
7739            key_spec_index: 0,
7740            token: 0 as *const libc::c_char,
7741            summary: 0 as *const libc::c_char,
7742            since: 0 as *const libc::c_char,
7743            flags: 0,
7744            deprecated_since: 0 as *const libc::c_char,
7745            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7746            num_args: 0,
7747        };
7748        init
7749    },
7750];
7751#[no_mangle]
7752pub static mut HELLO_History: [commandHistory; 2] = [
7753    {
7754        let mut init = commandHistory {
7755            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
7756            changes: b"`protover` made optional; when called without arguments the command reports the current connection's context.\0"
7757                as *const u8 as *const libc::c_char,
7758        };
7759        init
7760    },
7761    {
7762        let mut init = commandHistory {
7763            since: 0 as *const libc::c_char,
7764            changes: 0 as *const libc::c_char,
7765        };
7766        init
7767    },
7768];
7769#[no_mangle]
7770pub static mut HELLO_arguments_username_password_Subargs: [redisCommandArg; 3] = [
7771    {
7772        let mut init = redisCommandArg {
7773            name: b"username\0" as *const u8 as *const libc::c_char,
7774            type_0: ARG_TYPE_STRING,
7775            key_spec_index: -(1 as libc::c_int),
7776            token: 0 as *const libc::c_char,
7777            summary: 0 as *const libc::c_char,
7778            since: 0 as *const libc::c_char,
7779            flags: 0 as libc::c_int,
7780            deprecated_since: 0 as *const libc::c_char,
7781            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7782            num_args: 0,
7783        };
7784        init
7785    },
7786    {
7787        let mut init = redisCommandArg {
7788            name: b"password\0" as *const u8 as *const libc::c_char,
7789            type_0: ARG_TYPE_STRING,
7790            key_spec_index: -(1 as libc::c_int),
7791            token: 0 as *const libc::c_char,
7792            summary: 0 as *const libc::c_char,
7793            since: 0 as *const libc::c_char,
7794            flags: 0 as libc::c_int,
7795            deprecated_since: 0 as *const libc::c_char,
7796            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7797            num_args: 0,
7798        };
7799        init
7800    },
7801    {
7802        let mut init = redisCommandArg {
7803            name: 0 as *const libc::c_char,
7804            type_0: ARG_TYPE_STRING,
7805            key_spec_index: 0,
7806            token: 0 as *const libc::c_char,
7807            summary: 0 as *const libc::c_char,
7808            since: 0 as *const libc::c_char,
7809            flags: 0,
7810            deprecated_since: 0 as *const libc::c_char,
7811            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7812            num_args: 0,
7813        };
7814        init
7815    },
7816];
7817#[no_mangle]
7818pub static mut HELLO_arguments_Subargs: [redisCommandArg; 4] = unsafe {
7819    [
7820        {
7821            let mut init = redisCommandArg {
7822                name: b"protover\0" as *const u8 as *const libc::c_char,
7823                type_0: ARG_TYPE_INTEGER,
7824                key_spec_index: -(1 as libc::c_int),
7825                token: 0 as *const libc::c_char,
7826                summary: 0 as *const libc::c_char,
7827                since: 0 as *const libc::c_char,
7828                flags: 0 as libc::c_int,
7829                deprecated_since: 0 as *const libc::c_char,
7830                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7831                num_args: 0,
7832            };
7833            init
7834        },
7835        {
7836            let mut init = redisCommandArg {
7837                name: b"username_password\0" as *const u8 as *const libc::c_char,
7838                type_0: ARG_TYPE_BLOCK,
7839                key_spec_index: -(1 as libc::c_int),
7840                token: b"AUTH\0" as *const u8 as *const libc::c_char,
7841                summary: 0 as *const libc::c_char,
7842                since: 0 as *const libc::c_char,
7843                flags: (1 as libc::c_int) << 0 as libc::c_int,
7844                deprecated_since: 0 as *const libc::c_char,
7845                subargs: HELLO_arguments_username_password_Subargs.as_ptr() as *mut _,
7846                num_args: 0,
7847            };
7848            init
7849        },
7850        {
7851            let mut init = redisCommandArg {
7852                name: b"clientname\0" as *const u8 as *const libc::c_char,
7853                type_0: ARG_TYPE_STRING,
7854                key_spec_index: -(1 as libc::c_int),
7855                token: b"SETNAME\0" as *const u8 as *const libc::c_char,
7856                summary: 0 as *const libc::c_char,
7857                since: 0 as *const libc::c_char,
7858                flags: (1 as libc::c_int) << 0 as libc::c_int,
7859                deprecated_since: 0 as *const libc::c_char,
7860                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7861                num_args: 0,
7862            };
7863            init
7864        },
7865        {
7866            let mut init = redisCommandArg {
7867                name: 0 as *const libc::c_char,
7868                type_0: ARG_TYPE_STRING,
7869                key_spec_index: 0,
7870                token: 0 as *const libc::c_char,
7871                summary: 0 as *const libc::c_char,
7872                since: 0 as *const libc::c_char,
7873                flags: 0,
7874                deprecated_since: 0 as *const libc::c_char,
7875                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7876                num_args: 0,
7877            };
7878            init
7879        },
7880    ]
7881};
7882#[no_mangle]
7883pub static mut HELLO_Args: [redisCommandArg; 2] = unsafe {
7884    [
7885        {
7886            let mut init = redisCommandArg {
7887                name: b"arguments\0" as *const u8 as *const libc::c_char,
7888                type_0: ARG_TYPE_BLOCK,
7889                key_spec_index: -(1 as libc::c_int),
7890                token: 0 as *const libc::c_char,
7891                summary: 0 as *const libc::c_char,
7892                since: 0 as *const libc::c_char,
7893                flags: (1 as libc::c_int) << 0 as libc::c_int,
7894                deprecated_since: 0 as *const libc::c_char,
7895                subargs: HELLO_arguments_Subargs.as_ptr() as *mut _,
7896                num_args: 0,
7897            };
7898            init
7899        },
7900        {
7901            let mut init = redisCommandArg {
7902                name: 0 as *const libc::c_char,
7903                type_0: ARG_TYPE_STRING,
7904                key_spec_index: 0,
7905                token: 0 as *const libc::c_char,
7906                summary: 0 as *const libc::c_char,
7907                since: 0 as *const libc::c_char,
7908                flags: 0,
7909                deprecated_since: 0 as *const libc::c_char,
7910                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7911                num_args: 0,
7912            };
7913            init
7914        },
7915    ]
7916};
7917#[no_mangle]
7918pub static mut PING_tips: [*const libc::c_char; 3] = [
7919    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
7920    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
7921    0 as *const libc::c_char,
7922];
7923#[no_mangle]
7924pub static mut PING_Args: [redisCommandArg; 2] = [
7925    {
7926        let mut init = redisCommandArg {
7927            name: b"message\0" as *const u8 as *const libc::c_char,
7928            type_0: ARG_TYPE_STRING,
7929            key_spec_index: -(1 as libc::c_int),
7930            token: 0 as *const libc::c_char,
7931            summary: 0 as *const libc::c_char,
7932            since: 0 as *const libc::c_char,
7933            flags: (1 as libc::c_int) << 0 as libc::c_int,
7934            deprecated_since: 0 as *const libc::c_char,
7935            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7936            num_args: 0,
7937        };
7938        init
7939    },
7940    {
7941        let mut init = redisCommandArg {
7942            name: 0 as *const libc::c_char,
7943            type_0: ARG_TYPE_STRING,
7944            key_spec_index: 0,
7945            token: 0 as *const libc::c_char,
7946            summary: 0 as *const libc::c_char,
7947            since: 0 as *const libc::c_char,
7948            flags: 0,
7949            deprecated_since: 0 as *const libc::c_char,
7950            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7951            num_args: 0,
7952        };
7953        init
7954    },
7955];
7956#[no_mangle]
7957pub static mut SELECT_Args: [redisCommandArg; 2] = [
7958    {
7959        let mut init = redisCommandArg {
7960            name: b"index\0" as *const u8 as *const libc::c_char,
7961            type_0: ARG_TYPE_INTEGER,
7962            key_spec_index: -(1 as libc::c_int),
7963            token: 0 as *const libc::c_char,
7964            summary: 0 as *const libc::c_char,
7965            since: 0 as *const libc::c_char,
7966            flags: 0 as libc::c_int,
7967            deprecated_since: 0 as *const libc::c_char,
7968            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7969            num_args: 0,
7970        };
7971        init
7972    },
7973    {
7974        let mut init = redisCommandArg {
7975            name: 0 as *const libc::c_char,
7976            type_0: ARG_TYPE_STRING,
7977            key_spec_index: 0,
7978            token: 0 as *const libc::c_char,
7979            summary: 0 as *const libc::c_char,
7980            since: 0 as *const libc::c_char,
7981            flags: 0,
7982            deprecated_since: 0 as *const libc::c_char,
7983            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
7984            num_args: 0,
7985        };
7986        init
7987    },
7988];
7989#[no_mangle]
7990pub static mut COPY_Args: [redisCommandArg; 5] = [
7991    {
7992        let mut init = redisCommandArg {
7993            name: b"source\0" as *const u8 as *const libc::c_char,
7994            type_0: ARG_TYPE_KEY,
7995            key_spec_index: 0 as libc::c_int,
7996            token: 0 as *const libc::c_char,
7997            summary: 0 as *const libc::c_char,
7998            since: 0 as *const libc::c_char,
7999            flags: 0 as libc::c_int,
8000            deprecated_since: 0 as *const libc::c_char,
8001            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8002            num_args: 0,
8003        };
8004        init
8005    },
8006    {
8007        let mut init = redisCommandArg {
8008            name: b"destination\0" as *const u8 as *const libc::c_char,
8009            type_0: ARG_TYPE_KEY,
8010            key_spec_index: 1 as libc::c_int,
8011            token: 0 as *const libc::c_char,
8012            summary: 0 as *const libc::c_char,
8013            since: 0 as *const libc::c_char,
8014            flags: 0 as libc::c_int,
8015            deprecated_since: 0 as *const libc::c_char,
8016            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8017            num_args: 0,
8018        };
8019        init
8020    },
8021    {
8022        let mut init = redisCommandArg {
8023            name: b"destination-db\0" as *const u8 as *const libc::c_char,
8024            type_0: ARG_TYPE_INTEGER,
8025            key_spec_index: -(1 as libc::c_int),
8026            token: b"DB\0" as *const u8 as *const libc::c_char,
8027            summary: 0 as *const libc::c_char,
8028            since: 0 as *const libc::c_char,
8029            flags: (1 as libc::c_int) << 0 as libc::c_int,
8030            deprecated_since: 0 as *const libc::c_char,
8031            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8032            num_args: 0,
8033        };
8034        init
8035    },
8036    {
8037        let mut init = redisCommandArg {
8038            name: b"replace\0" as *const u8 as *const libc::c_char,
8039            type_0: ARG_TYPE_PURE_TOKEN,
8040            key_spec_index: -(1 as libc::c_int),
8041            token: b"REPLACE\0" as *const u8 as *const libc::c_char,
8042            summary: 0 as *const libc::c_char,
8043            since: 0 as *const libc::c_char,
8044            flags: (1 as libc::c_int) << 0 as libc::c_int,
8045            deprecated_since: 0 as *const libc::c_char,
8046            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8047            num_args: 0,
8048        };
8049        init
8050    },
8051    {
8052        let mut init = redisCommandArg {
8053            name: 0 as *const libc::c_char,
8054            type_0: ARG_TYPE_STRING,
8055            key_spec_index: 0,
8056            token: 0 as *const libc::c_char,
8057            summary: 0 as *const libc::c_char,
8058            since: 0 as *const libc::c_char,
8059            flags: 0,
8060            deprecated_since: 0 as *const libc::c_char,
8061            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8062            num_args: 0,
8063        };
8064        init
8065    },
8066];
8067#[no_mangle]
8068pub static mut DEL_tips: [*const libc::c_char; 3] = [
8069    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
8070    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
8071    0 as *const libc::c_char,
8072];
8073#[no_mangle]
8074pub static mut DEL_Args: [redisCommandArg; 2] = [
8075    {
8076        let mut init = redisCommandArg {
8077            name: b"key\0" as *const u8 as *const libc::c_char,
8078            type_0: ARG_TYPE_KEY,
8079            key_spec_index: 0 as libc::c_int,
8080            token: 0 as *const libc::c_char,
8081            summary: 0 as *const libc::c_char,
8082            since: 0 as *const libc::c_char,
8083            flags: (1 as libc::c_int) << 1 as libc::c_int,
8084            deprecated_since: 0 as *const libc::c_char,
8085            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8086            num_args: 0,
8087        };
8088        init
8089    },
8090    {
8091        let mut init = redisCommandArg {
8092            name: 0 as *const libc::c_char,
8093            type_0: ARG_TYPE_STRING,
8094            key_spec_index: 0,
8095            token: 0 as *const libc::c_char,
8096            summary: 0 as *const libc::c_char,
8097            since: 0 as *const libc::c_char,
8098            flags: 0,
8099            deprecated_since: 0 as *const libc::c_char,
8100            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8101            num_args: 0,
8102        };
8103        init
8104    },
8105];
8106#[no_mangle]
8107pub static mut DUMP_tips: [*const libc::c_char; 2] = [
8108    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
8109    0 as *const libc::c_char,
8110];
8111#[no_mangle]
8112pub static mut DUMP_Args: [redisCommandArg; 2] = [
8113    {
8114        let mut init = redisCommandArg {
8115            name: b"key\0" as *const u8 as *const libc::c_char,
8116            type_0: ARG_TYPE_KEY,
8117            key_spec_index: 0 as libc::c_int,
8118            token: 0 as *const libc::c_char,
8119            summary: 0 as *const libc::c_char,
8120            since: 0 as *const libc::c_char,
8121            flags: 0 as libc::c_int,
8122            deprecated_since: 0 as *const libc::c_char,
8123            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8124            num_args: 0,
8125        };
8126        init
8127    },
8128    {
8129        let mut init = redisCommandArg {
8130            name: 0 as *const libc::c_char,
8131            type_0: ARG_TYPE_STRING,
8132            key_spec_index: 0,
8133            token: 0 as *const libc::c_char,
8134            summary: 0 as *const libc::c_char,
8135            since: 0 as *const libc::c_char,
8136            flags: 0,
8137            deprecated_since: 0 as *const libc::c_char,
8138            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8139            num_args: 0,
8140        };
8141        init
8142    },
8143];
8144#[no_mangle]
8145pub static mut EXISTS_History: [commandHistory; 2] = [
8146    {
8147        let mut init = commandHistory {
8148            since: b"3.0.3\0" as *const u8 as *const libc::c_char,
8149            changes: b"Accepts multiple `key` arguments.\0" as *const u8
8150                as *const libc::c_char,
8151        };
8152        init
8153    },
8154    {
8155        let mut init = commandHistory {
8156            since: 0 as *const libc::c_char,
8157            changes: 0 as *const libc::c_char,
8158        };
8159        init
8160    },
8161];
8162#[no_mangle]
8163pub static mut EXISTS_tips: [*const libc::c_char; 3] = [
8164    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
8165    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
8166    0 as *const libc::c_char,
8167];
8168#[no_mangle]
8169pub static mut EXISTS_Args: [redisCommandArg; 2] = [
8170    {
8171        let mut init = redisCommandArg {
8172            name: b"key\0" as *const u8 as *const libc::c_char,
8173            type_0: ARG_TYPE_KEY,
8174            key_spec_index: 0 as libc::c_int,
8175            token: 0 as *const libc::c_char,
8176            summary: 0 as *const libc::c_char,
8177            since: 0 as *const libc::c_char,
8178            flags: (1 as libc::c_int) << 1 as libc::c_int,
8179            deprecated_since: 0 as *const libc::c_char,
8180            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8181            num_args: 0,
8182        };
8183        init
8184    },
8185    {
8186        let mut init = redisCommandArg {
8187            name: 0 as *const libc::c_char,
8188            type_0: ARG_TYPE_STRING,
8189            key_spec_index: 0,
8190            token: 0 as *const libc::c_char,
8191            summary: 0 as *const libc::c_char,
8192            since: 0 as *const libc::c_char,
8193            flags: 0,
8194            deprecated_since: 0 as *const libc::c_char,
8195            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8196            num_args: 0,
8197        };
8198        init
8199    },
8200];
8201#[no_mangle]
8202pub static mut EXPIRE_History: [commandHistory; 2] = [
8203    {
8204        let mut init = commandHistory {
8205            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
8206            changes: b"Added options: `NX`, `XX`, `GT` and `LT`.\0" as *const u8
8207                as *const libc::c_char,
8208        };
8209        init
8210    },
8211    {
8212        let mut init = commandHistory {
8213            since: 0 as *const libc::c_char,
8214            changes: 0 as *const libc::c_char,
8215        };
8216        init
8217    },
8218];
8219#[no_mangle]
8220pub static mut EXPIRE_condition_Subargs: [redisCommandArg; 5] = [
8221    {
8222        let mut init = redisCommandArg {
8223            name: b"nx\0" as *const u8 as *const libc::c_char,
8224            type_0: ARG_TYPE_PURE_TOKEN,
8225            key_spec_index: -(1 as libc::c_int),
8226            token: b"NX\0" as *const u8 as *const libc::c_char,
8227            summary: 0 as *const libc::c_char,
8228            since: 0 as *const libc::c_char,
8229            flags: 0 as libc::c_int,
8230            deprecated_since: 0 as *const libc::c_char,
8231            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8232            num_args: 0,
8233        };
8234        init
8235    },
8236    {
8237        let mut init = redisCommandArg {
8238            name: b"xx\0" as *const u8 as *const libc::c_char,
8239            type_0: ARG_TYPE_PURE_TOKEN,
8240            key_spec_index: -(1 as libc::c_int),
8241            token: b"XX\0" as *const u8 as *const libc::c_char,
8242            summary: 0 as *const libc::c_char,
8243            since: 0 as *const libc::c_char,
8244            flags: 0 as libc::c_int,
8245            deprecated_since: 0 as *const libc::c_char,
8246            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8247            num_args: 0,
8248        };
8249        init
8250    },
8251    {
8252        let mut init = redisCommandArg {
8253            name: b"gt\0" as *const u8 as *const libc::c_char,
8254            type_0: ARG_TYPE_PURE_TOKEN,
8255            key_spec_index: -(1 as libc::c_int),
8256            token: b"GT\0" as *const u8 as *const libc::c_char,
8257            summary: 0 as *const libc::c_char,
8258            since: 0 as *const libc::c_char,
8259            flags: 0 as libc::c_int,
8260            deprecated_since: 0 as *const libc::c_char,
8261            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8262            num_args: 0,
8263        };
8264        init
8265    },
8266    {
8267        let mut init = redisCommandArg {
8268            name: b"lt\0" as *const u8 as *const libc::c_char,
8269            type_0: ARG_TYPE_PURE_TOKEN,
8270            key_spec_index: -(1 as libc::c_int),
8271            token: b"LT\0" as *const u8 as *const libc::c_char,
8272            summary: 0 as *const libc::c_char,
8273            since: 0 as *const libc::c_char,
8274            flags: 0 as libc::c_int,
8275            deprecated_since: 0 as *const libc::c_char,
8276            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8277            num_args: 0,
8278        };
8279        init
8280    },
8281    {
8282        let mut init = redisCommandArg {
8283            name: 0 as *const libc::c_char,
8284            type_0: ARG_TYPE_STRING,
8285            key_spec_index: 0,
8286            token: 0 as *const libc::c_char,
8287            summary: 0 as *const libc::c_char,
8288            since: 0 as *const libc::c_char,
8289            flags: 0,
8290            deprecated_since: 0 as *const libc::c_char,
8291            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8292            num_args: 0,
8293        };
8294        init
8295    },
8296];
8297#[no_mangle]
8298pub static mut EXPIRE_Args: [redisCommandArg; 4] = unsafe {
8299    [
8300        {
8301            let mut init = redisCommandArg {
8302                name: b"key\0" as *const u8 as *const libc::c_char,
8303                type_0: ARG_TYPE_KEY,
8304                key_spec_index: 0 as libc::c_int,
8305                token: 0 as *const libc::c_char,
8306                summary: 0 as *const libc::c_char,
8307                since: 0 as *const libc::c_char,
8308                flags: 0 as libc::c_int,
8309                deprecated_since: 0 as *const libc::c_char,
8310                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8311                num_args: 0,
8312            };
8313            init
8314        },
8315        {
8316            let mut init = redisCommandArg {
8317                name: b"seconds\0" as *const u8 as *const libc::c_char,
8318                type_0: ARG_TYPE_INTEGER,
8319                key_spec_index: -(1 as libc::c_int),
8320                token: 0 as *const libc::c_char,
8321                summary: 0 as *const libc::c_char,
8322                since: 0 as *const libc::c_char,
8323                flags: 0 as libc::c_int,
8324                deprecated_since: 0 as *const libc::c_char,
8325                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8326                num_args: 0,
8327            };
8328            init
8329        },
8330        {
8331            let mut init = redisCommandArg {
8332                name: b"condition\0" as *const u8 as *const libc::c_char,
8333                type_0: ARG_TYPE_ONEOF,
8334                key_spec_index: -(1 as libc::c_int),
8335                token: 0 as *const libc::c_char,
8336                summary: 0 as *const libc::c_char,
8337                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
8338                flags: (1 as libc::c_int) << 0 as libc::c_int,
8339                deprecated_since: 0 as *const libc::c_char,
8340                subargs: EXPIRE_condition_Subargs.as_ptr() as *mut _,
8341                num_args: 0,
8342            };
8343            init
8344        },
8345        {
8346            let mut init = redisCommandArg {
8347                name: 0 as *const libc::c_char,
8348                type_0: ARG_TYPE_STRING,
8349                key_spec_index: 0,
8350                token: 0 as *const libc::c_char,
8351                summary: 0 as *const libc::c_char,
8352                since: 0 as *const libc::c_char,
8353                flags: 0,
8354                deprecated_since: 0 as *const libc::c_char,
8355                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8356                num_args: 0,
8357            };
8358            init
8359        },
8360    ]
8361};
8362#[no_mangle]
8363pub static mut EXPIREAT_History: [commandHistory; 2] = [
8364    {
8365        let mut init = commandHistory {
8366            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
8367            changes: b"Added options: `NX`, `XX`, `GT` and `LT`.\0" as *const u8
8368                as *const libc::c_char,
8369        };
8370        init
8371    },
8372    {
8373        let mut init = commandHistory {
8374            since: 0 as *const libc::c_char,
8375            changes: 0 as *const libc::c_char,
8376        };
8377        init
8378    },
8379];
8380#[no_mangle]
8381pub static mut EXPIREAT_condition_Subargs: [redisCommandArg; 5] = [
8382    {
8383        let mut init = redisCommandArg {
8384            name: b"nx\0" as *const u8 as *const libc::c_char,
8385            type_0: ARG_TYPE_PURE_TOKEN,
8386            key_spec_index: -(1 as libc::c_int),
8387            token: b"NX\0" as *const u8 as *const libc::c_char,
8388            summary: 0 as *const libc::c_char,
8389            since: 0 as *const libc::c_char,
8390            flags: 0 as libc::c_int,
8391            deprecated_since: 0 as *const libc::c_char,
8392            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8393            num_args: 0,
8394        };
8395        init
8396    },
8397    {
8398        let mut init = redisCommandArg {
8399            name: b"xx\0" as *const u8 as *const libc::c_char,
8400            type_0: ARG_TYPE_PURE_TOKEN,
8401            key_spec_index: -(1 as libc::c_int),
8402            token: b"XX\0" as *const u8 as *const libc::c_char,
8403            summary: 0 as *const libc::c_char,
8404            since: 0 as *const libc::c_char,
8405            flags: 0 as libc::c_int,
8406            deprecated_since: 0 as *const libc::c_char,
8407            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8408            num_args: 0,
8409        };
8410        init
8411    },
8412    {
8413        let mut init = redisCommandArg {
8414            name: b"gt\0" as *const u8 as *const libc::c_char,
8415            type_0: ARG_TYPE_PURE_TOKEN,
8416            key_spec_index: -(1 as libc::c_int),
8417            token: b"GT\0" as *const u8 as *const libc::c_char,
8418            summary: 0 as *const libc::c_char,
8419            since: 0 as *const libc::c_char,
8420            flags: 0 as libc::c_int,
8421            deprecated_since: 0 as *const libc::c_char,
8422            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8423            num_args: 0,
8424        };
8425        init
8426    },
8427    {
8428        let mut init = redisCommandArg {
8429            name: b"lt\0" as *const u8 as *const libc::c_char,
8430            type_0: ARG_TYPE_PURE_TOKEN,
8431            key_spec_index: -(1 as libc::c_int),
8432            token: b"LT\0" as *const u8 as *const libc::c_char,
8433            summary: 0 as *const libc::c_char,
8434            since: 0 as *const libc::c_char,
8435            flags: 0 as libc::c_int,
8436            deprecated_since: 0 as *const libc::c_char,
8437            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8438            num_args: 0,
8439        };
8440        init
8441    },
8442    {
8443        let mut init = redisCommandArg {
8444            name: 0 as *const libc::c_char,
8445            type_0: ARG_TYPE_STRING,
8446            key_spec_index: 0,
8447            token: 0 as *const libc::c_char,
8448            summary: 0 as *const libc::c_char,
8449            since: 0 as *const libc::c_char,
8450            flags: 0,
8451            deprecated_since: 0 as *const libc::c_char,
8452            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8453            num_args: 0,
8454        };
8455        init
8456    },
8457];
8458#[no_mangle]
8459pub static mut EXPIREAT_Args: [redisCommandArg; 4] = unsafe {
8460    [
8461        {
8462            let mut init = redisCommandArg {
8463                name: b"key\0" as *const u8 as *const libc::c_char,
8464                type_0: ARG_TYPE_KEY,
8465                key_spec_index: 0 as libc::c_int,
8466                token: 0 as *const libc::c_char,
8467                summary: 0 as *const libc::c_char,
8468                since: 0 as *const libc::c_char,
8469                flags: 0 as libc::c_int,
8470                deprecated_since: 0 as *const libc::c_char,
8471                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8472                num_args: 0,
8473            };
8474            init
8475        },
8476        {
8477            let mut init = redisCommandArg {
8478                name: b"unix-time-seconds\0" as *const u8 as *const libc::c_char,
8479                type_0: ARG_TYPE_UNIX_TIME,
8480                key_spec_index: -(1 as libc::c_int),
8481                token: 0 as *const libc::c_char,
8482                summary: 0 as *const libc::c_char,
8483                since: 0 as *const libc::c_char,
8484                flags: 0 as libc::c_int,
8485                deprecated_since: 0 as *const libc::c_char,
8486                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8487                num_args: 0,
8488            };
8489            init
8490        },
8491        {
8492            let mut init = redisCommandArg {
8493                name: b"condition\0" as *const u8 as *const libc::c_char,
8494                type_0: ARG_TYPE_ONEOF,
8495                key_spec_index: -(1 as libc::c_int),
8496                token: 0 as *const libc::c_char,
8497                summary: 0 as *const libc::c_char,
8498                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
8499                flags: (1 as libc::c_int) << 0 as libc::c_int,
8500                deprecated_since: 0 as *const libc::c_char,
8501                subargs: EXPIREAT_condition_Subargs.as_ptr() as *mut _,
8502                num_args: 0,
8503            };
8504            init
8505        },
8506        {
8507            let mut init = redisCommandArg {
8508                name: 0 as *const libc::c_char,
8509                type_0: ARG_TYPE_STRING,
8510                key_spec_index: 0,
8511                token: 0 as *const libc::c_char,
8512                summary: 0 as *const libc::c_char,
8513                since: 0 as *const libc::c_char,
8514                flags: 0,
8515                deprecated_since: 0 as *const libc::c_char,
8516                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8517                num_args: 0,
8518            };
8519            init
8520        },
8521    ]
8522};
8523#[no_mangle]
8524pub static mut EXPIRETIME_Args: [redisCommandArg; 2] = [
8525    {
8526        let mut init = redisCommandArg {
8527            name: b"key\0" as *const u8 as *const libc::c_char,
8528            type_0: ARG_TYPE_KEY,
8529            key_spec_index: 0 as libc::c_int,
8530            token: 0 as *const libc::c_char,
8531            summary: 0 as *const libc::c_char,
8532            since: 0 as *const libc::c_char,
8533            flags: 0 as libc::c_int,
8534            deprecated_since: 0 as *const libc::c_char,
8535            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8536            num_args: 0,
8537        };
8538        init
8539    },
8540    {
8541        let mut init = redisCommandArg {
8542            name: 0 as *const libc::c_char,
8543            type_0: ARG_TYPE_STRING,
8544            key_spec_index: 0,
8545            token: 0 as *const libc::c_char,
8546            summary: 0 as *const libc::c_char,
8547            since: 0 as *const libc::c_char,
8548            flags: 0,
8549            deprecated_since: 0 as *const libc::c_char,
8550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8551            num_args: 0,
8552        };
8553        init
8554    },
8555];
8556#[no_mangle]
8557pub static mut KEYS_tips: [*const libc::c_char; 3] = [
8558    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
8559    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
8560    0 as *const libc::c_char,
8561];
8562#[no_mangle]
8563pub static mut KEYS_Args: [redisCommandArg; 2] = [
8564    {
8565        let mut init = redisCommandArg {
8566            name: b"pattern\0" as *const u8 as *const libc::c_char,
8567            type_0: ARG_TYPE_PATTERN,
8568            key_spec_index: -(1 as libc::c_int),
8569            token: 0 as *const libc::c_char,
8570            summary: 0 as *const libc::c_char,
8571            since: 0 as *const libc::c_char,
8572            flags: 0 as libc::c_int,
8573            deprecated_since: 0 as *const libc::c_char,
8574            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8575            num_args: 0,
8576        };
8577        init
8578    },
8579    {
8580        let mut init = redisCommandArg {
8581            name: 0 as *const libc::c_char,
8582            type_0: ARG_TYPE_STRING,
8583            key_spec_index: 0,
8584            token: 0 as *const libc::c_char,
8585            summary: 0 as *const libc::c_char,
8586            since: 0 as *const libc::c_char,
8587            flags: 0,
8588            deprecated_since: 0 as *const libc::c_char,
8589            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8590            num_args: 0,
8591        };
8592        init
8593    },
8594];
8595#[no_mangle]
8596pub static mut MIGRATE_History: [commandHistory; 5] = [
8597    {
8598        let mut init = commandHistory {
8599            since: b"3.0.0\0" as *const u8 as *const libc::c_char,
8600            changes: b"Added the `COPY` and `REPLACE` options.\0" as *const u8
8601                as *const libc::c_char,
8602        };
8603        init
8604    },
8605    {
8606        let mut init = commandHistory {
8607            since: b"3.0.6\0" as *const u8 as *const libc::c_char,
8608            changes: b"Added the `KEYS` option.\0" as *const u8 as *const libc::c_char,
8609        };
8610        init
8611    },
8612    {
8613        let mut init = commandHistory {
8614            since: b"4.0.7\0" as *const u8 as *const libc::c_char,
8615            changes: b"Added the `AUTH` option.\0" as *const u8 as *const libc::c_char,
8616        };
8617        init
8618    },
8619    {
8620        let mut init = commandHistory {
8621            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
8622            changes: b"Added the `AUTH2` option.\0" as *const u8 as *const libc::c_char,
8623        };
8624        init
8625    },
8626    {
8627        let mut init = commandHistory {
8628            since: 0 as *const libc::c_char,
8629            changes: 0 as *const libc::c_char,
8630        };
8631        init
8632    },
8633];
8634#[no_mangle]
8635pub static mut MIGRATE_tips: [*const libc::c_char; 2] = [
8636    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
8637    0 as *const libc::c_char,
8638];
8639#[no_mangle]
8640pub static mut MIGRATE_key_or_empty_string_Subargs: [redisCommandArg; 3] = [
8641    {
8642        let mut init = redisCommandArg {
8643            name: b"key\0" as *const u8 as *const libc::c_char,
8644            type_0: ARG_TYPE_KEY,
8645            key_spec_index: 0 as libc::c_int,
8646            token: 0 as *const libc::c_char,
8647            summary: 0 as *const libc::c_char,
8648            since: 0 as *const libc::c_char,
8649            flags: 0 as libc::c_int,
8650            deprecated_since: 0 as *const libc::c_char,
8651            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8652            num_args: 0,
8653        };
8654        init
8655    },
8656    {
8657        let mut init = redisCommandArg {
8658            name: b"empty_string\0" as *const u8 as *const libc::c_char,
8659            type_0: ARG_TYPE_PURE_TOKEN,
8660            key_spec_index: -(1 as libc::c_int),
8661            token: b"\0" as *const u8 as *const libc::c_char,
8662            summary: 0 as *const libc::c_char,
8663            since: 0 as *const libc::c_char,
8664            flags: 0 as libc::c_int,
8665            deprecated_since: 0 as *const libc::c_char,
8666            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8667            num_args: 0,
8668        };
8669        init
8670    },
8671    {
8672        let mut init = redisCommandArg {
8673            name: 0 as *const libc::c_char,
8674            type_0: ARG_TYPE_STRING,
8675            key_spec_index: 0,
8676            token: 0 as *const libc::c_char,
8677            summary: 0 as *const libc::c_char,
8678            since: 0 as *const libc::c_char,
8679            flags: 0,
8680            deprecated_since: 0 as *const libc::c_char,
8681            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8682            num_args: 0,
8683        };
8684        init
8685    },
8686];
8687#[no_mangle]
8688pub static mut MIGRATE_authentication_username_password_Subargs: [redisCommandArg; 3] = [
8689    {
8690        let mut init = redisCommandArg {
8691            name: b"username\0" as *const u8 as *const libc::c_char,
8692            type_0: ARG_TYPE_STRING,
8693            key_spec_index: -(1 as libc::c_int),
8694            token: 0 as *const libc::c_char,
8695            summary: 0 as *const libc::c_char,
8696            since: 0 as *const libc::c_char,
8697            flags: 0 as libc::c_int,
8698            deprecated_since: 0 as *const libc::c_char,
8699            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8700            num_args: 0,
8701        };
8702        init
8703    },
8704    {
8705        let mut init = redisCommandArg {
8706            name: b"password\0" as *const u8 as *const libc::c_char,
8707            type_0: ARG_TYPE_STRING,
8708            key_spec_index: -(1 as libc::c_int),
8709            token: 0 as *const libc::c_char,
8710            summary: 0 as *const libc::c_char,
8711            since: 0 as *const libc::c_char,
8712            flags: 0 as libc::c_int,
8713            deprecated_since: 0 as *const libc::c_char,
8714            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8715            num_args: 0,
8716        };
8717        init
8718    },
8719    {
8720        let mut init = redisCommandArg {
8721            name: 0 as *const libc::c_char,
8722            type_0: ARG_TYPE_STRING,
8723            key_spec_index: 0,
8724            token: 0 as *const libc::c_char,
8725            summary: 0 as *const libc::c_char,
8726            since: 0 as *const libc::c_char,
8727            flags: 0,
8728            deprecated_since: 0 as *const libc::c_char,
8729            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8730            num_args: 0,
8731        };
8732        init
8733    },
8734];
8735#[no_mangle]
8736pub static mut MIGRATE_authentication_Subargs: [redisCommandArg; 3] = unsafe {
8737    [
8738        {
8739            let mut init = redisCommandArg {
8740                name: b"password\0" as *const u8 as *const libc::c_char,
8741                type_0: ARG_TYPE_STRING,
8742                key_spec_index: -(1 as libc::c_int),
8743                token: b"AUTH\0" as *const u8 as *const libc::c_char,
8744                summary: 0 as *const libc::c_char,
8745                since: b"4.0.7\0" as *const u8 as *const libc::c_char,
8746                flags: (1 as libc::c_int) << 0 as libc::c_int,
8747                deprecated_since: 0 as *const libc::c_char,
8748                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8749                num_args: 0,
8750            };
8751            init
8752        },
8753        {
8754            let mut init = redisCommandArg {
8755                name: b"username_password\0" as *const u8 as *const libc::c_char,
8756                type_0: ARG_TYPE_BLOCK,
8757                key_spec_index: -(1 as libc::c_int),
8758                token: b"AUTH2\0" as *const u8 as *const libc::c_char,
8759                summary: 0 as *const libc::c_char,
8760                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
8761                flags: (1 as libc::c_int) << 0 as libc::c_int,
8762                deprecated_since: 0 as *const libc::c_char,
8763                subargs: MIGRATE_authentication_username_password_Subargs.as_ptr()
8764                    as *mut _,
8765                num_args: 0,
8766            };
8767            init
8768        },
8769        {
8770            let mut init = redisCommandArg {
8771                name: 0 as *const libc::c_char,
8772                type_0: ARG_TYPE_STRING,
8773                key_spec_index: 0,
8774                token: 0 as *const libc::c_char,
8775                summary: 0 as *const libc::c_char,
8776                since: 0 as *const libc::c_char,
8777                flags: 0,
8778                deprecated_since: 0 as *const libc::c_char,
8779                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8780                num_args: 0,
8781            };
8782            init
8783        },
8784    ]
8785};
8786#[no_mangle]
8787pub static mut MIGRATE_Args: [redisCommandArg; 10] = unsafe {
8788    [
8789        {
8790            let mut init = redisCommandArg {
8791                name: b"host\0" as *const u8 as *const libc::c_char,
8792                type_0: ARG_TYPE_STRING,
8793                key_spec_index: -(1 as libc::c_int),
8794                token: 0 as *const libc::c_char,
8795                summary: 0 as *const libc::c_char,
8796                since: 0 as *const libc::c_char,
8797                flags: 0 as libc::c_int,
8798                deprecated_since: 0 as *const libc::c_char,
8799                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8800                num_args: 0,
8801            };
8802            init
8803        },
8804        {
8805            let mut init = redisCommandArg {
8806                name: b"port\0" as *const u8 as *const libc::c_char,
8807                type_0: ARG_TYPE_INTEGER,
8808                key_spec_index: -(1 as libc::c_int),
8809                token: 0 as *const libc::c_char,
8810                summary: 0 as *const libc::c_char,
8811                since: 0 as *const libc::c_char,
8812                flags: 0 as libc::c_int,
8813                deprecated_since: 0 as *const libc::c_char,
8814                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8815                num_args: 0,
8816            };
8817            init
8818        },
8819        {
8820            let mut init = redisCommandArg {
8821                name: b"key_or_empty_string\0" as *const u8 as *const libc::c_char,
8822                type_0: ARG_TYPE_ONEOF,
8823                key_spec_index: -(1 as libc::c_int),
8824                token: 0 as *const libc::c_char,
8825                summary: 0 as *const libc::c_char,
8826                since: 0 as *const libc::c_char,
8827                flags: 0 as libc::c_int,
8828                deprecated_since: 0 as *const libc::c_char,
8829                subargs: MIGRATE_key_or_empty_string_Subargs.as_ptr() as *mut _,
8830                num_args: 0,
8831            };
8832            init
8833        },
8834        {
8835            let mut init = redisCommandArg {
8836                name: b"destination-db\0" as *const u8 as *const libc::c_char,
8837                type_0: ARG_TYPE_INTEGER,
8838                key_spec_index: -(1 as libc::c_int),
8839                token: 0 as *const libc::c_char,
8840                summary: 0 as *const libc::c_char,
8841                since: 0 as *const libc::c_char,
8842                flags: 0 as libc::c_int,
8843                deprecated_since: 0 as *const libc::c_char,
8844                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8845                num_args: 0,
8846            };
8847            init
8848        },
8849        {
8850            let mut init = redisCommandArg {
8851                name: b"timeout\0" as *const u8 as *const libc::c_char,
8852                type_0: ARG_TYPE_INTEGER,
8853                key_spec_index: -(1 as libc::c_int),
8854                token: 0 as *const libc::c_char,
8855                summary: 0 as *const libc::c_char,
8856                since: 0 as *const libc::c_char,
8857                flags: 0 as libc::c_int,
8858                deprecated_since: 0 as *const libc::c_char,
8859                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8860                num_args: 0,
8861            };
8862            init
8863        },
8864        {
8865            let mut init = redisCommandArg {
8866                name: b"copy\0" as *const u8 as *const libc::c_char,
8867                type_0: ARG_TYPE_PURE_TOKEN,
8868                key_spec_index: -(1 as libc::c_int),
8869                token: b"COPY\0" as *const u8 as *const libc::c_char,
8870                summary: 0 as *const libc::c_char,
8871                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
8872                flags: (1 as libc::c_int) << 0 as libc::c_int,
8873                deprecated_since: 0 as *const libc::c_char,
8874                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8875                num_args: 0,
8876            };
8877            init
8878        },
8879        {
8880            let mut init = redisCommandArg {
8881                name: b"replace\0" as *const u8 as *const libc::c_char,
8882                type_0: ARG_TYPE_PURE_TOKEN,
8883                key_spec_index: -(1 as libc::c_int),
8884                token: b"REPLACE\0" as *const u8 as *const libc::c_char,
8885                summary: 0 as *const libc::c_char,
8886                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
8887                flags: (1 as libc::c_int) << 0 as libc::c_int,
8888                deprecated_since: 0 as *const libc::c_char,
8889                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8890                num_args: 0,
8891            };
8892            init
8893        },
8894        {
8895            let mut init = redisCommandArg {
8896                name: b"authentication\0" as *const u8 as *const libc::c_char,
8897                type_0: ARG_TYPE_ONEOF,
8898                key_spec_index: -(1 as libc::c_int),
8899                token: 0 as *const libc::c_char,
8900                summary: 0 as *const libc::c_char,
8901                since: 0 as *const libc::c_char,
8902                flags: (1 as libc::c_int) << 0 as libc::c_int,
8903                deprecated_since: 0 as *const libc::c_char,
8904                subargs: MIGRATE_authentication_Subargs.as_ptr() as *mut _,
8905                num_args: 0,
8906            };
8907            init
8908        },
8909        {
8910            let mut init = redisCommandArg {
8911                name: b"key\0" as *const u8 as *const libc::c_char,
8912                type_0: ARG_TYPE_KEY,
8913                key_spec_index: 1 as libc::c_int,
8914                token: b"KEYS\0" as *const u8 as *const libc::c_char,
8915                summary: 0 as *const libc::c_char,
8916                since: b"3.0.6\0" as *const u8 as *const libc::c_char,
8917                flags: (1 as libc::c_int) << 0 as libc::c_int
8918                    | (1 as libc::c_int) << 1 as libc::c_int,
8919                deprecated_since: 0 as *const libc::c_char,
8920                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8921                num_args: 0,
8922            };
8923            init
8924        },
8925        {
8926            let mut init = redisCommandArg {
8927                name: 0 as *const libc::c_char,
8928                type_0: ARG_TYPE_STRING,
8929                key_spec_index: 0,
8930                token: 0 as *const libc::c_char,
8931                summary: 0 as *const libc::c_char,
8932                since: 0 as *const libc::c_char,
8933                flags: 0,
8934                deprecated_since: 0 as *const libc::c_char,
8935                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8936                num_args: 0,
8937            };
8938            init
8939        },
8940    ]
8941};
8942#[no_mangle]
8943pub static mut MOVE_Args: [redisCommandArg; 3] = [
8944    {
8945        let mut init = redisCommandArg {
8946            name: b"key\0" as *const u8 as *const libc::c_char,
8947            type_0: ARG_TYPE_KEY,
8948            key_spec_index: 0 as libc::c_int,
8949            token: 0 as *const libc::c_char,
8950            summary: 0 as *const libc::c_char,
8951            since: 0 as *const libc::c_char,
8952            flags: 0 as libc::c_int,
8953            deprecated_since: 0 as *const libc::c_char,
8954            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8955            num_args: 0,
8956        };
8957        init
8958    },
8959    {
8960        let mut init = redisCommandArg {
8961            name: b"db\0" as *const u8 as *const libc::c_char,
8962            type_0: ARG_TYPE_INTEGER,
8963            key_spec_index: -(1 as libc::c_int),
8964            token: 0 as *const libc::c_char,
8965            summary: 0 as *const libc::c_char,
8966            since: 0 as *const libc::c_char,
8967            flags: 0 as libc::c_int,
8968            deprecated_since: 0 as *const libc::c_char,
8969            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8970            num_args: 0,
8971        };
8972        init
8973    },
8974    {
8975        let mut init = redisCommandArg {
8976            name: 0 as *const libc::c_char,
8977            type_0: ARG_TYPE_STRING,
8978            key_spec_index: 0,
8979            token: 0 as *const libc::c_char,
8980            summary: 0 as *const libc::c_char,
8981            since: 0 as *const libc::c_char,
8982            flags: 0,
8983            deprecated_since: 0 as *const libc::c_char,
8984            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
8985            num_args: 0,
8986        };
8987        init
8988    },
8989];
8990#[no_mangle]
8991pub static mut OBJECT_ENCODING_tips: [*const libc::c_char; 2] = [
8992    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
8993    0 as *const libc::c_char,
8994];
8995#[no_mangle]
8996pub static mut OBJECT_ENCODING_Args: [redisCommandArg; 2] = [
8997    {
8998        let mut init = redisCommandArg {
8999            name: b"key\0" as *const u8 as *const libc::c_char,
9000            type_0: ARG_TYPE_KEY,
9001            key_spec_index: 0 as libc::c_int,
9002            token: 0 as *const libc::c_char,
9003            summary: 0 as *const libc::c_char,
9004            since: 0 as *const libc::c_char,
9005            flags: 0 as libc::c_int,
9006            deprecated_since: 0 as *const libc::c_char,
9007            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9008            num_args: 0,
9009        };
9010        init
9011    },
9012    {
9013        let mut init = redisCommandArg {
9014            name: 0 as *const libc::c_char,
9015            type_0: ARG_TYPE_STRING,
9016            key_spec_index: 0,
9017            token: 0 as *const libc::c_char,
9018            summary: 0 as *const libc::c_char,
9019            since: 0 as *const libc::c_char,
9020            flags: 0,
9021            deprecated_since: 0 as *const libc::c_char,
9022            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9023            num_args: 0,
9024        };
9025        init
9026    },
9027];
9028#[no_mangle]
9029pub static mut OBJECT_FREQ_tips: [*const libc::c_char; 2] = [
9030    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
9031    0 as *const libc::c_char,
9032];
9033#[no_mangle]
9034pub static mut OBJECT_FREQ_Args: [redisCommandArg; 2] = [
9035    {
9036        let mut init = redisCommandArg {
9037            name: b"key\0" as *const u8 as *const libc::c_char,
9038            type_0: ARG_TYPE_KEY,
9039            key_spec_index: 0 as libc::c_int,
9040            token: 0 as *const libc::c_char,
9041            summary: 0 as *const libc::c_char,
9042            since: 0 as *const libc::c_char,
9043            flags: 0 as libc::c_int,
9044            deprecated_since: 0 as *const libc::c_char,
9045            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9046            num_args: 0,
9047        };
9048        init
9049    },
9050    {
9051        let mut init = redisCommandArg {
9052            name: 0 as *const libc::c_char,
9053            type_0: ARG_TYPE_STRING,
9054            key_spec_index: 0,
9055            token: 0 as *const libc::c_char,
9056            summary: 0 as *const libc::c_char,
9057            since: 0 as *const libc::c_char,
9058            flags: 0,
9059            deprecated_since: 0 as *const libc::c_char,
9060            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9061            num_args: 0,
9062        };
9063        init
9064    },
9065];
9066#[no_mangle]
9067pub static mut OBJECT_IDLETIME_tips: [*const libc::c_char; 2] = [
9068    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
9069    0 as *const libc::c_char,
9070];
9071#[no_mangle]
9072pub static mut OBJECT_IDLETIME_Args: [redisCommandArg; 2] = [
9073    {
9074        let mut init = redisCommandArg {
9075            name: b"key\0" as *const u8 as *const libc::c_char,
9076            type_0: ARG_TYPE_KEY,
9077            key_spec_index: 0 as libc::c_int,
9078            token: 0 as *const libc::c_char,
9079            summary: 0 as *const libc::c_char,
9080            since: 0 as *const libc::c_char,
9081            flags: 0 as libc::c_int,
9082            deprecated_since: 0 as *const libc::c_char,
9083            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9084            num_args: 0,
9085        };
9086        init
9087    },
9088    {
9089        let mut init = redisCommandArg {
9090            name: 0 as *const libc::c_char,
9091            type_0: ARG_TYPE_STRING,
9092            key_spec_index: 0,
9093            token: 0 as *const libc::c_char,
9094            summary: 0 as *const libc::c_char,
9095            since: 0 as *const libc::c_char,
9096            flags: 0,
9097            deprecated_since: 0 as *const libc::c_char,
9098            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9099            num_args: 0,
9100        };
9101        init
9102    },
9103];
9104#[no_mangle]
9105pub static mut OBJECT_REFCOUNT_tips: [*const libc::c_char; 2] = [
9106    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
9107    0 as *const libc::c_char,
9108];
9109#[no_mangle]
9110pub static mut OBJECT_REFCOUNT_Args: [redisCommandArg; 2] = [
9111    {
9112        let mut init = redisCommandArg {
9113            name: b"key\0" as *const u8 as *const libc::c_char,
9114            type_0: ARG_TYPE_KEY,
9115            key_spec_index: 0 as libc::c_int,
9116            token: 0 as *const libc::c_char,
9117            summary: 0 as *const libc::c_char,
9118            since: 0 as *const libc::c_char,
9119            flags: 0 as libc::c_int,
9120            deprecated_since: 0 as *const libc::c_char,
9121            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9122            num_args: 0,
9123        };
9124        init
9125    },
9126    {
9127        let mut init = redisCommandArg {
9128            name: 0 as *const libc::c_char,
9129            type_0: ARG_TYPE_STRING,
9130            key_spec_index: 0,
9131            token: 0 as *const libc::c_char,
9132            summary: 0 as *const libc::c_char,
9133            since: 0 as *const libc::c_char,
9134            flags: 0,
9135            deprecated_since: 0 as *const libc::c_char,
9136            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9137            num_args: 0,
9138        };
9139        init
9140    },
9141];
9142#[no_mangle]
9143pub static mut OBJECT_Subcommands: [redisCommand; 6] = unsafe {
9144    [
9145        {
9146            let mut init = redisCommand {
9147                declared_name: b"encoding\0" as *const u8 as *const libc::c_char,
9148                summary: b"Inspect the internal encoding of a Redis object\0"
9149                    as *const u8 as *const libc::c_char,
9150                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
9151                since: b"2.2.3\0" as *const u8 as *const libc::c_char,
9152                doc_flags: 0 as libc::c_int,
9153                replaced_by: 0 as *const libc::c_char,
9154                deprecated_since: 0 as *const libc::c_char,
9155                group: COMMAND_GROUP_GENERIC,
9156                history: 0 as *const commandHistory as *mut commandHistory,
9157                tips: OBJECT_ENCODING_tips.as_ptr() as *mut _,
9158                proc_0: Some(objectCommand as unsafe extern "C" fn(*mut client) -> ()),
9159                arity: 3 as libc::c_int,
9160                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
9161                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9162                    as uint64_t,
9163                key_specs_static: [
9164                    {
9165                        let mut init = keySpec {
9166                            notes: 0 as *const libc::c_char,
9167                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9168                                as uint64_t,
9169                            begin_search_type: KSPEC_BS_INDEX,
9170                            bs: C2RustUnnamed_3 {
9171                                index: {
9172                                    let mut init = C2RustUnnamed_5 {
9173                                        pos: 2 as libc::c_int,
9174                                    };
9175                                    init
9176                                },
9177                            },
9178                            find_keys_type: KSPEC_FK_RANGE,
9179                            fk: C2RustUnnamed_0 {
9180                                range: {
9181                                    let mut init = C2RustUnnamed_2 {
9182                                        lastkey: 0 as libc::c_int,
9183                                        keystep: 1 as libc::c_int,
9184                                        limit: 0 as libc::c_int,
9185                                    };
9186                                    init
9187                                },
9188                            },
9189                        };
9190                        init
9191                    },
9192                    keySpec {
9193                        notes: 0 as *const libc::c_char,
9194                        flags: 0,
9195                        begin_search_type: KSPEC_BS_INVALID,
9196                        bs: C2RustUnnamed_3 {
9197                            index: C2RustUnnamed_5 { pos: 0 },
9198                        },
9199                        find_keys_type: KSPEC_FK_INVALID,
9200                        fk: C2RustUnnamed_0 {
9201                            range: C2RustUnnamed_2 {
9202                                lastkey: 0,
9203                                keystep: 0,
9204                                limit: 0,
9205                            },
9206                        },
9207                    },
9208                    keySpec {
9209                        notes: 0 as *const libc::c_char,
9210                        flags: 0,
9211                        begin_search_type: KSPEC_BS_INVALID,
9212                        bs: C2RustUnnamed_3 {
9213                            index: C2RustUnnamed_5 { pos: 0 },
9214                        },
9215                        find_keys_type: KSPEC_FK_INVALID,
9216                        fk: C2RustUnnamed_0 {
9217                            range: C2RustUnnamed_2 {
9218                                lastkey: 0,
9219                                keystep: 0,
9220                                limit: 0,
9221                            },
9222                        },
9223                    },
9224                    keySpec {
9225                        notes: 0 as *const libc::c_char,
9226                        flags: 0,
9227                        begin_search_type: KSPEC_BS_INVALID,
9228                        bs: C2RustUnnamed_3 {
9229                            index: C2RustUnnamed_5 { pos: 0 },
9230                        },
9231                        find_keys_type: KSPEC_FK_INVALID,
9232                        fk: C2RustUnnamed_0 {
9233                            range: C2RustUnnamed_2 {
9234                                lastkey: 0,
9235                                keystep: 0,
9236                                limit: 0,
9237                            },
9238                        },
9239                    },
9240                ],
9241                getkeys_proc: None,
9242                subcommands: 0 as *const redisCommand as *mut redisCommand,
9243                args: OBJECT_ENCODING_Args.as_ptr() as *mut _,
9244                microseconds: 0,
9245                calls: 0,
9246                rejected_calls: 0,
9247                failed_calls: 0,
9248                id: 0,
9249                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9250                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9251                key_specs: 0 as *const keySpec as *mut keySpec,
9252                legacy_range_key_spec: keySpec {
9253                    notes: 0 as *const libc::c_char,
9254                    flags: 0,
9255                    begin_search_type: KSPEC_BS_INVALID,
9256                    bs: C2RustUnnamed_3 {
9257                        index: C2RustUnnamed_5 { pos: 0 },
9258                    },
9259                    find_keys_type: KSPEC_FK_INVALID,
9260                    fk: C2RustUnnamed_0 {
9261                        range: C2RustUnnamed_2 {
9262                            lastkey: 0,
9263                            keystep: 0,
9264                            limit: 0,
9265                        },
9266                    },
9267                },
9268                num_args: 0,
9269                num_history: 0,
9270                num_tips: 0,
9271                key_specs_num: 0,
9272                key_specs_max: 0,
9273                subcommands_dict: 0 as *const dict as *mut dict,
9274                parent: 0 as *const redisCommand as *mut redisCommand,
9275                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9276            };
9277            init
9278        },
9279        {
9280            let mut init = redisCommand {
9281                declared_name: b"freq\0" as *const u8 as *const libc::c_char,
9282                summary: b"Get the logarithmic access frequency counter of a Redis object\0"
9283                    as *const u8 as *const libc::c_char,
9284                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
9285                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
9286                doc_flags: 0 as libc::c_int,
9287                replaced_by: 0 as *const libc::c_char,
9288                deprecated_since: 0 as *const libc::c_char,
9289                group: COMMAND_GROUP_GENERIC,
9290                history: 0 as *const commandHistory as *mut commandHistory,
9291                tips: OBJECT_FREQ_tips.as_ptr() as *mut _,
9292                proc_0: Some(objectCommand as unsafe extern "C" fn(*mut client) -> ()),
9293                arity: 3 as libc::c_int,
9294                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
9295                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9296                    as uint64_t,
9297                key_specs_static: [
9298                    {
9299                        let mut init = keySpec {
9300                            notes: 0 as *const libc::c_char,
9301                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9302                                as uint64_t,
9303                            begin_search_type: KSPEC_BS_INDEX,
9304                            bs: C2RustUnnamed_3 {
9305                                index: {
9306                                    let mut init = C2RustUnnamed_5 {
9307                                        pos: 2 as libc::c_int,
9308                                    };
9309                                    init
9310                                },
9311                            },
9312                            find_keys_type: KSPEC_FK_RANGE,
9313                            fk: C2RustUnnamed_0 {
9314                                range: {
9315                                    let mut init = C2RustUnnamed_2 {
9316                                        lastkey: 0 as libc::c_int,
9317                                        keystep: 1 as libc::c_int,
9318                                        limit: 0 as libc::c_int,
9319                                    };
9320                                    init
9321                                },
9322                            },
9323                        };
9324                        init
9325                    },
9326                    keySpec {
9327                        notes: 0 as *const libc::c_char,
9328                        flags: 0,
9329                        begin_search_type: KSPEC_BS_INVALID,
9330                        bs: C2RustUnnamed_3 {
9331                            index: C2RustUnnamed_5 { pos: 0 },
9332                        },
9333                        find_keys_type: KSPEC_FK_INVALID,
9334                        fk: C2RustUnnamed_0 {
9335                            range: C2RustUnnamed_2 {
9336                                lastkey: 0,
9337                                keystep: 0,
9338                                limit: 0,
9339                            },
9340                        },
9341                    },
9342                    keySpec {
9343                        notes: 0 as *const libc::c_char,
9344                        flags: 0,
9345                        begin_search_type: KSPEC_BS_INVALID,
9346                        bs: C2RustUnnamed_3 {
9347                            index: C2RustUnnamed_5 { pos: 0 },
9348                        },
9349                        find_keys_type: KSPEC_FK_INVALID,
9350                        fk: C2RustUnnamed_0 {
9351                            range: C2RustUnnamed_2 {
9352                                lastkey: 0,
9353                                keystep: 0,
9354                                limit: 0,
9355                            },
9356                        },
9357                    },
9358                    keySpec {
9359                        notes: 0 as *const libc::c_char,
9360                        flags: 0,
9361                        begin_search_type: KSPEC_BS_INVALID,
9362                        bs: C2RustUnnamed_3 {
9363                            index: C2RustUnnamed_5 { pos: 0 },
9364                        },
9365                        find_keys_type: KSPEC_FK_INVALID,
9366                        fk: C2RustUnnamed_0 {
9367                            range: C2RustUnnamed_2 {
9368                                lastkey: 0,
9369                                keystep: 0,
9370                                limit: 0,
9371                            },
9372                        },
9373                    },
9374                ],
9375                getkeys_proc: None,
9376                subcommands: 0 as *const redisCommand as *mut redisCommand,
9377                args: OBJECT_FREQ_Args.as_ptr() as *mut _,
9378                microseconds: 0,
9379                calls: 0,
9380                rejected_calls: 0,
9381                failed_calls: 0,
9382                id: 0,
9383                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9384                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9385                key_specs: 0 as *const keySpec as *mut keySpec,
9386                legacy_range_key_spec: keySpec {
9387                    notes: 0 as *const libc::c_char,
9388                    flags: 0,
9389                    begin_search_type: KSPEC_BS_INVALID,
9390                    bs: C2RustUnnamed_3 {
9391                        index: C2RustUnnamed_5 { pos: 0 },
9392                    },
9393                    find_keys_type: KSPEC_FK_INVALID,
9394                    fk: C2RustUnnamed_0 {
9395                        range: C2RustUnnamed_2 {
9396                            lastkey: 0,
9397                            keystep: 0,
9398                            limit: 0,
9399                        },
9400                    },
9401                },
9402                num_args: 0,
9403                num_history: 0,
9404                num_tips: 0,
9405                key_specs_num: 0,
9406                key_specs_max: 0,
9407                subcommands_dict: 0 as *const dict as *mut dict,
9408                parent: 0 as *const redisCommand as *mut redisCommand,
9409                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9410            };
9411            init
9412        },
9413        {
9414            let mut init = redisCommand {
9415                declared_name: b"help\0" as *const u8 as *const libc::c_char,
9416                summary: b"Show helpful text about the different subcommands\0"
9417                    as *const u8 as *const libc::c_char,
9418                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
9419                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
9420                doc_flags: 0 as libc::c_int,
9421                replaced_by: 0 as *const libc::c_char,
9422                deprecated_since: 0 as *const libc::c_char,
9423                group: COMMAND_GROUP_GENERIC,
9424                history: 0 as *const commandHistory as *mut commandHistory,
9425                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
9426                proc_0: Some(objectCommand as unsafe extern "C" fn(*mut client) -> ()),
9427                arity: 2 as libc::c_int,
9428                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
9429                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
9430                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9431                    as uint64_t,
9432                key_specs_static: [keySpec {
9433                    notes: 0 as *const libc::c_char,
9434                    flags: 0,
9435                    begin_search_type: KSPEC_BS_INVALID,
9436                    bs: C2RustUnnamed_3 {
9437                        index: C2RustUnnamed_5 { pos: 0 },
9438                    },
9439                    find_keys_type: KSPEC_FK_INVALID,
9440                    fk: C2RustUnnamed_0 {
9441                        range: C2RustUnnamed_2 {
9442                            lastkey: 0,
9443                            keystep: 0,
9444                            limit: 0,
9445                        },
9446                    },
9447                }; 4],
9448                getkeys_proc: None,
9449                subcommands: 0 as *const redisCommand as *mut redisCommand,
9450                args: 0 as *const redisCommandArg as *mut redisCommandArg,
9451                microseconds: 0,
9452                calls: 0,
9453                rejected_calls: 0,
9454                failed_calls: 0,
9455                id: 0,
9456                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9457                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9458                key_specs: 0 as *const keySpec as *mut keySpec,
9459                legacy_range_key_spec: keySpec {
9460                    notes: 0 as *const libc::c_char,
9461                    flags: 0,
9462                    begin_search_type: KSPEC_BS_INVALID,
9463                    bs: C2RustUnnamed_3 {
9464                        index: C2RustUnnamed_5 { pos: 0 },
9465                    },
9466                    find_keys_type: KSPEC_FK_INVALID,
9467                    fk: C2RustUnnamed_0 {
9468                        range: C2RustUnnamed_2 {
9469                            lastkey: 0,
9470                            keystep: 0,
9471                            limit: 0,
9472                        },
9473                    },
9474                },
9475                num_args: 0,
9476                num_history: 0,
9477                num_tips: 0,
9478                key_specs_num: 0,
9479                key_specs_max: 0,
9480                subcommands_dict: 0 as *const dict as *mut dict,
9481                parent: 0 as *const redisCommand as *mut redisCommand,
9482                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9483            };
9484            init
9485        },
9486        {
9487            let mut init = redisCommand {
9488                declared_name: b"idletime\0" as *const u8 as *const libc::c_char,
9489                summary: b"Get the time since a Redis object was last accessed\0"
9490                    as *const u8 as *const libc::c_char,
9491                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
9492                since: b"2.2.3\0" as *const u8 as *const libc::c_char,
9493                doc_flags: 0 as libc::c_int,
9494                replaced_by: 0 as *const libc::c_char,
9495                deprecated_since: 0 as *const libc::c_char,
9496                group: COMMAND_GROUP_GENERIC,
9497                history: 0 as *const commandHistory as *mut commandHistory,
9498                tips: OBJECT_IDLETIME_tips.as_ptr() as *mut _,
9499                proc_0: Some(objectCommand as unsafe extern "C" fn(*mut client) -> ()),
9500                arity: 3 as libc::c_int,
9501                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
9502                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9503                    as uint64_t,
9504                key_specs_static: [
9505                    {
9506                        let mut init = keySpec {
9507                            notes: 0 as *const libc::c_char,
9508                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9509                                as uint64_t,
9510                            begin_search_type: KSPEC_BS_INDEX,
9511                            bs: C2RustUnnamed_3 {
9512                                index: {
9513                                    let mut init = C2RustUnnamed_5 {
9514                                        pos: 2 as libc::c_int,
9515                                    };
9516                                    init
9517                                },
9518                            },
9519                            find_keys_type: KSPEC_FK_RANGE,
9520                            fk: C2RustUnnamed_0 {
9521                                range: {
9522                                    let mut init = C2RustUnnamed_2 {
9523                                        lastkey: 0 as libc::c_int,
9524                                        keystep: 1 as libc::c_int,
9525                                        limit: 0 as libc::c_int,
9526                                    };
9527                                    init
9528                                },
9529                            },
9530                        };
9531                        init
9532                    },
9533                    keySpec {
9534                        notes: 0 as *const libc::c_char,
9535                        flags: 0,
9536                        begin_search_type: KSPEC_BS_INVALID,
9537                        bs: C2RustUnnamed_3 {
9538                            index: C2RustUnnamed_5 { pos: 0 },
9539                        },
9540                        find_keys_type: KSPEC_FK_INVALID,
9541                        fk: C2RustUnnamed_0 {
9542                            range: C2RustUnnamed_2 {
9543                                lastkey: 0,
9544                                keystep: 0,
9545                                limit: 0,
9546                            },
9547                        },
9548                    },
9549                    keySpec {
9550                        notes: 0 as *const libc::c_char,
9551                        flags: 0,
9552                        begin_search_type: KSPEC_BS_INVALID,
9553                        bs: C2RustUnnamed_3 {
9554                            index: C2RustUnnamed_5 { pos: 0 },
9555                        },
9556                        find_keys_type: KSPEC_FK_INVALID,
9557                        fk: C2RustUnnamed_0 {
9558                            range: C2RustUnnamed_2 {
9559                                lastkey: 0,
9560                                keystep: 0,
9561                                limit: 0,
9562                            },
9563                        },
9564                    },
9565                    keySpec {
9566                        notes: 0 as *const libc::c_char,
9567                        flags: 0,
9568                        begin_search_type: KSPEC_BS_INVALID,
9569                        bs: C2RustUnnamed_3 {
9570                            index: C2RustUnnamed_5 { pos: 0 },
9571                        },
9572                        find_keys_type: KSPEC_FK_INVALID,
9573                        fk: C2RustUnnamed_0 {
9574                            range: C2RustUnnamed_2 {
9575                                lastkey: 0,
9576                                keystep: 0,
9577                                limit: 0,
9578                            },
9579                        },
9580                    },
9581                ],
9582                getkeys_proc: None,
9583                subcommands: 0 as *const redisCommand as *mut redisCommand,
9584                args: OBJECT_IDLETIME_Args.as_ptr() as *mut _,
9585                microseconds: 0,
9586                calls: 0,
9587                rejected_calls: 0,
9588                failed_calls: 0,
9589                id: 0,
9590                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9591                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9592                key_specs: 0 as *const keySpec as *mut keySpec,
9593                legacy_range_key_spec: keySpec {
9594                    notes: 0 as *const libc::c_char,
9595                    flags: 0,
9596                    begin_search_type: KSPEC_BS_INVALID,
9597                    bs: C2RustUnnamed_3 {
9598                        index: C2RustUnnamed_5 { pos: 0 },
9599                    },
9600                    find_keys_type: KSPEC_FK_INVALID,
9601                    fk: C2RustUnnamed_0 {
9602                        range: C2RustUnnamed_2 {
9603                            lastkey: 0,
9604                            keystep: 0,
9605                            limit: 0,
9606                        },
9607                    },
9608                },
9609                num_args: 0,
9610                num_history: 0,
9611                num_tips: 0,
9612                key_specs_num: 0,
9613                key_specs_max: 0,
9614                subcommands_dict: 0 as *const dict as *mut dict,
9615                parent: 0 as *const redisCommand as *mut redisCommand,
9616                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9617            };
9618            init
9619        },
9620        {
9621            let mut init = redisCommand {
9622                declared_name: b"refcount\0" as *const u8 as *const libc::c_char,
9623                summary: b"Get the number of references to the value of the key\0"
9624                    as *const u8 as *const libc::c_char,
9625                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
9626                since: b"2.2.3\0" as *const u8 as *const libc::c_char,
9627                doc_flags: 0 as libc::c_int,
9628                replaced_by: 0 as *const libc::c_char,
9629                deprecated_since: 0 as *const libc::c_char,
9630                group: COMMAND_GROUP_GENERIC,
9631                history: 0 as *const commandHistory as *mut commandHistory,
9632                tips: OBJECT_REFCOUNT_tips.as_ptr() as *mut _,
9633                proc_0: Some(objectCommand as unsafe extern "C" fn(*mut client) -> ()),
9634                arity: 3 as libc::c_int,
9635                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
9636                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9637                    as uint64_t,
9638                key_specs_static: [
9639                    {
9640                        let mut init = keySpec {
9641                            notes: 0 as *const libc::c_char,
9642                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
9643                                as uint64_t,
9644                            begin_search_type: KSPEC_BS_INDEX,
9645                            bs: C2RustUnnamed_3 {
9646                                index: {
9647                                    let mut init = C2RustUnnamed_5 {
9648                                        pos: 2 as libc::c_int,
9649                                    };
9650                                    init
9651                                },
9652                            },
9653                            find_keys_type: KSPEC_FK_RANGE,
9654                            fk: C2RustUnnamed_0 {
9655                                range: {
9656                                    let mut init = C2RustUnnamed_2 {
9657                                        lastkey: 0 as libc::c_int,
9658                                        keystep: 1 as libc::c_int,
9659                                        limit: 0 as libc::c_int,
9660                                    };
9661                                    init
9662                                },
9663                            },
9664                        };
9665                        init
9666                    },
9667                    keySpec {
9668                        notes: 0 as *const libc::c_char,
9669                        flags: 0,
9670                        begin_search_type: KSPEC_BS_INVALID,
9671                        bs: C2RustUnnamed_3 {
9672                            index: C2RustUnnamed_5 { pos: 0 },
9673                        },
9674                        find_keys_type: KSPEC_FK_INVALID,
9675                        fk: C2RustUnnamed_0 {
9676                            range: C2RustUnnamed_2 {
9677                                lastkey: 0,
9678                                keystep: 0,
9679                                limit: 0,
9680                            },
9681                        },
9682                    },
9683                    keySpec {
9684                        notes: 0 as *const libc::c_char,
9685                        flags: 0,
9686                        begin_search_type: KSPEC_BS_INVALID,
9687                        bs: C2RustUnnamed_3 {
9688                            index: C2RustUnnamed_5 { pos: 0 },
9689                        },
9690                        find_keys_type: KSPEC_FK_INVALID,
9691                        fk: C2RustUnnamed_0 {
9692                            range: C2RustUnnamed_2 {
9693                                lastkey: 0,
9694                                keystep: 0,
9695                                limit: 0,
9696                            },
9697                        },
9698                    },
9699                    keySpec {
9700                        notes: 0 as *const libc::c_char,
9701                        flags: 0,
9702                        begin_search_type: KSPEC_BS_INVALID,
9703                        bs: C2RustUnnamed_3 {
9704                            index: C2RustUnnamed_5 { pos: 0 },
9705                        },
9706                        find_keys_type: KSPEC_FK_INVALID,
9707                        fk: C2RustUnnamed_0 {
9708                            range: C2RustUnnamed_2 {
9709                                lastkey: 0,
9710                                keystep: 0,
9711                                limit: 0,
9712                            },
9713                        },
9714                    },
9715                ],
9716                getkeys_proc: None,
9717                subcommands: 0 as *const redisCommand as *mut redisCommand,
9718                args: OBJECT_REFCOUNT_Args.as_ptr() as *mut _,
9719                microseconds: 0,
9720                calls: 0,
9721                rejected_calls: 0,
9722                failed_calls: 0,
9723                id: 0,
9724                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9725                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9726                key_specs: 0 as *const keySpec as *mut keySpec,
9727                legacy_range_key_spec: keySpec {
9728                    notes: 0 as *const libc::c_char,
9729                    flags: 0,
9730                    begin_search_type: KSPEC_BS_INVALID,
9731                    bs: C2RustUnnamed_3 {
9732                        index: C2RustUnnamed_5 { pos: 0 },
9733                    },
9734                    find_keys_type: KSPEC_FK_INVALID,
9735                    fk: C2RustUnnamed_0 {
9736                        range: C2RustUnnamed_2 {
9737                            lastkey: 0,
9738                            keystep: 0,
9739                            limit: 0,
9740                        },
9741                    },
9742                },
9743                num_args: 0,
9744                num_history: 0,
9745                num_tips: 0,
9746                key_specs_num: 0,
9747                key_specs_max: 0,
9748                subcommands_dict: 0 as *const dict as *mut dict,
9749                parent: 0 as *const redisCommand as *mut redisCommand,
9750                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9751            };
9752            init
9753        },
9754        {
9755            let mut init = redisCommand {
9756                declared_name: 0 as *const libc::c_char,
9757                summary: 0 as *const libc::c_char,
9758                complexity: 0 as *const libc::c_char,
9759                since: 0 as *const libc::c_char,
9760                doc_flags: 0,
9761                replaced_by: 0 as *const libc::c_char,
9762                deprecated_since: 0 as *const libc::c_char,
9763                group: COMMAND_GROUP_GENERIC,
9764                history: 0 as *const commandHistory as *mut commandHistory,
9765                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
9766                proc_0: None,
9767                arity: 0,
9768                flags: 0,
9769                acl_categories: 0,
9770                key_specs_static: [keySpec {
9771                    notes: 0 as *const libc::c_char,
9772                    flags: 0,
9773                    begin_search_type: KSPEC_BS_INVALID,
9774                    bs: C2RustUnnamed_3 {
9775                        index: C2RustUnnamed_5 { pos: 0 },
9776                    },
9777                    find_keys_type: KSPEC_FK_INVALID,
9778                    fk: C2RustUnnamed_0 {
9779                        range: C2RustUnnamed_2 {
9780                            lastkey: 0,
9781                            keystep: 0,
9782                            limit: 0,
9783                        },
9784                    },
9785                }; 4],
9786                getkeys_proc: None,
9787                subcommands: 0 as *const redisCommand as *mut redisCommand,
9788                args: 0 as *const redisCommandArg as *mut redisCommandArg,
9789                microseconds: 0,
9790                calls: 0,
9791                rejected_calls: 0,
9792                failed_calls: 0,
9793                id: 0,
9794                fullname: 0 as *const libc::c_char as *mut libc::c_char,
9795                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
9796                key_specs: 0 as *const keySpec as *mut keySpec,
9797                legacy_range_key_spec: keySpec {
9798                    notes: 0 as *const libc::c_char,
9799                    flags: 0,
9800                    begin_search_type: KSPEC_BS_INVALID,
9801                    bs: C2RustUnnamed_3 {
9802                        index: C2RustUnnamed_5 { pos: 0 },
9803                    },
9804                    find_keys_type: KSPEC_FK_INVALID,
9805                    fk: C2RustUnnamed_0 {
9806                        range: C2RustUnnamed_2 {
9807                            lastkey: 0,
9808                            keystep: 0,
9809                            limit: 0,
9810                        },
9811                    },
9812                },
9813                num_args: 0,
9814                num_history: 0,
9815                num_tips: 0,
9816                key_specs_num: 0,
9817                key_specs_max: 0,
9818                subcommands_dict: 0 as *const dict as *mut dict,
9819                parent: 0 as *const redisCommand as *mut redisCommand,
9820                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
9821            };
9822            init
9823        },
9824    ]
9825};
9826#[no_mangle]
9827pub static mut PERSIST_Args: [redisCommandArg; 2] = [
9828    {
9829        let mut init = redisCommandArg {
9830            name: b"key\0" as *const u8 as *const libc::c_char,
9831            type_0: ARG_TYPE_KEY,
9832            key_spec_index: 0 as libc::c_int,
9833            token: 0 as *const libc::c_char,
9834            summary: 0 as *const libc::c_char,
9835            since: 0 as *const libc::c_char,
9836            flags: 0 as libc::c_int,
9837            deprecated_since: 0 as *const libc::c_char,
9838            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9839            num_args: 0,
9840        };
9841        init
9842    },
9843    {
9844        let mut init = redisCommandArg {
9845            name: 0 as *const libc::c_char,
9846            type_0: ARG_TYPE_STRING,
9847            key_spec_index: 0,
9848            token: 0 as *const libc::c_char,
9849            summary: 0 as *const libc::c_char,
9850            since: 0 as *const libc::c_char,
9851            flags: 0,
9852            deprecated_since: 0 as *const libc::c_char,
9853            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9854            num_args: 0,
9855        };
9856        init
9857    },
9858];
9859#[no_mangle]
9860pub static mut PEXPIRE_History: [commandHistory; 2] = [
9861    {
9862        let mut init = commandHistory {
9863            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
9864            changes: b"Added options: `NX`, `XX`, `GT` and `LT`.\0" as *const u8
9865                as *const libc::c_char,
9866        };
9867        init
9868    },
9869    {
9870        let mut init = commandHistory {
9871            since: 0 as *const libc::c_char,
9872            changes: 0 as *const libc::c_char,
9873        };
9874        init
9875    },
9876];
9877#[no_mangle]
9878pub static mut PEXPIRE_condition_Subargs: [redisCommandArg; 5] = [
9879    {
9880        let mut init = redisCommandArg {
9881            name: b"nx\0" as *const u8 as *const libc::c_char,
9882            type_0: ARG_TYPE_PURE_TOKEN,
9883            key_spec_index: -(1 as libc::c_int),
9884            token: b"NX\0" as *const u8 as *const libc::c_char,
9885            summary: 0 as *const libc::c_char,
9886            since: 0 as *const libc::c_char,
9887            flags: 0 as libc::c_int,
9888            deprecated_since: 0 as *const libc::c_char,
9889            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9890            num_args: 0,
9891        };
9892        init
9893    },
9894    {
9895        let mut init = redisCommandArg {
9896            name: b"xx\0" as *const u8 as *const libc::c_char,
9897            type_0: ARG_TYPE_PURE_TOKEN,
9898            key_spec_index: -(1 as libc::c_int),
9899            token: b"XX\0" as *const u8 as *const libc::c_char,
9900            summary: 0 as *const libc::c_char,
9901            since: 0 as *const libc::c_char,
9902            flags: 0 as libc::c_int,
9903            deprecated_since: 0 as *const libc::c_char,
9904            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9905            num_args: 0,
9906        };
9907        init
9908    },
9909    {
9910        let mut init = redisCommandArg {
9911            name: b"gt\0" as *const u8 as *const libc::c_char,
9912            type_0: ARG_TYPE_PURE_TOKEN,
9913            key_spec_index: -(1 as libc::c_int),
9914            token: b"GT\0" as *const u8 as *const libc::c_char,
9915            summary: 0 as *const libc::c_char,
9916            since: 0 as *const libc::c_char,
9917            flags: 0 as libc::c_int,
9918            deprecated_since: 0 as *const libc::c_char,
9919            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9920            num_args: 0,
9921        };
9922        init
9923    },
9924    {
9925        let mut init = redisCommandArg {
9926            name: b"lt\0" as *const u8 as *const libc::c_char,
9927            type_0: ARG_TYPE_PURE_TOKEN,
9928            key_spec_index: -(1 as libc::c_int),
9929            token: b"LT\0" as *const u8 as *const libc::c_char,
9930            summary: 0 as *const libc::c_char,
9931            since: 0 as *const libc::c_char,
9932            flags: 0 as libc::c_int,
9933            deprecated_since: 0 as *const libc::c_char,
9934            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9935            num_args: 0,
9936        };
9937        init
9938    },
9939    {
9940        let mut init = redisCommandArg {
9941            name: 0 as *const libc::c_char,
9942            type_0: ARG_TYPE_STRING,
9943            key_spec_index: 0,
9944            token: 0 as *const libc::c_char,
9945            summary: 0 as *const libc::c_char,
9946            since: 0 as *const libc::c_char,
9947            flags: 0,
9948            deprecated_since: 0 as *const libc::c_char,
9949            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9950            num_args: 0,
9951        };
9952        init
9953    },
9954];
9955#[no_mangle]
9956pub static mut PEXPIRE_Args: [redisCommandArg; 4] = unsafe {
9957    [
9958        {
9959            let mut init = redisCommandArg {
9960                name: b"key\0" as *const u8 as *const libc::c_char,
9961                type_0: ARG_TYPE_KEY,
9962                key_spec_index: 0 as libc::c_int,
9963                token: 0 as *const libc::c_char,
9964                summary: 0 as *const libc::c_char,
9965                since: 0 as *const libc::c_char,
9966                flags: 0 as libc::c_int,
9967                deprecated_since: 0 as *const libc::c_char,
9968                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9969                num_args: 0,
9970            };
9971            init
9972        },
9973        {
9974            let mut init = redisCommandArg {
9975                name: b"milliseconds\0" as *const u8 as *const libc::c_char,
9976                type_0: ARG_TYPE_INTEGER,
9977                key_spec_index: -(1 as libc::c_int),
9978                token: 0 as *const libc::c_char,
9979                summary: 0 as *const libc::c_char,
9980                since: 0 as *const libc::c_char,
9981                flags: 0 as libc::c_int,
9982                deprecated_since: 0 as *const libc::c_char,
9983                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
9984                num_args: 0,
9985            };
9986            init
9987        },
9988        {
9989            let mut init = redisCommandArg {
9990                name: b"condition\0" as *const u8 as *const libc::c_char,
9991                type_0: ARG_TYPE_ONEOF,
9992                key_spec_index: -(1 as libc::c_int),
9993                token: 0 as *const libc::c_char,
9994                summary: 0 as *const libc::c_char,
9995                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
9996                flags: (1 as libc::c_int) << 0 as libc::c_int,
9997                deprecated_since: 0 as *const libc::c_char,
9998                subargs: PEXPIRE_condition_Subargs.as_ptr() as *mut _,
9999                num_args: 0,
10000            };
10001            init
10002        },
10003        {
10004            let mut init = redisCommandArg {
10005                name: 0 as *const libc::c_char,
10006                type_0: ARG_TYPE_STRING,
10007                key_spec_index: 0,
10008                token: 0 as *const libc::c_char,
10009                summary: 0 as *const libc::c_char,
10010                since: 0 as *const libc::c_char,
10011                flags: 0,
10012                deprecated_since: 0 as *const libc::c_char,
10013                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10014                num_args: 0,
10015            };
10016            init
10017        },
10018    ]
10019};
10020#[no_mangle]
10021pub static mut PEXPIREAT_History: [commandHistory; 2] = [
10022    {
10023        let mut init = commandHistory {
10024            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
10025            changes: b"Added options: `NX`, `XX`, `GT` and `LT`.\0" as *const u8
10026                as *const libc::c_char,
10027        };
10028        init
10029    },
10030    {
10031        let mut init = commandHistory {
10032            since: 0 as *const libc::c_char,
10033            changes: 0 as *const libc::c_char,
10034        };
10035        init
10036    },
10037];
10038#[no_mangle]
10039pub static mut PEXPIREAT_condition_Subargs: [redisCommandArg; 5] = [
10040    {
10041        let mut init = redisCommandArg {
10042            name: b"nx\0" as *const u8 as *const libc::c_char,
10043            type_0: ARG_TYPE_PURE_TOKEN,
10044            key_spec_index: -(1 as libc::c_int),
10045            token: b"NX\0" as *const u8 as *const libc::c_char,
10046            summary: 0 as *const libc::c_char,
10047            since: 0 as *const libc::c_char,
10048            flags: 0 as libc::c_int,
10049            deprecated_since: 0 as *const libc::c_char,
10050            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10051            num_args: 0,
10052        };
10053        init
10054    },
10055    {
10056        let mut init = redisCommandArg {
10057            name: b"xx\0" as *const u8 as *const libc::c_char,
10058            type_0: ARG_TYPE_PURE_TOKEN,
10059            key_spec_index: -(1 as libc::c_int),
10060            token: b"XX\0" as *const u8 as *const libc::c_char,
10061            summary: 0 as *const libc::c_char,
10062            since: 0 as *const libc::c_char,
10063            flags: 0 as libc::c_int,
10064            deprecated_since: 0 as *const libc::c_char,
10065            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10066            num_args: 0,
10067        };
10068        init
10069    },
10070    {
10071        let mut init = redisCommandArg {
10072            name: b"gt\0" as *const u8 as *const libc::c_char,
10073            type_0: ARG_TYPE_PURE_TOKEN,
10074            key_spec_index: -(1 as libc::c_int),
10075            token: b"GT\0" as *const u8 as *const libc::c_char,
10076            summary: 0 as *const libc::c_char,
10077            since: 0 as *const libc::c_char,
10078            flags: 0 as libc::c_int,
10079            deprecated_since: 0 as *const libc::c_char,
10080            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10081            num_args: 0,
10082        };
10083        init
10084    },
10085    {
10086        let mut init = redisCommandArg {
10087            name: b"lt\0" as *const u8 as *const libc::c_char,
10088            type_0: ARG_TYPE_PURE_TOKEN,
10089            key_spec_index: -(1 as libc::c_int),
10090            token: b"LT\0" as *const u8 as *const libc::c_char,
10091            summary: 0 as *const libc::c_char,
10092            since: 0 as *const libc::c_char,
10093            flags: 0 as libc::c_int,
10094            deprecated_since: 0 as *const libc::c_char,
10095            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10096            num_args: 0,
10097        };
10098        init
10099    },
10100    {
10101        let mut init = redisCommandArg {
10102            name: 0 as *const libc::c_char,
10103            type_0: ARG_TYPE_STRING,
10104            key_spec_index: 0,
10105            token: 0 as *const libc::c_char,
10106            summary: 0 as *const libc::c_char,
10107            since: 0 as *const libc::c_char,
10108            flags: 0,
10109            deprecated_since: 0 as *const libc::c_char,
10110            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10111            num_args: 0,
10112        };
10113        init
10114    },
10115];
10116#[no_mangle]
10117pub static mut PEXPIREAT_Args: [redisCommandArg; 4] = unsafe {
10118    [
10119        {
10120            let mut init = redisCommandArg {
10121                name: b"key\0" as *const u8 as *const libc::c_char,
10122                type_0: ARG_TYPE_KEY,
10123                key_spec_index: 0 as libc::c_int,
10124                token: 0 as *const libc::c_char,
10125                summary: 0 as *const libc::c_char,
10126                since: 0 as *const libc::c_char,
10127                flags: 0 as libc::c_int,
10128                deprecated_since: 0 as *const libc::c_char,
10129                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10130                num_args: 0,
10131            };
10132            init
10133        },
10134        {
10135            let mut init = redisCommandArg {
10136                name: b"unix-time-milliseconds\0" as *const u8 as *const libc::c_char,
10137                type_0: ARG_TYPE_UNIX_TIME,
10138                key_spec_index: -(1 as libc::c_int),
10139                token: 0 as *const libc::c_char,
10140                summary: 0 as *const libc::c_char,
10141                since: 0 as *const libc::c_char,
10142                flags: 0 as libc::c_int,
10143                deprecated_since: 0 as *const libc::c_char,
10144                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10145                num_args: 0,
10146            };
10147            init
10148        },
10149        {
10150            let mut init = redisCommandArg {
10151                name: b"condition\0" as *const u8 as *const libc::c_char,
10152                type_0: ARG_TYPE_ONEOF,
10153                key_spec_index: -(1 as libc::c_int),
10154                token: 0 as *const libc::c_char,
10155                summary: 0 as *const libc::c_char,
10156                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
10157                flags: (1 as libc::c_int) << 0 as libc::c_int,
10158                deprecated_since: 0 as *const libc::c_char,
10159                subargs: PEXPIREAT_condition_Subargs.as_ptr() as *mut _,
10160                num_args: 0,
10161            };
10162            init
10163        },
10164        {
10165            let mut init = redisCommandArg {
10166                name: 0 as *const libc::c_char,
10167                type_0: ARG_TYPE_STRING,
10168                key_spec_index: 0,
10169                token: 0 as *const libc::c_char,
10170                summary: 0 as *const libc::c_char,
10171                since: 0 as *const libc::c_char,
10172                flags: 0,
10173                deprecated_since: 0 as *const libc::c_char,
10174                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10175                num_args: 0,
10176            };
10177            init
10178        },
10179    ]
10180};
10181#[no_mangle]
10182pub static mut PEXPIRETIME_Args: [redisCommandArg; 2] = [
10183    {
10184        let mut init = redisCommandArg {
10185            name: b"key\0" as *const u8 as *const libc::c_char,
10186            type_0: ARG_TYPE_KEY,
10187            key_spec_index: 0 as libc::c_int,
10188            token: 0 as *const libc::c_char,
10189            summary: 0 as *const libc::c_char,
10190            since: 0 as *const libc::c_char,
10191            flags: 0 as libc::c_int,
10192            deprecated_since: 0 as *const libc::c_char,
10193            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10194            num_args: 0,
10195        };
10196        init
10197    },
10198    {
10199        let mut init = redisCommandArg {
10200            name: 0 as *const libc::c_char,
10201            type_0: ARG_TYPE_STRING,
10202            key_spec_index: 0,
10203            token: 0 as *const libc::c_char,
10204            summary: 0 as *const libc::c_char,
10205            since: 0 as *const libc::c_char,
10206            flags: 0,
10207            deprecated_since: 0 as *const libc::c_char,
10208            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10209            num_args: 0,
10210        };
10211        init
10212    },
10213];
10214#[no_mangle]
10215pub static mut PTTL_History: [commandHistory; 2] = [
10216    {
10217        let mut init = commandHistory {
10218            since: b"2.8.0\0" as *const u8 as *const libc::c_char,
10219            changes: b"Added the -2 reply.\0" as *const u8 as *const libc::c_char,
10220        };
10221        init
10222    },
10223    {
10224        let mut init = commandHistory {
10225            since: 0 as *const libc::c_char,
10226            changes: 0 as *const libc::c_char,
10227        };
10228        init
10229    },
10230];
10231#[no_mangle]
10232pub static mut PTTL_tips: [*const libc::c_char; 2] = [
10233    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
10234    0 as *const libc::c_char,
10235];
10236#[no_mangle]
10237pub static mut PTTL_Args: [redisCommandArg; 2] = [
10238    {
10239        let mut init = redisCommandArg {
10240            name: b"key\0" as *const u8 as *const libc::c_char,
10241            type_0: ARG_TYPE_KEY,
10242            key_spec_index: 0 as libc::c_int,
10243            token: 0 as *const libc::c_char,
10244            summary: 0 as *const libc::c_char,
10245            since: 0 as *const libc::c_char,
10246            flags: 0 as libc::c_int,
10247            deprecated_since: 0 as *const libc::c_char,
10248            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10249            num_args: 0,
10250        };
10251        init
10252    },
10253    {
10254        let mut init = redisCommandArg {
10255            name: 0 as *const libc::c_char,
10256            type_0: ARG_TYPE_STRING,
10257            key_spec_index: 0,
10258            token: 0 as *const libc::c_char,
10259            summary: 0 as *const libc::c_char,
10260            since: 0 as *const libc::c_char,
10261            flags: 0,
10262            deprecated_since: 0 as *const libc::c_char,
10263            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10264            num_args: 0,
10265        };
10266        init
10267    },
10268];
10269#[no_mangle]
10270pub static mut RANDOMKEY_tips: [*const libc::c_char; 3] = [
10271    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
10272    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
10273    0 as *const libc::c_char,
10274];
10275#[no_mangle]
10276pub static mut RENAME_Args: [redisCommandArg; 3] = [
10277    {
10278        let mut init = redisCommandArg {
10279            name: b"key\0" as *const u8 as *const libc::c_char,
10280            type_0: ARG_TYPE_KEY,
10281            key_spec_index: 0 as libc::c_int,
10282            token: 0 as *const libc::c_char,
10283            summary: 0 as *const libc::c_char,
10284            since: 0 as *const libc::c_char,
10285            flags: 0 as libc::c_int,
10286            deprecated_since: 0 as *const libc::c_char,
10287            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10288            num_args: 0,
10289        };
10290        init
10291    },
10292    {
10293        let mut init = redisCommandArg {
10294            name: b"newkey\0" as *const u8 as *const libc::c_char,
10295            type_0: ARG_TYPE_KEY,
10296            key_spec_index: 1 as libc::c_int,
10297            token: 0 as *const libc::c_char,
10298            summary: 0 as *const libc::c_char,
10299            since: 0 as *const libc::c_char,
10300            flags: 0 as libc::c_int,
10301            deprecated_since: 0 as *const libc::c_char,
10302            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10303            num_args: 0,
10304        };
10305        init
10306    },
10307    {
10308        let mut init = redisCommandArg {
10309            name: 0 as *const libc::c_char,
10310            type_0: ARG_TYPE_STRING,
10311            key_spec_index: 0,
10312            token: 0 as *const libc::c_char,
10313            summary: 0 as *const libc::c_char,
10314            since: 0 as *const libc::c_char,
10315            flags: 0,
10316            deprecated_since: 0 as *const libc::c_char,
10317            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10318            num_args: 0,
10319        };
10320        init
10321    },
10322];
10323#[no_mangle]
10324pub static mut RENAMENX_History: [commandHistory; 2] = [
10325    {
10326        let mut init = commandHistory {
10327            since: b"3.2.0\0" as *const u8 as *const libc::c_char,
10328            changes: b"The command no longer returns an error when source and destination names are the same.\0"
10329                as *const u8 as *const libc::c_char,
10330        };
10331        init
10332    },
10333    {
10334        let mut init = commandHistory {
10335            since: 0 as *const libc::c_char,
10336            changes: 0 as *const libc::c_char,
10337        };
10338        init
10339    },
10340];
10341#[no_mangle]
10342pub static mut RENAMENX_Args: [redisCommandArg; 3] = [
10343    {
10344        let mut init = redisCommandArg {
10345            name: b"key\0" as *const u8 as *const libc::c_char,
10346            type_0: ARG_TYPE_KEY,
10347            key_spec_index: 0 as libc::c_int,
10348            token: 0 as *const libc::c_char,
10349            summary: 0 as *const libc::c_char,
10350            since: 0 as *const libc::c_char,
10351            flags: 0 as libc::c_int,
10352            deprecated_since: 0 as *const libc::c_char,
10353            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10354            num_args: 0,
10355        };
10356        init
10357    },
10358    {
10359        let mut init = redisCommandArg {
10360            name: b"newkey\0" as *const u8 as *const libc::c_char,
10361            type_0: ARG_TYPE_KEY,
10362            key_spec_index: 1 as libc::c_int,
10363            token: 0 as *const libc::c_char,
10364            summary: 0 as *const libc::c_char,
10365            since: 0 as *const libc::c_char,
10366            flags: 0 as libc::c_int,
10367            deprecated_since: 0 as *const libc::c_char,
10368            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10369            num_args: 0,
10370        };
10371        init
10372    },
10373    {
10374        let mut init = redisCommandArg {
10375            name: 0 as *const libc::c_char,
10376            type_0: ARG_TYPE_STRING,
10377            key_spec_index: 0,
10378            token: 0 as *const libc::c_char,
10379            summary: 0 as *const libc::c_char,
10380            since: 0 as *const libc::c_char,
10381            flags: 0,
10382            deprecated_since: 0 as *const libc::c_char,
10383            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10384            num_args: 0,
10385        };
10386        init
10387    },
10388];
10389#[no_mangle]
10390pub static mut RESTORE_History: [commandHistory; 4] = [
10391    {
10392        let mut init = commandHistory {
10393            since: b"3.0.0\0" as *const u8 as *const libc::c_char,
10394            changes: b"Added the `REPLACE` modifier.\0" as *const u8
10395                as *const libc::c_char,
10396        };
10397        init
10398    },
10399    {
10400        let mut init = commandHistory {
10401            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
10402            changes: b"Added the `ABSTTL` modifier.\0" as *const u8
10403                as *const libc::c_char,
10404        };
10405        init
10406    },
10407    {
10408        let mut init = commandHistory {
10409            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
10410            changes: b"Added the `IDLETIME` and `FREQ` options.\0" as *const u8
10411                as *const libc::c_char,
10412        };
10413        init
10414    },
10415    {
10416        let mut init = commandHistory {
10417            since: 0 as *const libc::c_char,
10418            changes: 0 as *const libc::c_char,
10419        };
10420        init
10421    },
10422];
10423#[no_mangle]
10424pub static mut RESTORE_Args: [redisCommandArg; 8] = [
10425    {
10426        let mut init = redisCommandArg {
10427            name: b"key\0" as *const u8 as *const libc::c_char,
10428            type_0: ARG_TYPE_KEY,
10429            key_spec_index: 0 as libc::c_int,
10430            token: 0 as *const libc::c_char,
10431            summary: 0 as *const libc::c_char,
10432            since: 0 as *const libc::c_char,
10433            flags: 0 as libc::c_int,
10434            deprecated_since: 0 as *const libc::c_char,
10435            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10436            num_args: 0,
10437        };
10438        init
10439    },
10440    {
10441        let mut init = redisCommandArg {
10442            name: b"ttl\0" as *const u8 as *const libc::c_char,
10443            type_0: ARG_TYPE_INTEGER,
10444            key_spec_index: -(1 as libc::c_int),
10445            token: 0 as *const libc::c_char,
10446            summary: 0 as *const libc::c_char,
10447            since: 0 as *const libc::c_char,
10448            flags: 0 as libc::c_int,
10449            deprecated_since: 0 as *const libc::c_char,
10450            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10451            num_args: 0,
10452        };
10453        init
10454    },
10455    {
10456        let mut init = redisCommandArg {
10457            name: b"serialized-value\0" as *const u8 as *const libc::c_char,
10458            type_0: ARG_TYPE_STRING,
10459            key_spec_index: -(1 as libc::c_int),
10460            token: 0 as *const libc::c_char,
10461            summary: 0 as *const libc::c_char,
10462            since: 0 as *const libc::c_char,
10463            flags: 0 as libc::c_int,
10464            deprecated_since: 0 as *const libc::c_char,
10465            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10466            num_args: 0,
10467        };
10468        init
10469    },
10470    {
10471        let mut init = redisCommandArg {
10472            name: b"replace\0" as *const u8 as *const libc::c_char,
10473            type_0: ARG_TYPE_PURE_TOKEN,
10474            key_spec_index: -(1 as libc::c_int),
10475            token: b"REPLACE\0" as *const u8 as *const libc::c_char,
10476            summary: 0 as *const libc::c_char,
10477            since: b"3.0.0\0" as *const u8 as *const libc::c_char,
10478            flags: (1 as libc::c_int) << 0 as libc::c_int,
10479            deprecated_since: 0 as *const libc::c_char,
10480            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10481            num_args: 0,
10482        };
10483        init
10484    },
10485    {
10486        let mut init = redisCommandArg {
10487            name: b"absttl\0" as *const u8 as *const libc::c_char,
10488            type_0: ARG_TYPE_PURE_TOKEN,
10489            key_spec_index: -(1 as libc::c_int),
10490            token: b"ABSTTL\0" as *const u8 as *const libc::c_char,
10491            summary: 0 as *const libc::c_char,
10492            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
10493            flags: (1 as libc::c_int) << 0 as libc::c_int,
10494            deprecated_since: 0 as *const libc::c_char,
10495            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10496            num_args: 0,
10497        };
10498        init
10499    },
10500    {
10501        let mut init = redisCommandArg {
10502            name: b"seconds\0" as *const u8 as *const libc::c_char,
10503            type_0: ARG_TYPE_INTEGER,
10504            key_spec_index: -(1 as libc::c_int),
10505            token: b"IDLETIME\0" as *const u8 as *const libc::c_char,
10506            summary: 0 as *const libc::c_char,
10507            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
10508            flags: (1 as libc::c_int) << 0 as libc::c_int,
10509            deprecated_since: 0 as *const libc::c_char,
10510            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10511            num_args: 0,
10512        };
10513        init
10514    },
10515    {
10516        let mut init = redisCommandArg {
10517            name: b"frequency\0" as *const u8 as *const libc::c_char,
10518            type_0: ARG_TYPE_INTEGER,
10519            key_spec_index: -(1 as libc::c_int),
10520            token: b"FREQ\0" as *const u8 as *const libc::c_char,
10521            summary: 0 as *const libc::c_char,
10522            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
10523            flags: (1 as libc::c_int) << 0 as libc::c_int,
10524            deprecated_since: 0 as *const libc::c_char,
10525            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10526            num_args: 0,
10527        };
10528        init
10529    },
10530    {
10531        let mut init = redisCommandArg {
10532            name: 0 as *const libc::c_char,
10533            type_0: ARG_TYPE_STRING,
10534            key_spec_index: 0,
10535            token: 0 as *const libc::c_char,
10536            summary: 0 as *const libc::c_char,
10537            since: 0 as *const libc::c_char,
10538            flags: 0,
10539            deprecated_since: 0 as *const libc::c_char,
10540            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10541            num_args: 0,
10542        };
10543        init
10544    },
10545];
10546#[no_mangle]
10547pub static mut SCAN_History: [commandHistory; 2] = [
10548    {
10549        let mut init = commandHistory {
10550            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
10551            changes: b"Added the `TYPE` subcommand.\0" as *const u8
10552                as *const libc::c_char,
10553        };
10554        init
10555    },
10556    {
10557        let mut init = commandHistory {
10558            since: 0 as *const libc::c_char,
10559            changes: 0 as *const libc::c_char,
10560        };
10561        init
10562    },
10563];
10564#[no_mangle]
10565pub static mut SCAN_tips: [*const libc::c_char; 3] = [
10566    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
10567    b"request_policy:special\0" as *const u8 as *const libc::c_char,
10568    0 as *const libc::c_char,
10569];
10570#[no_mangle]
10571pub static mut SCAN_Args: [redisCommandArg; 5] = [
10572    {
10573        let mut init = redisCommandArg {
10574            name: b"cursor\0" as *const u8 as *const libc::c_char,
10575            type_0: ARG_TYPE_INTEGER,
10576            key_spec_index: -(1 as libc::c_int),
10577            token: 0 as *const libc::c_char,
10578            summary: 0 as *const libc::c_char,
10579            since: 0 as *const libc::c_char,
10580            flags: 0 as libc::c_int,
10581            deprecated_since: 0 as *const libc::c_char,
10582            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10583            num_args: 0,
10584        };
10585        init
10586    },
10587    {
10588        let mut init = redisCommandArg {
10589            name: b"pattern\0" as *const u8 as *const libc::c_char,
10590            type_0: ARG_TYPE_PATTERN,
10591            key_spec_index: -(1 as libc::c_int),
10592            token: b"MATCH\0" as *const u8 as *const libc::c_char,
10593            summary: 0 as *const libc::c_char,
10594            since: 0 as *const libc::c_char,
10595            flags: (1 as libc::c_int) << 0 as libc::c_int,
10596            deprecated_since: 0 as *const libc::c_char,
10597            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10598            num_args: 0,
10599        };
10600        init
10601    },
10602    {
10603        let mut init = redisCommandArg {
10604            name: b"count\0" as *const u8 as *const libc::c_char,
10605            type_0: ARG_TYPE_INTEGER,
10606            key_spec_index: -(1 as libc::c_int),
10607            token: b"COUNT\0" as *const u8 as *const libc::c_char,
10608            summary: 0 as *const libc::c_char,
10609            since: 0 as *const libc::c_char,
10610            flags: (1 as libc::c_int) << 0 as libc::c_int,
10611            deprecated_since: 0 as *const libc::c_char,
10612            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10613            num_args: 0,
10614        };
10615        init
10616    },
10617    {
10618        let mut init = redisCommandArg {
10619            name: b"type\0" as *const u8 as *const libc::c_char,
10620            type_0: ARG_TYPE_STRING,
10621            key_spec_index: -(1 as libc::c_int),
10622            token: b"TYPE\0" as *const u8 as *const libc::c_char,
10623            summary: 0 as *const libc::c_char,
10624            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
10625            flags: (1 as libc::c_int) << 0 as libc::c_int,
10626            deprecated_since: 0 as *const libc::c_char,
10627            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10628            num_args: 0,
10629        };
10630        init
10631    },
10632    {
10633        let mut init = redisCommandArg {
10634            name: 0 as *const libc::c_char,
10635            type_0: ARG_TYPE_STRING,
10636            key_spec_index: 0,
10637            token: 0 as *const libc::c_char,
10638            summary: 0 as *const libc::c_char,
10639            since: 0 as *const libc::c_char,
10640            flags: 0,
10641            deprecated_since: 0 as *const libc::c_char,
10642            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10643            num_args: 0,
10644        };
10645        init
10646    },
10647];
10648#[no_mangle]
10649pub static mut SORT_offset_count_Subargs: [redisCommandArg; 3] = [
10650    {
10651        let mut init = redisCommandArg {
10652            name: b"offset\0" as *const u8 as *const libc::c_char,
10653            type_0: ARG_TYPE_INTEGER,
10654            key_spec_index: -(1 as libc::c_int),
10655            token: 0 as *const libc::c_char,
10656            summary: 0 as *const libc::c_char,
10657            since: 0 as *const libc::c_char,
10658            flags: 0 as libc::c_int,
10659            deprecated_since: 0 as *const libc::c_char,
10660            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10661            num_args: 0,
10662        };
10663        init
10664    },
10665    {
10666        let mut init = redisCommandArg {
10667            name: b"count\0" as *const u8 as *const libc::c_char,
10668            type_0: ARG_TYPE_INTEGER,
10669            key_spec_index: -(1 as libc::c_int),
10670            token: 0 as *const libc::c_char,
10671            summary: 0 as *const libc::c_char,
10672            since: 0 as *const libc::c_char,
10673            flags: 0 as libc::c_int,
10674            deprecated_since: 0 as *const libc::c_char,
10675            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10676            num_args: 0,
10677        };
10678        init
10679    },
10680    {
10681        let mut init = redisCommandArg {
10682            name: 0 as *const libc::c_char,
10683            type_0: ARG_TYPE_STRING,
10684            key_spec_index: 0,
10685            token: 0 as *const libc::c_char,
10686            summary: 0 as *const libc::c_char,
10687            since: 0 as *const libc::c_char,
10688            flags: 0,
10689            deprecated_since: 0 as *const libc::c_char,
10690            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10691            num_args: 0,
10692        };
10693        init
10694    },
10695];
10696#[no_mangle]
10697pub static mut SORT_order_Subargs: [redisCommandArg; 3] = [
10698    {
10699        let mut init = redisCommandArg {
10700            name: b"asc\0" as *const u8 as *const libc::c_char,
10701            type_0: ARG_TYPE_PURE_TOKEN,
10702            key_spec_index: -(1 as libc::c_int),
10703            token: b"ASC\0" as *const u8 as *const libc::c_char,
10704            summary: 0 as *const libc::c_char,
10705            since: 0 as *const libc::c_char,
10706            flags: 0 as libc::c_int,
10707            deprecated_since: 0 as *const libc::c_char,
10708            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10709            num_args: 0,
10710        };
10711        init
10712    },
10713    {
10714        let mut init = redisCommandArg {
10715            name: b"desc\0" as *const u8 as *const libc::c_char,
10716            type_0: ARG_TYPE_PURE_TOKEN,
10717            key_spec_index: -(1 as libc::c_int),
10718            token: b"DESC\0" as *const u8 as *const libc::c_char,
10719            summary: 0 as *const libc::c_char,
10720            since: 0 as *const libc::c_char,
10721            flags: 0 as libc::c_int,
10722            deprecated_since: 0 as *const libc::c_char,
10723            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10724            num_args: 0,
10725        };
10726        init
10727    },
10728    {
10729        let mut init = redisCommandArg {
10730            name: 0 as *const libc::c_char,
10731            type_0: ARG_TYPE_STRING,
10732            key_spec_index: 0,
10733            token: 0 as *const libc::c_char,
10734            summary: 0 as *const libc::c_char,
10735            since: 0 as *const libc::c_char,
10736            flags: 0,
10737            deprecated_since: 0 as *const libc::c_char,
10738            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10739            num_args: 0,
10740        };
10741        init
10742    },
10743];
10744#[no_mangle]
10745pub static mut SORT_Args: [redisCommandArg; 8] = unsafe {
10746    [
10747        {
10748            let mut init = redisCommandArg {
10749                name: b"key\0" as *const u8 as *const libc::c_char,
10750                type_0: ARG_TYPE_KEY,
10751                key_spec_index: 0 as libc::c_int,
10752                token: 0 as *const libc::c_char,
10753                summary: 0 as *const libc::c_char,
10754                since: 0 as *const libc::c_char,
10755                flags: 0 as libc::c_int,
10756                deprecated_since: 0 as *const libc::c_char,
10757                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10758                num_args: 0,
10759            };
10760            init
10761        },
10762        {
10763            let mut init = redisCommandArg {
10764                name: b"pattern\0" as *const u8 as *const libc::c_char,
10765                type_0: ARG_TYPE_PATTERN,
10766                key_spec_index: 1 as libc::c_int,
10767                token: b"BY\0" as *const u8 as *const libc::c_char,
10768                summary: 0 as *const libc::c_char,
10769                since: 0 as *const libc::c_char,
10770                flags: (1 as libc::c_int) << 0 as libc::c_int,
10771                deprecated_since: 0 as *const libc::c_char,
10772                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10773                num_args: 0,
10774            };
10775            init
10776        },
10777        {
10778            let mut init = redisCommandArg {
10779                name: b"offset_count\0" as *const u8 as *const libc::c_char,
10780                type_0: ARG_TYPE_BLOCK,
10781                key_spec_index: -(1 as libc::c_int),
10782                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
10783                summary: 0 as *const libc::c_char,
10784                since: 0 as *const libc::c_char,
10785                flags: (1 as libc::c_int) << 0 as libc::c_int,
10786                deprecated_since: 0 as *const libc::c_char,
10787                subargs: SORT_offset_count_Subargs.as_ptr() as *mut _,
10788                num_args: 0,
10789            };
10790            init
10791        },
10792        {
10793            let mut init = redisCommandArg {
10794                name: b"pattern\0" as *const u8 as *const libc::c_char,
10795                type_0: ARG_TYPE_PATTERN,
10796                key_spec_index: 1 as libc::c_int,
10797                token: b"GET\0" as *const u8 as *const libc::c_char,
10798                summary: 0 as *const libc::c_char,
10799                since: 0 as *const libc::c_char,
10800                flags: (1 as libc::c_int) << 0 as libc::c_int
10801                    | (1 as libc::c_int) << 1 as libc::c_int
10802                    | (1 as libc::c_int) << 2 as libc::c_int,
10803                deprecated_since: 0 as *const libc::c_char,
10804                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10805                num_args: 0,
10806            };
10807            init
10808        },
10809        {
10810            let mut init = redisCommandArg {
10811                name: b"order\0" as *const u8 as *const libc::c_char,
10812                type_0: ARG_TYPE_ONEOF,
10813                key_spec_index: -(1 as libc::c_int),
10814                token: 0 as *const libc::c_char,
10815                summary: 0 as *const libc::c_char,
10816                since: 0 as *const libc::c_char,
10817                flags: (1 as libc::c_int) << 0 as libc::c_int,
10818                deprecated_since: 0 as *const libc::c_char,
10819                subargs: SORT_order_Subargs.as_ptr() as *mut _,
10820                num_args: 0,
10821            };
10822            init
10823        },
10824        {
10825            let mut init = redisCommandArg {
10826                name: b"sorting\0" as *const u8 as *const libc::c_char,
10827                type_0: ARG_TYPE_PURE_TOKEN,
10828                key_spec_index: -(1 as libc::c_int),
10829                token: b"ALPHA\0" as *const u8 as *const libc::c_char,
10830                summary: 0 as *const libc::c_char,
10831                since: 0 as *const libc::c_char,
10832                flags: (1 as libc::c_int) << 0 as libc::c_int,
10833                deprecated_since: 0 as *const libc::c_char,
10834                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10835                num_args: 0,
10836            };
10837            init
10838        },
10839        {
10840            let mut init = redisCommandArg {
10841                name: b"destination\0" as *const u8 as *const libc::c_char,
10842                type_0: ARG_TYPE_KEY,
10843                key_spec_index: 2 as libc::c_int,
10844                token: b"STORE\0" as *const u8 as *const libc::c_char,
10845                summary: 0 as *const libc::c_char,
10846                since: 0 as *const libc::c_char,
10847                flags: (1 as libc::c_int) << 0 as libc::c_int,
10848                deprecated_since: 0 as *const libc::c_char,
10849                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10850                num_args: 0,
10851            };
10852            init
10853        },
10854        {
10855            let mut init = redisCommandArg {
10856                name: 0 as *const libc::c_char,
10857                type_0: ARG_TYPE_STRING,
10858                key_spec_index: 0,
10859                token: 0 as *const libc::c_char,
10860                summary: 0 as *const libc::c_char,
10861                since: 0 as *const libc::c_char,
10862                flags: 0,
10863                deprecated_since: 0 as *const libc::c_char,
10864                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10865                num_args: 0,
10866            };
10867            init
10868        },
10869    ]
10870};
10871#[no_mangle]
10872pub static mut SORT_RO_offset_count_Subargs: [redisCommandArg; 3] = [
10873    {
10874        let mut init = redisCommandArg {
10875            name: b"offset\0" as *const u8 as *const libc::c_char,
10876            type_0: ARG_TYPE_INTEGER,
10877            key_spec_index: -(1 as libc::c_int),
10878            token: 0 as *const libc::c_char,
10879            summary: 0 as *const libc::c_char,
10880            since: 0 as *const libc::c_char,
10881            flags: 0 as libc::c_int,
10882            deprecated_since: 0 as *const libc::c_char,
10883            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10884            num_args: 0,
10885        };
10886        init
10887    },
10888    {
10889        let mut init = redisCommandArg {
10890            name: b"count\0" as *const u8 as *const libc::c_char,
10891            type_0: ARG_TYPE_INTEGER,
10892            key_spec_index: -(1 as libc::c_int),
10893            token: 0 as *const libc::c_char,
10894            summary: 0 as *const libc::c_char,
10895            since: 0 as *const libc::c_char,
10896            flags: 0 as libc::c_int,
10897            deprecated_since: 0 as *const libc::c_char,
10898            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10899            num_args: 0,
10900        };
10901        init
10902    },
10903    {
10904        let mut init = redisCommandArg {
10905            name: 0 as *const libc::c_char,
10906            type_0: ARG_TYPE_STRING,
10907            key_spec_index: 0,
10908            token: 0 as *const libc::c_char,
10909            summary: 0 as *const libc::c_char,
10910            since: 0 as *const libc::c_char,
10911            flags: 0,
10912            deprecated_since: 0 as *const libc::c_char,
10913            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10914            num_args: 0,
10915        };
10916        init
10917    },
10918];
10919#[no_mangle]
10920pub static mut SORT_RO_order_Subargs: [redisCommandArg; 3] = [
10921    {
10922        let mut init = redisCommandArg {
10923            name: b"asc\0" as *const u8 as *const libc::c_char,
10924            type_0: ARG_TYPE_PURE_TOKEN,
10925            key_spec_index: -(1 as libc::c_int),
10926            token: b"ASC\0" as *const u8 as *const libc::c_char,
10927            summary: 0 as *const libc::c_char,
10928            since: 0 as *const libc::c_char,
10929            flags: 0 as libc::c_int,
10930            deprecated_since: 0 as *const libc::c_char,
10931            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10932            num_args: 0,
10933        };
10934        init
10935    },
10936    {
10937        let mut init = redisCommandArg {
10938            name: b"desc\0" as *const u8 as *const libc::c_char,
10939            type_0: ARG_TYPE_PURE_TOKEN,
10940            key_spec_index: -(1 as libc::c_int),
10941            token: b"DESC\0" as *const u8 as *const libc::c_char,
10942            summary: 0 as *const libc::c_char,
10943            since: 0 as *const libc::c_char,
10944            flags: 0 as libc::c_int,
10945            deprecated_since: 0 as *const libc::c_char,
10946            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10947            num_args: 0,
10948        };
10949        init
10950    },
10951    {
10952        let mut init = redisCommandArg {
10953            name: 0 as *const libc::c_char,
10954            type_0: ARG_TYPE_STRING,
10955            key_spec_index: 0,
10956            token: 0 as *const libc::c_char,
10957            summary: 0 as *const libc::c_char,
10958            since: 0 as *const libc::c_char,
10959            flags: 0,
10960            deprecated_since: 0 as *const libc::c_char,
10961            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10962            num_args: 0,
10963        };
10964        init
10965    },
10966];
10967#[no_mangle]
10968pub static mut SORT_RO_Args: [redisCommandArg; 7] = unsafe {
10969    [
10970        {
10971            let mut init = redisCommandArg {
10972                name: b"key\0" as *const u8 as *const libc::c_char,
10973                type_0: ARG_TYPE_KEY,
10974                key_spec_index: 0 as libc::c_int,
10975                token: 0 as *const libc::c_char,
10976                summary: 0 as *const libc::c_char,
10977                since: 0 as *const libc::c_char,
10978                flags: 0 as libc::c_int,
10979                deprecated_since: 0 as *const libc::c_char,
10980                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10981                num_args: 0,
10982            };
10983            init
10984        },
10985        {
10986            let mut init = redisCommandArg {
10987                name: b"pattern\0" as *const u8 as *const libc::c_char,
10988                type_0: ARG_TYPE_PATTERN,
10989                key_spec_index: 1 as libc::c_int,
10990                token: b"BY\0" as *const u8 as *const libc::c_char,
10991                summary: 0 as *const libc::c_char,
10992                since: 0 as *const libc::c_char,
10993                flags: (1 as libc::c_int) << 0 as libc::c_int,
10994                deprecated_since: 0 as *const libc::c_char,
10995                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
10996                num_args: 0,
10997            };
10998            init
10999        },
11000        {
11001            let mut init = redisCommandArg {
11002                name: b"offset_count\0" as *const u8 as *const libc::c_char,
11003                type_0: ARG_TYPE_BLOCK,
11004                key_spec_index: -(1 as libc::c_int),
11005                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
11006                summary: 0 as *const libc::c_char,
11007                since: 0 as *const libc::c_char,
11008                flags: (1 as libc::c_int) << 0 as libc::c_int,
11009                deprecated_since: 0 as *const libc::c_char,
11010                subargs: SORT_RO_offset_count_Subargs.as_ptr() as *mut _,
11011                num_args: 0,
11012            };
11013            init
11014        },
11015        {
11016            let mut init = redisCommandArg {
11017                name: b"pattern\0" as *const u8 as *const libc::c_char,
11018                type_0: ARG_TYPE_PATTERN,
11019                key_spec_index: 1 as libc::c_int,
11020                token: b"GET\0" as *const u8 as *const libc::c_char,
11021                summary: 0 as *const libc::c_char,
11022                since: 0 as *const libc::c_char,
11023                flags: (1 as libc::c_int) << 0 as libc::c_int
11024                    | (1 as libc::c_int) << 1 as libc::c_int
11025                    | (1 as libc::c_int) << 2 as libc::c_int,
11026                deprecated_since: 0 as *const libc::c_char,
11027                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11028                num_args: 0,
11029            };
11030            init
11031        },
11032        {
11033            let mut init = redisCommandArg {
11034                name: b"order\0" as *const u8 as *const libc::c_char,
11035                type_0: ARG_TYPE_ONEOF,
11036                key_spec_index: -(1 as libc::c_int),
11037                token: 0 as *const libc::c_char,
11038                summary: 0 as *const libc::c_char,
11039                since: 0 as *const libc::c_char,
11040                flags: (1 as libc::c_int) << 0 as libc::c_int,
11041                deprecated_since: 0 as *const libc::c_char,
11042                subargs: SORT_RO_order_Subargs.as_ptr() as *mut _,
11043                num_args: 0,
11044            };
11045            init
11046        },
11047        {
11048            let mut init = redisCommandArg {
11049                name: b"sorting\0" as *const u8 as *const libc::c_char,
11050                type_0: ARG_TYPE_PURE_TOKEN,
11051                key_spec_index: -(1 as libc::c_int),
11052                token: b"ALPHA\0" as *const u8 as *const libc::c_char,
11053                summary: 0 as *const libc::c_char,
11054                since: 0 as *const libc::c_char,
11055                flags: (1 as libc::c_int) << 0 as libc::c_int,
11056                deprecated_since: 0 as *const libc::c_char,
11057                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11058                num_args: 0,
11059            };
11060            init
11061        },
11062        {
11063            let mut init = redisCommandArg {
11064                name: 0 as *const libc::c_char,
11065                type_0: ARG_TYPE_STRING,
11066                key_spec_index: 0,
11067                token: 0 as *const libc::c_char,
11068                summary: 0 as *const libc::c_char,
11069                since: 0 as *const libc::c_char,
11070                flags: 0,
11071                deprecated_since: 0 as *const libc::c_char,
11072                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11073                num_args: 0,
11074            };
11075            init
11076        },
11077    ]
11078};
11079#[no_mangle]
11080pub static mut TOUCH_tips: [*const libc::c_char; 3] = [
11081    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
11082    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
11083    0 as *const libc::c_char,
11084];
11085#[no_mangle]
11086pub static mut TOUCH_Args: [redisCommandArg; 2] = [
11087    {
11088        let mut init = redisCommandArg {
11089            name: b"key\0" as *const u8 as *const libc::c_char,
11090            type_0: ARG_TYPE_KEY,
11091            key_spec_index: 0 as libc::c_int,
11092            token: 0 as *const libc::c_char,
11093            summary: 0 as *const libc::c_char,
11094            since: 0 as *const libc::c_char,
11095            flags: (1 as libc::c_int) << 1 as libc::c_int,
11096            deprecated_since: 0 as *const libc::c_char,
11097            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11098            num_args: 0,
11099        };
11100        init
11101    },
11102    {
11103        let mut init = redisCommandArg {
11104            name: 0 as *const libc::c_char,
11105            type_0: ARG_TYPE_STRING,
11106            key_spec_index: 0,
11107            token: 0 as *const libc::c_char,
11108            summary: 0 as *const libc::c_char,
11109            since: 0 as *const libc::c_char,
11110            flags: 0,
11111            deprecated_since: 0 as *const libc::c_char,
11112            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11113            num_args: 0,
11114        };
11115        init
11116    },
11117];
11118#[no_mangle]
11119pub static mut TTL_History: [commandHistory; 2] = [
11120    {
11121        let mut init = commandHistory {
11122            since: b"2.8.0\0" as *const u8 as *const libc::c_char,
11123            changes: b"Added the -2 reply.\0" as *const u8 as *const libc::c_char,
11124        };
11125        init
11126    },
11127    {
11128        let mut init = commandHistory {
11129            since: 0 as *const libc::c_char,
11130            changes: 0 as *const libc::c_char,
11131        };
11132        init
11133    },
11134];
11135#[no_mangle]
11136pub static mut TTL_tips: [*const libc::c_char; 2] = [
11137    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
11138    0 as *const libc::c_char,
11139];
11140#[no_mangle]
11141pub static mut TTL_Args: [redisCommandArg; 2] = [
11142    {
11143        let mut init = redisCommandArg {
11144            name: b"key\0" as *const u8 as *const libc::c_char,
11145            type_0: ARG_TYPE_KEY,
11146            key_spec_index: 0 as libc::c_int,
11147            token: 0 as *const libc::c_char,
11148            summary: 0 as *const libc::c_char,
11149            since: 0 as *const libc::c_char,
11150            flags: 0 as libc::c_int,
11151            deprecated_since: 0 as *const libc::c_char,
11152            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11153            num_args: 0,
11154        };
11155        init
11156    },
11157    {
11158        let mut init = redisCommandArg {
11159            name: 0 as *const libc::c_char,
11160            type_0: ARG_TYPE_STRING,
11161            key_spec_index: 0,
11162            token: 0 as *const libc::c_char,
11163            summary: 0 as *const libc::c_char,
11164            since: 0 as *const libc::c_char,
11165            flags: 0,
11166            deprecated_since: 0 as *const libc::c_char,
11167            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11168            num_args: 0,
11169        };
11170        init
11171    },
11172];
11173#[no_mangle]
11174pub static mut TYPE_Args: [redisCommandArg; 2] = [
11175    {
11176        let mut init = redisCommandArg {
11177            name: b"key\0" as *const u8 as *const libc::c_char,
11178            type_0: ARG_TYPE_KEY,
11179            key_spec_index: 0 as libc::c_int,
11180            token: 0 as *const libc::c_char,
11181            summary: 0 as *const libc::c_char,
11182            since: 0 as *const libc::c_char,
11183            flags: 0 as libc::c_int,
11184            deprecated_since: 0 as *const libc::c_char,
11185            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11186            num_args: 0,
11187        };
11188        init
11189    },
11190    {
11191        let mut init = redisCommandArg {
11192            name: 0 as *const libc::c_char,
11193            type_0: ARG_TYPE_STRING,
11194            key_spec_index: 0,
11195            token: 0 as *const libc::c_char,
11196            summary: 0 as *const libc::c_char,
11197            since: 0 as *const libc::c_char,
11198            flags: 0,
11199            deprecated_since: 0 as *const libc::c_char,
11200            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11201            num_args: 0,
11202        };
11203        init
11204    },
11205];
11206#[no_mangle]
11207pub static mut UNLINK_tips: [*const libc::c_char; 3] = [
11208    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
11209    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
11210    0 as *const libc::c_char,
11211];
11212#[no_mangle]
11213pub static mut UNLINK_Args: [redisCommandArg; 2] = [
11214    {
11215        let mut init = redisCommandArg {
11216            name: b"key\0" as *const u8 as *const libc::c_char,
11217            type_0: ARG_TYPE_KEY,
11218            key_spec_index: 0 as libc::c_int,
11219            token: 0 as *const libc::c_char,
11220            summary: 0 as *const libc::c_char,
11221            since: 0 as *const libc::c_char,
11222            flags: (1 as libc::c_int) << 1 as libc::c_int,
11223            deprecated_since: 0 as *const libc::c_char,
11224            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11225            num_args: 0,
11226        };
11227        init
11228    },
11229    {
11230        let mut init = redisCommandArg {
11231            name: 0 as *const libc::c_char,
11232            type_0: ARG_TYPE_STRING,
11233            key_spec_index: 0,
11234            token: 0 as *const libc::c_char,
11235            summary: 0 as *const libc::c_char,
11236            since: 0 as *const libc::c_char,
11237            flags: 0,
11238            deprecated_since: 0 as *const libc::c_char,
11239            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11240            num_args: 0,
11241        };
11242        init
11243    },
11244];
11245#[no_mangle]
11246pub static mut WAIT_tips: [*const libc::c_char; 3] = [
11247    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
11248    b"response_policy:agg_min\0" as *const u8 as *const libc::c_char,
11249    0 as *const libc::c_char,
11250];
11251#[no_mangle]
11252pub static mut WAIT_Args: [redisCommandArg; 3] = [
11253    {
11254        let mut init = redisCommandArg {
11255            name: b"numreplicas\0" as *const u8 as *const libc::c_char,
11256            type_0: ARG_TYPE_INTEGER,
11257            key_spec_index: -(1 as libc::c_int),
11258            token: 0 as *const libc::c_char,
11259            summary: 0 as *const libc::c_char,
11260            since: 0 as *const libc::c_char,
11261            flags: 0 as libc::c_int,
11262            deprecated_since: 0 as *const libc::c_char,
11263            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11264            num_args: 0,
11265        };
11266        init
11267    },
11268    {
11269        let mut init = redisCommandArg {
11270            name: b"timeout\0" as *const u8 as *const libc::c_char,
11271            type_0: ARG_TYPE_INTEGER,
11272            key_spec_index: -(1 as libc::c_int),
11273            token: 0 as *const libc::c_char,
11274            summary: 0 as *const libc::c_char,
11275            since: 0 as *const libc::c_char,
11276            flags: 0 as libc::c_int,
11277            deprecated_since: 0 as *const libc::c_char,
11278            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11279            num_args: 0,
11280        };
11281        init
11282    },
11283    {
11284        let mut init = redisCommandArg {
11285            name: 0 as *const libc::c_char,
11286            type_0: ARG_TYPE_STRING,
11287            key_spec_index: 0,
11288            token: 0 as *const libc::c_char,
11289            summary: 0 as *const libc::c_char,
11290            since: 0 as *const libc::c_char,
11291            flags: 0,
11292            deprecated_since: 0 as *const libc::c_char,
11293            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11294            num_args: 0,
11295        };
11296        init
11297    },
11298];
11299#[no_mangle]
11300pub static mut GEOADD_History: [commandHistory; 2] = [
11301    {
11302        let mut init = commandHistory {
11303            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
11304            changes: b"Added the `CH`, `NX` and `XX` options.\0" as *const u8
11305                as *const libc::c_char,
11306        };
11307        init
11308    },
11309    {
11310        let mut init = commandHistory {
11311            since: 0 as *const libc::c_char,
11312            changes: 0 as *const libc::c_char,
11313        };
11314        init
11315    },
11316];
11317#[no_mangle]
11318pub static mut GEOADD_condition_Subargs: [redisCommandArg; 3] = [
11319    {
11320        let mut init = redisCommandArg {
11321            name: b"nx\0" as *const u8 as *const libc::c_char,
11322            type_0: ARG_TYPE_PURE_TOKEN,
11323            key_spec_index: -(1 as libc::c_int),
11324            token: b"NX\0" as *const u8 as *const libc::c_char,
11325            summary: 0 as *const libc::c_char,
11326            since: 0 as *const libc::c_char,
11327            flags: 0 as libc::c_int,
11328            deprecated_since: 0 as *const libc::c_char,
11329            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11330            num_args: 0,
11331        };
11332        init
11333    },
11334    {
11335        let mut init = redisCommandArg {
11336            name: b"xx\0" as *const u8 as *const libc::c_char,
11337            type_0: ARG_TYPE_PURE_TOKEN,
11338            key_spec_index: -(1 as libc::c_int),
11339            token: b"XX\0" as *const u8 as *const libc::c_char,
11340            summary: 0 as *const libc::c_char,
11341            since: 0 as *const libc::c_char,
11342            flags: 0 as libc::c_int,
11343            deprecated_since: 0 as *const libc::c_char,
11344            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11345            num_args: 0,
11346        };
11347        init
11348    },
11349    {
11350        let mut init = redisCommandArg {
11351            name: 0 as *const libc::c_char,
11352            type_0: ARG_TYPE_STRING,
11353            key_spec_index: 0,
11354            token: 0 as *const libc::c_char,
11355            summary: 0 as *const libc::c_char,
11356            since: 0 as *const libc::c_char,
11357            flags: 0,
11358            deprecated_since: 0 as *const libc::c_char,
11359            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11360            num_args: 0,
11361        };
11362        init
11363    },
11364];
11365#[no_mangle]
11366pub static mut GEOADD_longitude_latitude_member_Subargs: [redisCommandArg; 4] = [
11367    {
11368        let mut init = redisCommandArg {
11369            name: b"longitude\0" as *const u8 as *const libc::c_char,
11370            type_0: ARG_TYPE_DOUBLE,
11371            key_spec_index: -(1 as libc::c_int),
11372            token: 0 as *const libc::c_char,
11373            summary: 0 as *const libc::c_char,
11374            since: 0 as *const libc::c_char,
11375            flags: 0 as libc::c_int,
11376            deprecated_since: 0 as *const libc::c_char,
11377            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11378            num_args: 0,
11379        };
11380        init
11381    },
11382    {
11383        let mut init = redisCommandArg {
11384            name: b"latitude\0" as *const u8 as *const libc::c_char,
11385            type_0: ARG_TYPE_DOUBLE,
11386            key_spec_index: -(1 as libc::c_int),
11387            token: 0 as *const libc::c_char,
11388            summary: 0 as *const libc::c_char,
11389            since: 0 as *const libc::c_char,
11390            flags: 0 as libc::c_int,
11391            deprecated_since: 0 as *const libc::c_char,
11392            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11393            num_args: 0,
11394        };
11395        init
11396    },
11397    {
11398        let mut init = redisCommandArg {
11399            name: b"member\0" as *const u8 as *const libc::c_char,
11400            type_0: ARG_TYPE_STRING,
11401            key_spec_index: -(1 as libc::c_int),
11402            token: 0 as *const libc::c_char,
11403            summary: 0 as *const libc::c_char,
11404            since: 0 as *const libc::c_char,
11405            flags: 0 as libc::c_int,
11406            deprecated_since: 0 as *const libc::c_char,
11407            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11408            num_args: 0,
11409        };
11410        init
11411    },
11412    {
11413        let mut init = redisCommandArg {
11414            name: 0 as *const libc::c_char,
11415            type_0: ARG_TYPE_STRING,
11416            key_spec_index: 0,
11417            token: 0 as *const libc::c_char,
11418            summary: 0 as *const libc::c_char,
11419            since: 0 as *const libc::c_char,
11420            flags: 0,
11421            deprecated_since: 0 as *const libc::c_char,
11422            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11423            num_args: 0,
11424        };
11425        init
11426    },
11427];
11428#[no_mangle]
11429pub static mut GEOADD_Args: [redisCommandArg; 5] = unsafe {
11430    [
11431        {
11432            let mut init = redisCommandArg {
11433                name: b"key\0" as *const u8 as *const libc::c_char,
11434                type_0: ARG_TYPE_KEY,
11435                key_spec_index: 0 as libc::c_int,
11436                token: 0 as *const libc::c_char,
11437                summary: 0 as *const libc::c_char,
11438                since: 0 as *const libc::c_char,
11439                flags: 0 as libc::c_int,
11440                deprecated_since: 0 as *const libc::c_char,
11441                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11442                num_args: 0,
11443            };
11444            init
11445        },
11446        {
11447            let mut init = redisCommandArg {
11448                name: b"condition\0" as *const u8 as *const libc::c_char,
11449                type_0: ARG_TYPE_ONEOF,
11450                key_spec_index: -(1 as libc::c_int),
11451                token: 0 as *const libc::c_char,
11452                summary: 0 as *const libc::c_char,
11453                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
11454                flags: (1 as libc::c_int) << 0 as libc::c_int,
11455                deprecated_since: 0 as *const libc::c_char,
11456                subargs: GEOADD_condition_Subargs.as_ptr() as *mut _,
11457                num_args: 0,
11458            };
11459            init
11460        },
11461        {
11462            let mut init = redisCommandArg {
11463                name: b"change\0" as *const u8 as *const libc::c_char,
11464                type_0: ARG_TYPE_PURE_TOKEN,
11465                key_spec_index: -(1 as libc::c_int),
11466                token: b"CH\0" as *const u8 as *const libc::c_char,
11467                summary: 0 as *const libc::c_char,
11468                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
11469                flags: (1 as libc::c_int) << 0 as libc::c_int,
11470                deprecated_since: 0 as *const libc::c_char,
11471                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11472                num_args: 0,
11473            };
11474            init
11475        },
11476        {
11477            let mut init = redisCommandArg {
11478                name: b"longitude_latitude_member\0" as *const u8 as *const libc::c_char,
11479                type_0: ARG_TYPE_BLOCK,
11480                key_spec_index: -(1 as libc::c_int),
11481                token: 0 as *const libc::c_char,
11482                summary: 0 as *const libc::c_char,
11483                since: 0 as *const libc::c_char,
11484                flags: (1 as libc::c_int) << 1 as libc::c_int,
11485                deprecated_since: 0 as *const libc::c_char,
11486                subargs: GEOADD_longitude_latitude_member_Subargs.as_ptr() as *mut _,
11487                num_args: 0,
11488            };
11489            init
11490        },
11491        {
11492            let mut init = redisCommandArg {
11493                name: 0 as *const libc::c_char,
11494                type_0: ARG_TYPE_STRING,
11495                key_spec_index: 0,
11496                token: 0 as *const libc::c_char,
11497                summary: 0 as *const libc::c_char,
11498                since: 0 as *const libc::c_char,
11499                flags: 0,
11500                deprecated_since: 0 as *const libc::c_char,
11501                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11502                num_args: 0,
11503            };
11504            init
11505        },
11506    ]
11507};
11508#[no_mangle]
11509pub static mut GEODIST_unit_Subargs: [redisCommandArg; 5] = [
11510    {
11511        let mut init = redisCommandArg {
11512            name: b"m\0" as *const u8 as *const libc::c_char,
11513            type_0: ARG_TYPE_PURE_TOKEN,
11514            key_spec_index: -(1 as libc::c_int),
11515            token: b"M\0" as *const u8 as *const libc::c_char,
11516            summary: 0 as *const libc::c_char,
11517            since: 0 as *const libc::c_char,
11518            flags: 0 as libc::c_int,
11519            deprecated_since: 0 as *const libc::c_char,
11520            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11521            num_args: 0,
11522        };
11523        init
11524    },
11525    {
11526        let mut init = redisCommandArg {
11527            name: b"km\0" as *const u8 as *const libc::c_char,
11528            type_0: ARG_TYPE_PURE_TOKEN,
11529            key_spec_index: -(1 as libc::c_int),
11530            token: b"KM\0" as *const u8 as *const libc::c_char,
11531            summary: 0 as *const libc::c_char,
11532            since: 0 as *const libc::c_char,
11533            flags: 0 as libc::c_int,
11534            deprecated_since: 0 as *const libc::c_char,
11535            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11536            num_args: 0,
11537        };
11538        init
11539    },
11540    {
11541        let mut init = redisCommandArg {
11542            name: b"ft\0" as *const u8 as *const libc::c_char,
11543            type_0: ARG_TYPE_PURE_TOKEN,
11544            key_spec_index: -(1 as libc::c_int),
11545            token: b"FT\0" as *const u8 as *const libc::c_char,
11546            summary: 0 as *const libc::c_char,
11547            since: 0 as *const libc::c_char,
11548            flags: 0 as libc::c_int,
11549            deprecated_since: 0 as *const libc::c_char,
11550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11551            num_args: 0,
11552        };
11553        init
11554    },
11555    {
11556        let mut init = redisCommandArg {
11557            name: b"mi\0" as *const u8 as *const libc::c_char,
11558            type_0: ARG_TYPE_PURE_TOKEN,
11559            key_spec_index: -(1 as libc::c_int),
11560            token: b"MI\0" as *const u8 as *const libc::c_char,
11561            summary: 0 as *const libc::c_char,
11562            since: 0 as *const libc::c_char,
11563            flags: 0 as libc::c_int,
11564            deprecated_since: 0 as *const libc::c_char,
11565            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11566            num_args: 0,
11567        };
11568        init
11569    },
11570    {
11571        let mut init = redisCommandArg {
11572            name: 0 as *const libc::c_char,
11573            type_0: ARG_TYPE_STRING,
11574            key_spec_index: 0,
11575            token: 0 as *const libc::c_char,
11576            summary: 0 as *const libc::c_char,
11577            since: 0 as *const libc::c_char,
11578            flags: 0,
11579            deprecated_since: 0 as *const libc::c_char,
11580            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11581            num_args: 0,
11582        };
11583        init
11584    },
11585];
11586#[no_mangle]
11587pub static mut GEODIST_Args: [redisCommandArg; 5] = unsafe {
11588    [
11589        {
11590            let mut init = redisCommandArg {
11591                name: b"key\0" as *const u8 as *const libc::c_char,
11592                type_0: ARG_TYPE_KEY,
11593                key_spec_index: 0 as libc::c_int,
11594                token: 0 as *const libc::c_char,
11595                summary: 0 as *const libc::c_char,
11596                since: 0 as *const libc::c_char,
11597                flags: 0 as libc::c_int,
11598                deprecated_since: 0 as *const libc::c_char,
11599                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11600                num_args: 0,
11601            };
11602            init
11603        },
11604        {
11605            let mut init = redisCommandArg {
11606                name: b"member1\0" as *const u8 as *const libc::c_char,
11607                type_0: ARG_TYPE_STRING,
11608                key_spec_index: -(1 as libc::c_int),
11609                token: 0 as *const libc::c_char,
11610                summary: 0 as *const libc::c_char,
11611                since: 0 as *const libc::c_char,
11612                flags: 0 as libc::c_int,
11613                deprecated_since: 0 as *const libc::c_char,
11614                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11615                num_args: 0,
11616            };
11617            init
11618        },
11619        {
11620            let mut init = redisCommandArg {
11621                name: b"member2\0" as *const u8 as *const libc::c_char,
11622                type_0: ARG_TYPE_STRING,
11623                key_spec_index: -(1 as libc::c_int),
11624                token: 0 as *const libc::c_char,
11625                summary: 0 as *const libc::c_char,
11626                since: 0 as *const libc::c_char,
11627                flags: 0 as libc::c_int,
11628                deprecated_since: 0 as *const libc::c_char,
11629                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11630                num_args: 0,
11631            };
11632            init
11633        },
11634        {
11635            let mut init = redisCommandArg {
11636                name: b"unit\0" as *const u8 as *const libc::c_char,
11637                type_0: ARG_TYPE_ONEOF,
11638                key_spec_index: -(1 as libc::c_int),
11639                token: 0 as *const libc::c_char,
11640                summary: 0 as *const libc::c_char,
11641                since: 0 as *const libc::c_char,
11642                flags: (1 as libc::c_int) << 0 as libc::c_int,
11643                deprecated_since: 0 as *const libc::c_char,
11644                subargs: GEODIST_unit_Subargs.as_ptr() as *mut _,
11645                num_args: 0,
11646            };
11647            init
11648        },
11649        {
11650            let mut init = redisCommandArg {
11651                name: 0 as *const libc::c_char,
11652                type_0: ARG_TYPE_STRING,
11653                key_spec_index: 0,
11654                token: 0 as *const libc::c_char,
11655                summary: 0 as *const libc::c_char,
11656                since: 0 as *const libc::c_char,
11657                flags: 0,
11658                deprecated_since: 0 as *const libc::c_char,
11659                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11660                num_args: 0,
11661            };
11662            init
11663        },
11664    ]
11665};
11666#[no_mangle]
11667pub static mut GEOHASH_Args: [redisCommandArg; 3] = [
11668    {
11669        let mut init = redisCommandArg {
11670            name: b"key\0" as *const u8 as *const libc::c_char,
11671            type_0: ARG_TYPE_KEY,
11672            key_spec_index: 0 as libc::c_int,
11673            token: 0 as *const libc::c_char,
11674            summary: 0 as *const libc::c_char,
11675            since: 0 as *const libc::c_char,
11676            flags: 0 as libc::c_int,
11677            deprecated_since: 0 as *const libc::c_char,
11678            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11679            num_args: 0,
11680        };
11681        init
11682    },
11683    {
11684        let mut init = redisCommandArg {
11685            name: b"member\0" as *const u8 as *const libc::c_char,
11686            type_0: ARG_TYPE_STRING,
11687            key_spec_index: -(1 as libc::c_int),
11688            token: 0 as *const libc::c_char,
11689            summary: 0 as *const libc::c_char,
11690            since: 0 as *const libc::c_char,
11691            flags: (1 as libc::c_int) << 1 as libc::c_int,
11692            deprecated_since: 0 as *const libc::c_char,
11693            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11694            num_args: 0,
11695        };
11696        init
11697    },
11698    {
11699        let mut init = redisCommandArg {
11700            name: 0 as *const libc::c_char,
11701            type_0: ARG_TYPE_STRING,
11702            key_spec_index: 0,
11703            token: 0 as *const libc::c_char,
11704            summary: 0 as *const libc::c_char,
11705            since: 0 as *const libc::c_char,
11706            flags: 0,
11707            deprecated_since: 0 as *const libc::c_char,
11708            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11709            num_args: 0,
11710        };
11711        init
11712    },
11713];
11714#[no_mangle]
11715pub static mut GEOPOS_Args: [redisCommandArg; 3] = [
11716    {
11717        let mut init = redisCommandArg {
11718            name: b"key\0" as *const u8 as *const libc::c_char,
11719            type_0: ARG_TYPE_KEY,
11720            key_spec_index: 0 as libc::c_int,
11721            token: 0 as *const libc::c_char,
11722            summary: 0 as *const libc::c_char,
11723            since: 0 as *const libc::c_char,
11724            flags: 0 as libc::c_int,
11725            deprecated_since: 0 as *const libc::c_char,
11726            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11727            num_args: 0,
11728        };
11729        init
11730    },
11731    {
11732        let mut init = redisCommandArg {
11733            name: b"member\0" as *const u8 as *const libc::c_char,
11734            type_0: ARG_TYPE_STRING,
11735            key_spec_index: -(1 as libc::c_int),
11736            token: 0 as *const libc::c_char,
11737            summary: 0 as *const libc::c_char,
11738            since: 0 as *const libc::c_char,
11739            flags: (1 as libc::c_int) << 1 as libc::c_int,
11740            deprecated_since: 0 as *const libc::c_char,
11741            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11742            num_args: 0,
11743        };
11744        init
11745    },
11746    {
11747        let mut init = redisCommandArg {
11748            name: 0 as *const libc::c_char,
11749            type_0: ARG_TYPE_STRING,
11750            key_spec_index: 0,
11751            token: 0 as *const libc::c_char,
11752            summary: 0 as *const libc::c_char,
11753            since: 0 as *const libc::c_char,
11754            flags: 0,
11755            deprecated_since: 0 as *const libc::c_char,
11756            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11757            num_args: 0,
11758        };
11759        init
11760    },
11761];
11762#[no_mangle]
11763pub static mut GEORADIUS_History: [commandHistory; 3] = [
11764    {
11765        let mut init = commandHistory {
11766            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
11767            changes: b"Added the `ANY` option for `COUNT`.\0" as *const u8
11768                as *const libc::c_char,
11769        };
11770        init
11771    },
11772    {
11773        let mut init = commandHistory {
11774            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
11775            changes: b"Added support for uppercase unit names.\0" as *const u8
11776                as *const libc::c_char,
11777        };
11778        init
11779    },
11780    {
11781        let mut init = commandHistory {
11782            since: 0 as *const libc::c_char,
11783            changes: 0 as *const libc::c_char,
11784        };
11785        init
11786    },
11787];
11788#[no_mangle]
11789pub static mut GEORADIUS_unit_Subargs: [redisCommandArg; 5] = [
11790    {
11791        let mut init = redisCommandArg {
11792            name: b"m\0" as *const u8 as *const libc::c_char,
11793            type_0: ARG_TYPE_PURE_TOKEN,
11794            key_spec_index: -(1 as libc::c_int),
11795            token: b"M\0" as *const u8 as *const libc::c_char,
11796            summary: 0 as *const libc::c_char,
11797            since: 0 as *const libc::c_char,
11798            flags: 0 as libc::c_int,
11799            deprecated_since: 0 as *const libc::c_char,
11800            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11801            num_args: 0,
11802        };
11803        init
11804    },
11805    {
11806        let mut init = redisCommandArg {
11807            name: b"km\0" as *const u8 as *const libc::c_char,
11808            type_0: ARG_TYPE_PURE_TOKEN,
11809            key_spec_index: -(1 as libc::c_int),
11810            token: b"KM\0" as *const u8 as *const libc::c_char,
11811            summary: 0 as *const libc::c_char,
11812            since: 0 as *const libc::c_char,
11813            flags: 0 as libc::c_int,
11814            deprecated_since: 0 as *const libc::c_char,
11815            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11816            num_args: 0,
11817        };
11818        init
11819    },
11820    {
11821        let mut init = redisCommandArg {
11822            name: b"ft\0" as *const u8 as *const libc::c_char,
11823            type_0: ARG_TYPE_PURE_TOKEN,
11824            key_spec_index: -(1 as libc::c_int),
11825            token: b"FT\0" as *const u8 as *const libc::c_char,
11826            summary: 0 as *const libc::c_char,
11827            since: 0 as *const libc::c_char,
11828            flags: 0 as libc::c_int,
11829            deprecated_since: 0 as *const libc::c_char,
11830            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11831            num_args: 0,
11832        };
11833        init
11834    },
11835    {
11836        let mut init = redisCommandArg {
11837            name: b"mi\0" as *const u8 as *const libc::c_char,
11838            type_0: ARG_TYPE_PURE_TOKEN,
11839            key_spec_index: -(1 as libc::c_int),
11840            token: b"MI\0" as *const u8 as *const libc::c_char,
11841            summary: 0 as *const libc::c_char,
11842            since: 0 as *const libc::c_char,
11843            flags: 0 as libc::c_int,
11844            deprecated_since: 0 as *const libc::c_char,
11845            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11846            num_args: 0,
11847        };
11848        init
11849    },
11850    {
11851        let mut init = redisCommandArg {
11852            name: 0 as *const libc::c_char,
11853            type_0: ARG_TYPE_STRING,
11854            key_spec_index: 0,
11855            token: 0 as *const libc::c_char,
11856            summary: 0 as *const libc::c_char,
11857            since: 0 as *const libc::c_char,
11858            flags: 0,
11859            deprecated_since: 0 as *const libc::c_char,
11860            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11861            num_args: 0,
11862        };
11863        init
11864    },
11865];
11866#[no_mangle]
11867pub static mut GEORADIUS_count_Subargs: [redisCommandArg; 3] = [
11868    {
11869        let mut init = redisCommandArg {
11870            name: b"count\0" as *const u8 as *const libc::c_char,
11871            type_0: ARG_TYPE_INTEGER,
11872            key_spec_index: -(1 as libc::c_int),
11873            token: b"COUNT\0" as *const u8 as *const libc::c_char,
11874            summary: 0 as *const libc::c_char,
11875            since: 0 as *const libc::c_char,
11876            flags: 0 as libc::c_int,
11877            deprecated_since: 0 as *const libc::c_char,
11878            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11879            num_args: 0,
11880        };
11881        init
11882    },
11883    {
11884        let mut init = redisCommandArg {
11885            name: b"any\0" as *const u8 as *const libc::c_char,
11886            type_0: ARG_TYPE_PURE_TOKEN,
11887            key_spec_index: -(1 as libc::c_int),
11888            token: b"ANY\0" as *const u8 as *const libc::c_char,
11889            summary: 0 as *const libc::c_char,
11890            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
11891            flags: (1 as libc::c_int) << 0 as libc::c_int,
11892            deprecated_since: 0 as *const libc::c_char,
11893            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11894            num_args: 0,
11895        };
11896        init
11897    },
11898    {
11899        let mut init = redisCommandArg {
11900            name: 0 as *const libc::c_char,
11901            type_0: ARG_TYPE_STRING,
11902            key_spec_index: 0,
11903            token: 0 as *const libc::c_char,
11904            summary: 0 as *const libc::c_char,
11905            since: 0 as *const libc::c_char,
11906            flags: 0,
11907            deprecated_since: 0 as *const libc::c_char,
11908            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11909            num_args: 0,
11910        };
11911        init
11912    },
11913];
11914#[no_mangle]
11915pub static mut GEORADIUS_order_Subargs: [redisCommandArg; 3] = [
11916    {
11917        let mut init = redisCommandArg {
11918            name: b"asc\0" as *const u8 as *const libc::c_char,
11919            type_0: ARG_TYPE_PURE_TOKEN,
11920            key_spec_index: -(1 as libc::c_int),
11921            token: b"ASC\0" as *const u8 as *const libc::c_char,
11922            summary: 0 as *const libc::c_char,
11923            since: 0 as *const libc::c_char,
11924            flags: 0 as libc::c_int,
11925            deprecated_since: 0 as *const libc::c_char,
11926            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11927            num_args: 0,
11928        };
11929        init
11930    },
11931    {
11932        let mut init = redisCommandArg {
11933            name: b"desc\0" as *const u8 as *const libc::c_char,
11934            type_0: ARG_TYPE_PURE_TOKEN,
11935            key_spec_index: -(1 as libc::c_int),
11936            token: b"DESC\0" as *const u8 as *const libc::c_char,
11937            summary: 0 as *const libc::c_char,
11938            since: 0 as *const libc::c_char,
11939            flags: 0 as libc::c_int,
11940            deprecated_since: 0 as *const libc::c_char,
11941            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11942            num_args: 0,
11943        };
11944        init
11945    },
11946    {
11947        let mut init = redisCommandArg {
11948            name: 0 as *const libc::c_char,
11949            type_0: ARG_TYPE_STRING,
11950            key_spec_index: 0,
11951            token: 0 as *const libc::c_char,
11952            summary: 0 as *const libc::c_char,
11953            since: 0 as *const libc::c_char,
11954            flags: 0,
11955            deprecated_since: 0 as *const libc::c_char,
11956            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11957            num_args: 0,
11958        };
11959        init
11960    },
11961];
11962#[no_mangle]
11963pub static mut GEORADIUS_Args: [redisCommandArg; 13] = unsafe {
11964    [
11965        {
11966            let mut init = redisCommandArg {
11967                name: b"key\0" as *const u8 as *const libc::c_char,
11968                type_0: ARG_TYPE_KEY,
11969                key_spec_index: 0 as libc::c_int,
11970                token: 0 as *const libc::c_char,
11971                summary: 0 as *const libc::c_char,
11972                since: 0 as *const libc::c_char,
11973                flags: 0 as libc::c_int,
11974                deprecated_since: 0 as *const libc::c_char,
11975                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11976                num_args: 0,
11977            };
11978            init
11979        },
11980        {
11981            let mut init = redisCommandArg {
11982                name: b"longitude\0" as *const u8 as *const libc::c_char,
11983                type_0: ARG_TYPE_DOUBLE,
11984                key_spec_index: -(1 as libc::c_int),
11985                token: 0 as *const libc::c_char,
11986                summary: 0 as *const libc::c_char,
11987                since: 0 as *const libc::c_char,
11988                flags: 0 as libc::c_int,
11989                deprecated_since: 0 as *const libc::c_char,
11990                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
11991                num_args: 0,
11992            };
11993            init
11994        },
11995        {
11996            let mut init = redisCommandArg {
11997                name: b"latitude\0" as *const u8 as *const libc::c_char,
11998                type_0: ARG_TYPE_DOUBLE,
11999                key_spec_index: -(1 as libc::c_int),
12000                token: 0 as *const libc::c_char,
12001                summary: 0 as *const libc::c_char,
12002                since: 0 as *const libc::c_char,
12003                flags: 0 as libc::c_int,
12004                deprecated_since: 0 as *const libc::c_char,
12005                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12006                num_args: 0,
12007            };
12008            init
12009        },
12010        {
12011            let mut init = redisCommandArg {
12012                name: b"radius\0" as *const u8 as *const libc::c_char,
12013                type_0: ARG_TYPE_DOUBLE,
12014                key_spec_index: -(1 as libc::c_int),
12015                token: 0 as *const libc::c_char,
12016                summary: 0 as *const libc::c_char,
12017                since: 0 as *const libc::c_char,
12018                flags: 0 as libc::c_int,
12019                deprecated_since: 0 as *const libc::c_char,
12020                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12021                num_args: 0,
12022            };
12023            init
12024        },
12025        {
12026            let mut init = redisCommandArg {
12027                name: b"unit\0" as *const u8 as *const libc::c_char,
12028                type_0: ARG_TYPE_ONEOF,
12029                key_spec_index: -(1 as libc::c_int),
12030                token: 0 as *const libc::c_char,
12031                summary: 0 as *const libc::c_char,
12032                since: 0 as *const libc::c_char,
12033                flags: 0 as libc::c_int,
12034                deprecated_since: 0 as *const libc::c_char,
12035                subargs: GEORADIUS_unit_Subargs.as_ptr() as *mut _,
12036                num_args: 0,
12037            };
12038            init
12039        },
12040        {
12041            let mut init = redisCommandArg {
12042                name: b"withcoord\0" as *const u8 as *const libc::c_char,
12043                type_0: ARG_TYPE_PURE_TOKEN,
12044                key_spec_index: -(1 as libc::c_int),
12045                token: b"WITHCOORD\0" as *const u8 as *const libc::c_char,
12046                summary: 0 as *const libc::c_char,
12047                since: 0 as *const libc::c_char,
12048                flags: (1 as libc::c_int) << 0 as libc::c_int,
12049                deprecated_since: 0 as *const libc::c_char,
12050                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12051                num_args: 0,
12052            };
12053            init
12054        },
12055        {
12056            let mut init = redisCommandArg {
12057                name: b"withdist\0" as *const u8 as *const libc::c_char,
12058                type_0: ARG_TYPE_PURE_TOKEN,
12059                key_spec_index: -(1 as libc::c_int),
12060                token: b"WITHDIST\0" as *const u8 as *const libc::c_char,
12061                summary: 0 as *const libc::c_char,
12062                since: 0 as *const libc::c_char,
12063                flags: (1 as libc::c_int) << 0 as libc::c_int,
12064                deprecated_since: 0 as *const libc::c_char,
12065                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12066                num_args: 0,
12067            };
12068            init
12069        },
12070        {
12071            let mut init = redisCommandArg {
12072                name: b"withhash\0" as *const u8 as *const libc::c_char,
12073                type_0: ARG_TYPE_PURE_TOKEN,
12074                key_spec_index: -(1 as libc::c_int),
12075                token: b"WITHHASH\0" as *const u8 as *const libc::c_char,
12076                summary: 0 as *const libc::c_char,
12077                since: 0 as *const libc::c_char,
12078                flags: (1 as libc::c_int) << 0 as libc::c_int,
12079                deprecated_since: 0 as *const libc::c_char,
12080                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12081                num_args: 0,
12082            };
12083            init
12084        },
12085        {
12086            let mut init = redisCommandArg {
12087                name: b"count\0" as *const u8 as *const libc::c_char,
12088                type_0: ARG_TYPE_BLOCK,
12089                key_spec_index: -(1 as libc::c_int),
12090                token: 0 as *const libc::c_char,
12091                summary: 0 as *const libc::c_char,
12092                since: 0 as *const libc::c_char,
12093                flags: (1 as libc::c_int) << 0 as libc::c_int,
12094                deprecated_since: 0 as *const libc::c_char,
12095                subargs: GEORADIUS_count_Subargs.as_ptr() as *mut _,
12096                num_args: 0,
12097            };
12098            init
12099        },
12100        {
12101            let mut init = redisCommandArg {
12102                name: b"order\0" as *const u8 as *const libc::c_char,
12103                type_0: ARG_TYPE_ONEOF,
12104                key_spec_index: -(1 as libc::c_int),
12105                token: 0 as *const libc::c_char,
12106                summary: 0 as *const libc::c_char,
12107                since: 0 as *const libc::c_char,
12108                flags: (1 as libc::c_int) << 0 as libc::c_int,
12109                deprecated_since: 0 as *const libc::c_char,
12110                subargs: GEORADIUS_order_Subargs.as_ptr() as *mut _,
12111                num_args: 0,
12112            };
12113            init
12114        },
12115        {
12116            let mut init = redisCommandArg {
12117                name: b"key\0" as *const u8 as *const libc::c_char,
12118                type_0: ARG_TYPE_KEY,
12119                key_spec_index: 1 as libc::c_int,
12120                token: b"STORE\0" as *const u8 as *const libc::c_char,
12121                summary: 0 as *const libc::c_char,
12122                since: 0 as *const libc::c_char,
12123                flags: (1 as libc::c_int) << 0 as libc::c_int,
12124                deprecated_since: 0 as *const libc::c_char,
12125                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12126                num_args: 0,
12127            };
12128            init
12129        },
12130        {
12131            let mut init = redisCommandArg {
12132                name: b"key\0" as *const u8 as *const libc::c_char,
12133                type_0: ARG_TYPE_KEY,
12134                key_spec_index: 2 as libc::c_int,
12135                token: b"STOREDIST\0" as *const u8 as *const libc::c_char,
12136                summary: 0 as *const libc::c_char,
12137                since: 0 as *const libc::c_char,
12138                flags: (1 as libc::c_int) << 0 as libc::c_int,
12139                deprecated_since: 0 as *const libc::c_char,
12140                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12141                num_args: 0,
12142            };
12143            init
12144        },
12145        {
12146            let mut init = redisCommandArg {
12147                name: 0 as *const libc::c_char,
12148                type_0: ARG_TYPE_STRING,
12149                key_spec_index: 0,
12150                token: 0 as *const libc::c_char,
12151                summary: 0 as *const libc::c_char,
12152                since: 0 as *const libc::c_char,
12153                flags: 0,
12154                deprecated_since: 0 as *const libc::c_char,
12155                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12156                num_args: 0,
12157            };
12158            init
12159        },
12160    ]
12161};
12162#[no_mangle]
12163pub static mut GEORADIUSBYMEMBER_History: [commandHistory; 2] = [
12164    {
12165        let mut init = commandHistory {
12166            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
12167            changes: b"Added support for uppercase unit names.\0" as *const u8
12168                as *const libc::c_char,
12169        };
12170        init
12171    },
12172    {
12173        let mut init = commandHistory {
12174            since: 0 as *const libc::c_char,
12175            changes: 0 as *const libc::c_char,
12176        };
12177        init
12178    },
12179];
12180#[no_mangle]
12181pub static mut GEORADIUSBYMEMBER_unit_Subargs: [redisCommandArg; 5] = [
12182    {
12183        let mut init = redisCommandArg {
12184            name: b"m\0" as *const u8 as *const libc::c_char,
12185            type_0: ARG_TYPE_PURE_TOKEN,
12186            key_spec_index: -(1 as libc::c_int),
12187            token: b"M\0" as *const u8 as *const libc::c_char,
12188            summary: 0 as *const libc::c_char,
12189            since: 0 as *const libc::c_char,
12190            flags: 0 as libc::c_int,
12191            deprecated_since: 0 as *const libc::c_char,
12192            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12193            num_args: 0,
12194        };
12195        init
12196    },
12197    {
12198        let mut init = redisCommandArg {
12199            name: b"km\0" as *const u8 as *const libc::c_char,
12200            type_0: ARG_TYPE_PURE_TOKEN,
12201            key_spec_index: -(1 as libc::c_int),
12202            token: b"KM\0" as *const u8 as *const libc::c_char,
12203            summary: 0 as *const libc::c_char,
12204            since: 0 as *const libc::c_char,
12205            flags: 0 as libc::c_int,
12206            deprecated_since: 0 as *const libc::c_char,
12207            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12208            num_args: 0,
12209        };
12210        init
12211    },
12212    {
12213        let mut init = redisCommandArg {
12214            name: b"ft\0" as *const u8 as *const libc::c_char,
12215            type_0: ARG_TYPE_PURE_TOKEN,
12216            key_spec_index: -(1 as libc::c_int),
12217            token: b"FT\0" as *const u8 as *const libc::c_char,
12218            summary: 0 as *const libc::c_char,
12219            since: 0 as *const libc::c_char,
12220            flags: 0 as libc::c_int,
12221            deprecated_since: 0 as *const libc::c_char,
12222            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12223            num_args: 0,
12224        };
12225        init
12226    },
12227    {
12228        let mut init = redisCommandArg {
12229            name: b"mi\0" as *const u8 as *const libc::c_char,
12230            type_0: ARG_TYPE_PURE_TOKEN,
12231            key_spec_index: -(1 as libc::c_int),
12232            token: b"MI\0" as *const u8 as *const libc::c_char,
12233            summary: 0 as *const libc::c_char,
12234            since: 0 as *const libc::c_char,
12235            flags: 0 as libc::c_int,
12236            deprecated_since: 0 as *const libc::c_char,
12237            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12238            num_args: 0,
12239        };
12240        init
12241    },
12242    {
12243        let mut init = redisCommandArg {
12244            name: 0 as *const libc::c_char,
12245            type_0: ARG_TYPE_STRING,
12246            key_spec_index: 0,
12247            token: 0 as *const libc::c_char,
12248            summary: 0 as *const libc::c_char,
12249            since: 0 as *const libc::c_char,
12250            flags: 0,
12251            deprecated_since: 0 as *const libc::c_char,
12252            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12253            num_args: 0,
12254        };
12255        init
12256    },
12257];
12258#[no_mangle]
12259pub static mut GEORADIUSBYMEMBER_count_Subargs: [redisCommandArg; 3] = [
12260    {
12261        let mut init = redisCommandArg {
12262            name: b"count\0" as *const u8 as *const libc::c_char,
12263            type_0: ARG_TYPE_INTEGER,
12264            key_spec_index: -(1 as libc::c_int),
12265            token: b"COUNT\0" as *const u8 as *const libc::c_char,
12266            summary: 0 as *const libc::c_char,
12267            since: 0 as *const libc::c_char,
12268            flags: 0 as libc::c_int,
12269            deprecated_since: 0 as *const libc::c_char,
12270            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12271            num_args: 0,
12272        };
12273        init
12274    },
12275    {
12276        let mut init = redisCommandArg {
12277            name: b"any\0" as *const u8 as *const libc::c_char,
12278            type_0: ARG_TYPE_PURE_TOKEN,
12279            key_spec_index: -(1 as libc::c_int),
12280            token: b"ANY\0" as *const u8 as *const libc::c_char,
12281            summary: 0 as *const libc::c_char,
12282            since: 0 as *const libc::c_char,
12283            flags: (1 as libc::c_int) << 0 as libc::c_int,
12284            deprecated_since: 0 as *const libc::c_char,
12285            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12286            num_args: 0,
12287        };
12288        init
12289    },
12290    {
12291        let mut init = redisCommandArg {
12292            name: 0 as *const libc::c_char,
12293            type_0: ARG_TYPE_STRING,
12294            key_spec_index: 0,
12295            token: 0 as *const libc::c_char,
12296            summary: 0 as *const libc::c_char,
12297            since: 0 as *const libc::c_char,
12298            flags: 0,
12299            deprecated_since: 0 as *const libc::c_char,
12300            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12301            num_args: 0,
12302        };
12303        init
12304    },
12305];
12306#[no_mangle]
12307pub static mut GEORADIUSBYMEMBER_order_Subargs: [redisCommandArg; 3] = [
12308    {
12309        let mut init = redisCommandArg {
12310            name: b"asc\0" as *const u8 as *const libc::c_char,
12311            type_0: ARG_TYPE_PURE_TOKEN,
12312            key_spec_index: -(1 as libc::c_int),
12313            token: b"ASC\0" as *const u8 as *const libc::c_char,
12314            summary: 0 as *const libc::c_char,
12315            since: 0 as *const libc::c_char,
12316            flags: 0 as libc::c_int,
12317            deprecated_since: 0 as *const libc::c_char,
12318            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12319            num_args: 0,
12320        };
12321        init
12322    },
12323    {
12324        let mut init = redisCommandArg {
12325            name: b"desc\0" as *const u8 as *const libc::c_char,
12326            type_0: ARG_TYPE_PURE_TOKEN,
12327            key_spec_index: -(1 as libc::c_int),
12328            token: b"DESC\0" as *const u8 as *const libc::c_char,
12329            summary: 0 as *const libc::c_char,
12330            since: 0 as *const libc::c_char,
12331            flags: 0 as libc::c_int,
12332            deprecated_since: 0 as *const libc::c_char,
12333            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12334            num_args: 0,
12335        };
12336        init
12337    },
12338    {
12339        let mut init = redisCommandArg {
12340            name: 0 as *const libc::c_char,
12341            type_0: ARG_TYPE_STRING,
12342            key_spec_index: 0,
12343            token: 0 as *const libc::c_char,
12344            summary: 0 as *const libc::c_char,
12345            since: 0 as *const libc::c_char,
12346            flags: 0,
12347            deprecated_since: 0 as *const libc::c_char,
12348            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12349            num_args: 0,
12350        };
12351        init
12352    },
12353];
12354#[no_mangle]
12355pub static mut GEORADIUSBYMEMBER_Args: [redisCommandArg; 12] = unsafe {
12356    [
12357        {
12358            let mut init = redisCommandArg {
12359                name: b"key\0" as *const u8 as *const libc::c_char,
12360                type_0: ARG_TYPE_KEY,
12361                key_spec_index: 0 as libc::c_int,
12362                token: 0 as *const libc::c_char,
12363                summary: 0 as *const libc::c_char,
12364                since: 0 as *const libc::c_char,
12365                flags: 0 as libc::c_int,
12366                deprecated_since: 0 as *const libc::c_char,
12367                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12368                num_args: 0,
12369            };
12370            init
12371        },
12372        {
12373            let mut init = redisCommandArg {
12374                name: b"member\0" as *const u8 as *const libc::c_char,
12375                type_0: ARG_TYPE_STRING,
12376                key_spec_index: -(1 as libc::c_int),
12377                token: 0 as *const libc::c_char,
12378                summary: 0 as *const libc::c_char,
12379                since: 0 as *const libc::c_char,
12380                flags: 0 as libc::c_int,
12381                deprecated_since: 0 as *const libc::c_char,
12382                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12383                num_args: 0,
12384            };
12385            init
12386        },
12387        {
12388            let mut init = redisCommandArg {
12389                name: b"radius\0" as *const u8 as *const libc::c_char,
12390                type_0: ARG_TYPE_DOUBLE,
12391                key_spec_index: -(1 as libc::c_int),
12392                token: 0 as *const libc::c_char,
12393                summary: 0 as *const libc::c_char,
12394                since: 0 as *const libc::c_char,
12395                flags: 0 as libc::c_int,
12396                deprecated_since: 0 as *const libc::c_char,
12397                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12398                num_args: 0,
12399            };
12400            init
12401        },
12402        {
12403            let mut init = redisCommandArg {
12404                name: b"unit\0" as *const u8 as *const libc::c_char,
12405                type_0: ARG_TYPE_ONEOF,
12406                key_spec_index: -(1 as libc::c_int),
12407                token: 0 as *const libc::c_char,
12408                summary: 0 as *const libc::c_char,
12409                since: 0 as *const libc::c_char,
12410                flags: 0 as libc::c_int,
12411                deprecated_since: 0 as *const libc::c_char,
12412                subargs: GEORADIUSBYMEMBER_unit_Subargs.as_ptr() as *mut _,
12413                num_args: 0,
12414            };
12415            init
12416        },
12417        {
12418            let mut init = redisCommandArg {
12419                name: b"withcoord\0" as *const u8 as *const libc::c_char,
12420                type_0: ARG_TYPE_PURE_TOKEN,
12421                key_spec_index: -(1 as libc::c_int),
12422                token: b"WITHCOORD\0" as *const u8 as *const libc::c_char,
12423                summary: 0 as *const libc::c_char,
12424                since: 0 as *const libc::c_char,
12425                flags: (1 as libc::c_int) << 0 as libc::c_int,
12426                deprecated_since: 0 as *const libc::c_char,
12427                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12428                num_args: 0,
12429            };
12430            init
12431        },
12432        {
12433            let mut init = redisCommandArg {
12434                name: b"withdist\0" as *const u8 as *const libc::c_char,
12435                type_0: ARG_TYPE_PURE_TOKEN,
12436                key_spec_index: -(1 as libc::c_int),
12437                token: b"WITHDIST\0" as *const u8 as *const libc::c_char,
12438                summary: 0 as *const libc::c_char,
12439                since: 0 as *const libc::c_char,
12440                flags: (1 as libc::c_int) << 0 as libc::c_int,
12441                deprecated_since: 0 as *const libc::c_char,
12442                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12443                num_args: 0,
12444            };
12445            init
12446        },
12447        {
12448            let mut init = redisCommandArg {
12449                name: b"withhash\0" as *const u8 as *const libc::c_char,
12450                type_0: ARG_TYPE_PURE_TOKEN,
12451                key_spec_index: -(1 as libc::c_int),
12452                token: b"WITHHASH\0" as *const u8 as *const libc::c_char,
12453                summary: 0 as *const libc::c_char,
12454                since: 0 as *const libc::c_char,
12455                flags: (1 as libc::c_int) << 0 as libc::c_int,
12456                deprecated_since: 0 as *const libc::c_char,
12457                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12458                num_args: 0,
12459            };
12460            init
12461        },
12462        {
12463            let mut init = redisCommandArg {
12464                name: b"count\0" as *const u8 as *const libc::c_char,
12465                type_0: ARG_TYPE_BLOCK,
12466                key_spec_index: -(1 as libc::c_int),
12467                token: 0 as *const libc::c_char,
12468                summary: 0 as *const libc::c_char,
12469                since: 0 as *const libc::c_char,
12470                flags: (1 as libc::c_int) << 0 as libc::c_int,
12471                deprecated_since: 0 as *const libc::c_char,
12472                subargs: GEORADIUSBYMEMBER_count_Subargs.as_ptr() as *mut _,
12473                num_args: 0,
12474            };
12475            init
12476        },
12477        {
12478            let mut init = redisCommandArg {
12479                name: b"order\0" as *const u8 as *const libc::c_char,
12480                type_0: ARG_TYPE_ONEOF,
12481                key_spec_index: -(1 as libc::c_int),
12482                token: 0 as *const libc::c_char,
12483                summary: 0 as *const libc::c_char,
12484                since: 0 as *const libc::c_char,
12485                flags: (1 as libc::c_int) << 0 as libc::c_int,
12486                deprecated_since: 0 as *const libc::c_char,
12487                subargs: GEORADIUSBYMEMBER_order_Subargs.as_ptr() as *mut _,
12488                num_args: 0,
12489            };
12490            init
12491        },
12492        {
12493            let mut init = redisCommandArg {
12494                name: b"key\0" as *const u8 as *const libc::c_char,
12495                type_0: ARG_TYPE_KEY,
12496                key_spec_index: 1 as libc::c_int,
12497                token: b"STORE\0" as *const u8 as *const libc::c_char,
12498                summary: 0 as *const libc::c_char,
12499                since: 0 as *const libc::c_char,
12500                flags: (1 as libc::c_int) << 0 as libc::c_int,
12501                deprecated_since: 0 as *const libc::c_char,
12502                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12503                num_args: 0,
12504            };
12505            init
12506        },
12507        {
12508            let mut init = redisCommandArg {
12509                name: b"key\0" as *const u8 as *const libc::c_char,
12510                type_0: ARG_TYPE_KEY,
12511                key_spec_index: 2 as libc::c_int,
12512                token: b"STOREDIST\0" as *const u8 as *const libc::c_char,
12513                summary: 0 as *const libc::c_char,
12514                since: 0 as *const libc::c_char,
12515                flags: (1 as libc::c_int) << 0 as libc::c_int,
12516                deprecated_since: 0 as *const libc::c_char,
12517                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12518                num_args: 0,
12519            };
12520            init
12521        },
12522        {
12523            let mut init = redisCommandArg {
12524                name: 0 as *const libc::c_char,
12525                type_0: ARG_TYPE_STRING,
12526                key_spec_index: 0,
12527                token: 0 as *const libc::c_char,
12528                summary: 0 as *const libc::c_char,
12529                since: 0 as *const libc::c_char,
12530                flags: 0,
12531                deprecated_since: 0 as *const libc::c_char,
12532                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12533                num_args: 0,
12534            };
12535            init
12536        },
12537    ]
12538};
12539#[no_mangle]
12540pub static mut GEORADIUSBYMEMBER_RO_unit_Subargs: [redisCommandArg; 5] = [
12541    {
12542        let mut init = redisCommandArg {
12543            name: b"m\0" as *const u8 as *const libc::c_char,
12544            type_0: ARG_TYPE_PURE_TOKEN,
12545            key_spec_index: -(1 as libc::c_int),
12546            token: b"M\0" as *const u8 as *const libc::c_char,
12547            summary: 0 as *const libc::c_char,
12548            since: 0 as *const libc::c_char,
12549            flags: 0 as libc::c_int,
12550            deprecated_since: 0 as *const libc::c_char,
12551            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12552            num_args: 0,
12553        };
12554        init
12555    },
12556    {
12557        let mut init = redisCommandArg {
12558            name: b"km\0" as *const u8 as *const libc::c_char,
12559            type_0: ARG_TYPE_PURE_TOKEN,
12560            key_spec_index: -(1 as libc::c_int),
12561            token: b"KM\0" as *const u8 as *const libc::c_char,
12562            summary: 0 as *const libc::c_char,
12563            since: 0 as *const libc::c_char,
12564            flags: 0 as libc::c_int,
12565            deprecated_since: 0 as *const libc::c_char,
12566            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12567            num_args: 0,
12568        };
12569        init
12570    },
12571    {
12572        let mut init = redisCommandArg {
12573            name: b"ft\0" as *const u8 as *const libc::c_char,
12574            type_0: ARG_TYPE_PURE_TOKEN,
12575            key_spec_index: -(1 as libc::c_int),
12576            token: b"FT\0" as *const u8 as *const libc::c_char,
12577            summary: 0 as *const libc::c_char,
12578            since: 0 as *const libc::c_char,
12579            flags: 0 as libc::c_int,
12580            deprecated_since: 0 as *const libc::c_char,
12581            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12582            num_args: 0,
12583        };
12584        init
12585    },
12586    {
12587        let mut init = redisCommandArg {
12588            name: b"mi\0" as *const u8 as *const libc::c_char,
12589            type_0: ARG_TYPE_PURE_TOKEN,
12590            key_spec_index: -(1 as libc::c_int),
12591            token: b"MI\0" as *const u8 as *const libc::c_char,
12592            summary: 0 as *const libc::c_char,
12593            since: 0 as *const libc::c_char,
12594            flags: 0 as libc::c_int,
12595            deprecated_since: 0 as *const libc::c_char,
12596            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12597            num_args: 0,
12598        };
12599        init
12600    },
12601    {
12602        let mut init = redisCommandArg {
12603            name: 0 as *const libc::c_char,
12604            type_0: ARG_TYPE_STRING,
12605            key_spec_index: 0,
12606            token: 0 as *const libc::c_char,
12607            summary: 0 as *const libc::c_char,
12608            since: 0 as *const libc::c_char,
12609            flags: 0,
12610            deprecated_since: 0 as *const libc::c_char,
12611            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12612            num_args: 0,
12613        };
12614        init
12615    },
12616];
12617#[no_mangle]
12618pub static mut GEORADIUSBYMEMBER_RO_count_Subargs: [redisCommandArg; 3] = [
12619    {
12620        let mut init = redisCommandArg {
12621            name: b"count\0" as *const u8 as *const libc::c_char,
12622            type_0: ARG_TYPE_INTEGER,
12623            key_spec_index: -(1 as libc::c_int),
12624            token: b"COUNT\0" as *const u8 as *const libc::c_char,
12625            summary: 0 as *const libc::c_char,
12626            since: 0 as *const libc::c_char,
12627            flags: 0 as libc::c_int,
12628            deprecated_since: 0 as *const libc::c_char,
12629            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12630            num_args: 0,
12631        };
12632        init
12633    },
12634    {
12635        let mut init = redisCommandArg {
12636            name: b"any\0" as *const u8 as *const libc::c_char,
12637            type_0: ARG_TYPE_PURE_TOKEN,
12638            key_spec_index: -(1 as libc::c_int),
12639            token: b"ANY\0" as *const u8 as *const libc::c_char,
12640            summary: 0 as *const libc::c_char,
12641            since: 0 as *const libc::c_char,
12642            flags: (1 as libc::c_int) << 0 as libc::c_int,
12643            deprecated_since: 0 as *const libc::c_char,
12644            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12645            num_args: 0,
12646        };
12647        init
12648    },
12649    {
12650        let mut init = redisCommandArg {
12651            name: 0 as *const libc::c_char,
12652            type_0: ARG_TYPE_STRING,
12653            key_spec_index: 0,
12654            token: 0 as *const libc::c_char,
12655            summary: 0 as *const libc::c_char,
12656            since: 0 as *const libc::c_char,
12657            flags: 0,
12658            deprecated_since: 0 as *const libc::c_char,
12659            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12660            num_args: 0,
12661        };
12662        init
12663    },
12664];
12665#[no_mangle]
12666pub static mut GEORADIUSBYMEMBER_RO_order_Subargs: [redisCommandArg; 3] = [
12667    {
12668        let mut init = redisCommandArg {
12669            name: b"asc\0" as *const u8 as *const libc::c_char,
12670            type_0: ARG_TYPE_PURE_TOKEN,
12671            key_spec_index: -(1 as libc::c_int),
12672            token: b"ASC\0" as *const u8 as *const libc::c_char,
12673            summary: 0 as *const libc::c_char,
12674            since: 0 as *const libc::c_char,
12675            flags: 0 as libc::c_int,
12676            deprecated_since: 0 as *const libc::c_char,
12677            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12678            num_args: 0,
12679        };
12680        init
12681    },
12682    {
12683        let mut init = redisCommandArg {
12684            name: b"desc\0" as *const u8 as *const libc::c_char,
12685            type_0: ARG_TYPE_PURE_TOKEN,
12686            key_spec_index: -(1 as libc::c_int),
12687            token: b"DESC\0" as *const u8 as *const libc::c_char,
12688            summary: 0 as *const libc::c_char,
12689            since: 0 as *const libc::c_char,
12690            flags: 0 as libc::c_int,
12691            deprecated_since: 0 as *const libc::c_char,
12692            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12693            num_args: 0,
12694        };
12695        init
12696    },
12697    {
12698        let mut init = redisCommandArg {
12699            name: 0 as *const libc::c_char,
12700            type_0: ARG_TYPE_STRING,
12701            key_spec_index: 0,
12702            token: 0 as *const libc::c_char,
12703            summary: 0 as *const libc::c_char,
12704            since: 0 as *const libc::c_char,
12705            flags: 0,
12706            deprecated_since: 0 as *const libc::c_char,
12707            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12708            num_args: 0,
12709        };
12710        init
12711    },
12712];
12713#[no_mangle]
12714pub static mut GEORADIUSBYMEMBER_RO_Args: [redisCommandArg; 10] = unsafe {
12715    [
12716        {
12717            let mut init = redisCommandArg {
12718                name: b"key\0" as *const u8 as *const libc::c_char,
12719                type_0: ARG_TYPE_KEY,
12720                key_spec_index: 0 as libc::c_int,
12721                token: 0 as *const libc::c_char,
12722                summary: 0 as *const libc::c_char,
12723                since: 0 as *const libc::c_char,
12724                flags: 0 as libc::c_int,
12725                deprecated_since: 0 as *const libc::c_char,
12726                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12727                num_args: 0,
12728            };
12729            init
12730        },
12731        {
12732            let mut init = redisCommandArg {
12733                name: b"member\0" as *const u8 as *const libc::c_char,
12734                type_0: ARG_TYPE_STRING,
12735                key_spec_index: -(1 as libc::c_int),
12736                token: 0 as *const libc::c_char,
12737                summary: 0 as *const libc::c_char,
12738                since: 0 as *const libc::c_char,
12739                flags: 0 as libc::c_int,
12740                deprecated_since: 0 as *const libc::c_char,
12741                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12742                num_args: 0,
12743            };
12744            init
12745        },
12746        {
12747            let mut init = redisCommandArg {
12748                name: b"radius\0" as *const u8 as *const libc::c_char,
12749                type_0: ARG_TYPE_DOUBLE,
12750                key_spec_index: -(1 as libc::c_int),
12751                token: 0 as *const libc::c_char,
12752                summary: 0 as *const libc::c_char,
12753                since: 0 as *const libc::c_char,
12754                flags: 0 as libc::c_int,
12755                deprecated_since: 0 as *const libc::c_char,
12756                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12757                num_args: 0,
12758            };
12759            init
12760        },
12761        {
12762            let mut init = redisCommandArg {
12763                name: b"unit\0" as *const u8 as *const libc::c_char,
12764                type_0: ARG_TYPE_ONEOF,
12765                key_spec_index: -(1 as libc::c_int),
12766                token: 0 as *const libc::c_char,
12767                summary: 0 as *const libc::c_char,
12768                since: 0 as *const libc::c_char,
12769                flags: 0 as libc::c_int,
12770                deprecated_since: 0 as *const libc::c_char,
12771                subargs: GEORADIUSBYMEMBER_RO_unit_Subargs.as_ptr() as *mut _,
12772                num_args: 0,
12773            };
12774            init
12775        },
12776        {
12777            let mut init = redisCommandArg {
12778                name: b"withcoord\0" as *const u8 as *const libc::c_char,
12779                type_0: ARG_TYPE_PURE_TOKEN,
12780                key_spec_index: -(1 as libc::c_int),
12781                token: b"WITHCOORD\0" as *const u8 as *const libc::c_char,
12782                summary: 0 as *const libc::c_char,
12783                since: 0 as *const libc::c_char,
12784                flags: (1 as libc::c_int) << 0 as libc::c_int,
12785                deprecated_since: 0 as *const libc::c_char,
12786                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12787                num_args: 0,
12788            };
12789            init
12790        },
12791        {
12792            let mut init = redisCommandArg {
12793                name: b"withdist\0" as *const u8 as *const libc::c_char,
12794                type_0: ARG_TYPE_PURE_TOKEN,
12795                key_spec_index: -(1 as libc::c_int),
12796                token: b"WITHDIST\0" as *const u8 as *const libc::c_char,
12797                summary: 0 as *const libc::c_char,
12798                since: 0 as *const libc::c_char,
12799                flags: (1 as libc::c_int) << 0 as libc::c_int,
12800                deprecated_since: 0 as *const libc::c_char,
12801                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12802                num_args: 0,
12803            };
12804            init
12805        },
12806        {
12807            let mut init = redisCommandArg {
12808                name: b"withhash\0" as *const u8 as *const libc::c_char,
12809                type_0: ARG_TYPE_PURE_TOKEN,
12810                key_spec_index: -(1 as libc::c_int),
12811                token: b"WITHHASH\0" as *const u8 as *const libc::c_char,
12812                summary: 0 as *const libc::c_char,
12813                since: 0 as *const libc::c_char,
12814                flags: (1 as libc::c_int) << 0 as libc::c_int,
12815                deprecated_since: 0 as *const libc::c_char,
12816                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12817                num_args: 0,
12818            };
12819            init
12820        },
12821        {
12822            let mut init = redisCommandArg {
12823                name: b"count\0" as *const u8 as *const libc::c_char,
12824                type_0: ARG_TYPE_BLOCK,
12825                key_spec_index: -(1 as libc::c_int),
12826                token: 0 as *const libc::c_char,
12827                summary: 0 as *const libc::c_char,
12828                since: 0 as *const libc::c_char,
12829                flags: (1 as libc::c_int) << 0 as libc::c_int,
12830                deprecated_since: 0 as *const libc::c_char,
12831                subargs: GEORADIUSBYMEMBER_RO_count_Subargs.as_ptr() as *mut _,
12832                num_args: 0,
12833            };
12834            init
12835        },
12836        {
12837            let mut init = redisCommandArg {
12838                name: b"order\0" as *const u8 as *const libc::c_char,
12839                type_0: ARG_TYPE_ONEOF,
12840                key_spec_index: -(1 as libc::c_int),
12841                token: 0 as *const libc::c_char,
12842                summary: 0 as *const libc::c_char,
12843                since: 0 as *const libc::c_char,
12844                flags: (1 as libc::c_int) << 0 as libc::c_int,
12845                deprecated_since: 0 as *const libc::c_char,
12846                subargs: GEORADIUSBYMEMBER_RO_order_Subargs.as_ptr() as *mut _,
12847                num_args: 0,
12848            };
12849            init
12850        },
12851        {
12852            let mut init = redisCommandArg {
12853                name: 0 as *const libc::c_char,
12854                type_0: ARG_TYPE_STRING,
12855                key_spec_index: 0,
12856                token: 0 as *const libc::c_char,
12857                summary: 0 as *const libc::c_char,
12858                since: 0 as *const libc::c_char,
12859                flags: 0,
12860                deprecated_since: 0 as *const libc::c_char,
12861                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12862                num_args: 0,
12863            };
12864            init
12865        },
12866    ]
12867};
12868#[no_mangle]
12869pub static mut GEORADIUS_RO_History: [commandHistory; 2] = [
12870    {
12871        let mut init = commandHistory {
12872            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
12873            changes: b"Added the `ANY` option for `COUNT`.\0" as *const u8
12874                as *const libc::c_char,
12875        };
12876        init
12877    },
12878    {
12879        let mut init = commandHistory {
12880            since: 0 as *const libc::c_char,
12881            changes: 0 as *const libc::c_char,
12882        };
12883        init
12884    },
12885];
12886#[no_mangle]
12887pub static mut GEORADIUS_RO_unit_Subargs: [redisCommandArg; 5] = [
12888    {
12889        let mut init = redisCommandArg {
12890            name: b"m\0" as *const u8 as *const libc::c_char,
12891            type_0: ARG_TYPE_PURE_TOKEN,
12892            key_spec_index: -(1 as libc::c_int),
12893            token: b"M\0" as *const u8 as *const libc::c_char,
12894            summary: 0 as *const libc::c_char,
12895            since: 0 as *const libc::c_char,
12896            flags: 0 as libc::c_int,
12897            deprecated_since: 0 as *const libc::c_char,
12898            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12899            num_args: 0,
12900        };
12901        init
12902    },
12903    {
12904        let mut init = redisCommandArg {
12905            name: b"km\0" as *const u8 as *const libc::c_char,
12906            type_0: ARG_TYPE_PURE_TOKEN,
12907            key_spec_index: -(1 as libc::c_int),
12908            token: b"KM\0" as *const u8 as *const libc::c_char,
12909            summary: 0 as *const libc::c_char,
12910            since: 0 as *const libc::c_char,
12911            flags: 0 as libc::c_int,
12912            deprecated_since: 0 as *const libc::c_char,
12913            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12914            num_args: 0,
12915        };
12916        init
12917    },
12918    {
12919        let mut init = redisCommandArg {
12920            name: b"ft\0" as *const u8 as *const libc::c_char,
12921            type_0: ARG_TYPE_PURE_TOKEN,
12922            key_spec_index: -(1 as libc::c_int),
12923            token: b"FT\0" as *const u8 as *const libc::c_char,
12924            summary: 0 as *const libc::c_char,
12925            since: 0 as *const libc::c_char,
12926            flags: 0 as libc::c_int,
12927            deprecated_since: 0 as *const libc::c_char,
12928            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12929            num_args: 0,
12930        };
12931        init
12932    },
12933    {
12934        let mut init = redisCommandArg {
12935            name: b"mi\0" as *const u8 as *const libc::c_char,
12936            type_0: ARG_TYPE_PURE_TOKEN,
12937            key_spec_index: -(1 as libc::c_int),
12938            token: b"MI\0" as *const u8 as *const libc::c_char,
12939            summary: 0 as *const libc::c_char,
12940            since: 0 as *const libc::c_char,
12941            flags: 0 as libc::c_int,
12942            deprecated_since: 0 as *const libc::c_char,
12943            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12944            num_args: 0,
12945        };
12946        init
12947    },
12948    {
12949        let mut init = redisCommandArg {
12950            name: 0 as *const libc::c_char,
12951            type_0: ARG_TYPE_STRING,
12952            key_spec_index: 0,
12953            token: 0 as *const libc::c_char,
12954            summary: 0 as *const libc::c_char,
12955            since: 0 as *const libc::c_char,
12956            flags: 0,
12957            deprecated_since: 0 as *const libc::c_char,
12958            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12959            num_args: 0,
12960        };
12961        init
12962    },
12963];
12964#[no_mangle]
12965pub static mut GEORADIUS_RO_count_Subargs: [redisCommandArg; 3] = [
12966    {
12967        let mut init = redisCommandArg {
12968            name: b"count\0" as *const u8 as *const libc::c_char,
12969            type_0: ARG_TYPE_INTEGER,
12970            key_spec_index: -(1 as libc::c_int),
12971            token: b"COUNT\0" as *const u8 as *const libc::c_char,
12972            summary: 0 as *const libc::c_char,
12973            since: 0 as *const libc::c_char,
12974            flags: 0 as libc::c_int,
12975            deprecated_since: 0 as *const libc::c_char,
12976            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12977            num_args: 0,
12978        };
12979        init
12980    },
12981    {
12982        let mut init = redisCommandArg {
12983            name: b"any\0" as *const u8 as *const libc::c_char,
12984            type_0: ARG_TYPE_PURE_TOKEN,
12985            key_spec_index: -(1 as libc::c_int),
12986            token: b"ANY\0" as *const u8 as *const libc::c_char,
12987            summary: 0 as *const libc::c_char,
12988            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
12989            flags: (1 as libc::c_int) << 0 as libc::c_int,
12990            deprecated_since: 0 as *const libc::c_char,
12991            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
12992            num_args: 0,
12993        };
12994        init
12995    },
12996    {
12997        let mut init = redisCommandArg {
12998            name: 0 as *const libc::c_char,
12999            type_0: ARG_TYPE_STRING,
13000            key_spec_index: 0,
13001            token: 0 as *const libc::c_char,
13002            summary: 0 as *const libc::c_char,
13003            since: 0 as *const libc::c_char,
13004            flags: 0,
13005            deprecated_since: 0 as *const libc::c_char,
13006            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13007            num_args: 0,
13008        };
13009        init
13010    },
13011];
13012#[no_mangle]
13013pub static mut GEORADIUS_RO_order_Subargs: [redisCommandArg; 3] = [
13014    {
13015        let mut init = redisCommandArg {
13016            name: b"asc\0" as *const u8 as *const libc::c_char,
13017            type_0: ARG_TYPE_PURE_TOKEN,
13018            key_spec_index: -(1 as libc::c_int),
13019            token: b"ASC\0" as *const u8 as *const libc::c_char,
13020            summary: 0 as *const libc::c_char,
13021            since: 0 as *const libc::c_char,
13022            flags: 0 as libc::c_int,
13023            deprecated_since: 0 as *const libc::c_char,
13024            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13025            num_args: 0,
13026        };
13027        init
13028    },
13029    {
13030        let mut init = redisCommandArg {
13031            name: b"desc\0" as *const u8 as *const libc::c_char,
13032            type_0: ARG_TYPE_PURE_TOKEN,
13033            key_spec_index: -(1 as libc::c_int),
13034            token: b"DESC\0" as *const u8 as *const libc::c_char,
13035            summary: 0 as *const libc::c_char,
13036            since: 0 as *const libc::c_char,
13037            flags: 0 as libc::c_int,
13038            deprecated_since: 0 as *const libc::c_char,
13039            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13040            num_args: 0,
13041        };
13042        init
13043    },
13044    {
13045        let mut init = redisCommandArg {
13046            name: 0 as *const libc::c_char,
13047            type_0: ARG_TYPE_STRING,
13048            key_spec_index: 0,
13049            token: 0 as *const libc::c_char,
13050            summary: 0 as *const libc::c_char,
13051            since: 0 as *const libc::c_char,
13052            flags: 0,
13053            deprecated_since: 0 as *const libc::c_char,
13054            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13055            num_args: 0,
13056        };
13057        init
13058    },
13059];
13060#[no_mangle]
13061pub static mut GEORADIUS_RO_Args: [redisCommandArg; 11] = unsafe {
13062    [
13063        {
13064            let mut init = redisCommandArg {
13065                name: b"key\0" as *const u8 as *const libc::c_char,
13066                type_0: ARG_TYPE_KEY,
13067                key_spec_index: 0 as libc::c_int,
13068                token: 0 as *const libc::c_char,
13069                summary: 0 as *const libc::c_char,
13070                since: 0 as *const libc::c_char,
13071                flags: 0 as libc::c_int,
13072                deprecated_since: 0 as *const libc::c_char,
13073                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13074                num_args: 0,
13075            };
13076            init
13077        },
13078        {
13079            let mut init = redisCommandArg {
13080                name: b"longitude\0" as *const u8 as *const libc::c_char,
13081                type_0: ARG_TYPE_DOUBLE,
13082                key_spec_index: -(1 as libc::c_int),
13083                token: 0 as *const libc::c_char,
13084                summary: 0 as *const libc::c_char,
13085                since: 0 as *const libc::c_char,
13086                flags: 0 as libc::c_int,
13087                deprecated_since: 0 as *const libc::c_char,
13088                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13089                num_args: 0,
13090            };
13091            init
13092        },
13093        {
13094            let mut init = redisCommandArg {
13095                name: b"latitude\0" as *const u8 as *const libc::c_char,
13096                type_0: ARG_TYPE_DOUBLE,
13097                key_spec_index: -(1 as libc::c_int),
13098                token: 0 as *const libc::c_char,
13099                summary: 0 as *const libc::c_char,
13100                since: 0 as *const libc::c_char,
13101                flags: 0 as libc::c_int,
13102                deprecated_since: 0 as *const libc::c_char,
13103                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13104                num_args: 0,
13105            };
13106            init
13107        },
13108        {
13109            let mut init = redisCommandArg {
13110                name: b"radius\0" as *const u8 as *const libc::c_char,
13111                type_0: ARG_TYPE_DOUBLE,
13112                key_spec_index: -(1 as libc::c_int),
13113                token: 0 as *const libc::c_char,
13114                summary: 0 as *const libc::c_char,
13115                since: 0 as *const libc::c_char,
13116                flags: 0 as libc::c_int,
13117                deprecated_since: 0 as *const libc::c_char,
13118                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13119                num_args: 0,
13120            };
13121            init
13122        },
13123        {
13124            let mut init = redisCommandArg {
13125                name: b"unit\0" as *const u8 as *const libc::c_char,
13126                type_0: ARG_TYPE_ONEOF,
13127                key_spec_index: -(1 as libc::c_int),
13128                token: 0 as *const libc::c_char,
13129                summary: 0 as *const libc::c_char,
13130                since: 0 as *const libc::c_char,
13131                flags: 0 as libc::c_int,
13132                deprecated_since: 0 as *const libc::c_char,
13133                subargs: GEORADIUS_RO_unit_Subargs.as_ptr() as *mut _,
13134                num_args: 0,
13135            };
13136            init
13137        },
13138        {
13139            let mut init = redisCommandArg {
13140                name: b"withcoord\0" as *const u8 as *const libc::c_char,
13141                type_0: ARG_TYPE_PURE_TOKEN,
13142                key_spec_index: -(1 as libc::c_int),
13143                token: b"WITHCOORD\0" as *const u8 as *const libc::c_char,
13144                summary: 0 as *const libc::c_char,
13145                since: 0 as *const libc::c_char,
13146                flags: (1 as libc::c_int) << 0 as libc::c_int,
13147                deprecated_since: 0 as *const libc::c_char,
13148                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13149                num_args: 0,
13150            };
13151            init
13152        },
13153        {
13154            let mut init = redisCommandArg {
13155                name: b"withdist\0" as *const u8 as *const libc::c_char,
13156                type_0: ARG_TYPE_PURE_TOKEN,
13157                key_spec_index: -(1 as libc::c_int),
13158                token: b"WITHDIST\0" as *const u8 as *const libc::c_char,
13159                summary: 0 as *const libc::c_char,
13160                since: 0 as *const libc::c_char,
13161                flags: (1 as libc::c_int) << 0 as libc::c_int,
13162                deprecated_since: 0 as *const libc::c_char,
13163                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13164                num_args: 0,
13165            };
13166            init
13167        },
13168        {
13169            let mut init = redisCommandArg {
13170                name: b"withhash\0" as *const u8 as *const libc::c_char,
13171                type_0: ARG_TYPE_PURE_TOKEN,
13172                key_spec_index: -(1 as libc::c_int),
13173                token: b"WITHHASH\0" as *const u8 as *const libc::c_char,
13174                summary: 0 as *const libc::c_char,
13175                since: 0 as *const libc::c_char,
13176                flags: (1 as libc::c_int) << 0 as libc::c_int,
13177                deprecated_since: 0 as *const libc::c_char,
13178                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13179                num_args: 0,
13180            };
13181            init
13182        },
13183        {
13184            let mut init = redisCommandArg {
13185                name: b"count\0" as *const u8 as *const libc::c_char,
13186                type_0: ARG_TYPE_BLOCK,
13187                key_spec_index: -(1 as libc::c_int),
13188                token: 0 as *const libc::c_char,
13189                summary: 0 as *const libc::c_char,
13190                since: 0 as *const libc::c_char,
13191                flags: (1 as libc::c_int) << 0 as libc::c_int,
13192                deprecated_since: 0 as *const libc::c_char,
13193                subargs: GEORADIUS_RO_count_Subargs.as_ptr() as *mut _,
13194                num_args: 0,
13195            };
13196            init
13197        },
13198        {
13199            let mut init = redisCommandArg {
13200                name: b"order\0" as *const u8 as *const libc::c_char,
13201                type_0: ARG_TYPE_ONEOF,
13202                key_spec_index: -(1 as libc::c_int),
13203                token: 0 as *const libc::c_char,
13204                summary: 0 as *const libc::c_char,
13205                since: 0 as *const libc::c_char,
13206                flags: (1 as libc::c_int) << 0 as libc::c_int,
13207                deprecated_since: 0 as *const libc::c_char,
13208                subargs: GEORADIUS_RO_order_Subargs.as_ptr() as *mut _,
13209                num_args: 0,
13210            };
13211            init
13212        },
13213        {
13214            let mut init = redisCommandArg {
13215                name: 0 as *const libc::c_char,
13216                type_0: ARG_TYPE_STRING,
13217                key_spec_index: 0,
13218                token: 0 as *const libc::c_char,
13219                summary: 0 as *const libc::c_char,
13220                since: 0 as *const libc::c_char,
13221                flags: 0,
13222                deprecated_since: 0 as *const libc::c_char,
13223                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13224                num_args: 0,
13225            };
13226            init
13227        },
13228    ]
13229};
13230#[no_mangle]
13231pub static mut GEOSEARCH_History: [commandHistory; 2] = [
13232    {
13233        let mut init = commandHistory {
13234            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
13235            changes: b"Added support for uppercase unit names.\0" as *const u8
13236                as *const libc::c_char,
13237        };
13238        init
13239    },
13240    {
13241        let mut init = commandHistory {
13242            since: 0 as *const libc::c_char,
13243            changes: 0 as *const libc::c_char,
13244        };
13245        init
13246    },
13247];
13248#[no_mangle]
13249pub static mut GEOSEARCH_from_longitude_latitude_Subargs: [redisCommandArg; 3] = [
13250    {
13251        let mut init = redisCommandArg {
13252            name: b"longitude\0" as *const u8 as *const libc::c_char,
13253            type_0: ARG_TYPE_DOUBLE,
13254            key_spec_index: -(1 as libc::c_int),
13255            token: 0 as *const libc::c_char,
13256            summary: 0 as *const libc::c_char,
13257            since: 0 as *const libc::c_char,
13258            flags: 0 as libc::c_int,
13259            deprecated_since: 0 as *const libc::c_char,
13260            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13261            num_args: 0,
13262        };
13263        init
13264    },
13265    {
13266        let mut init = redisCommandArg {
13267            name: b"latitude\0" as *const u8 as *const libc::c_char,
13268            type_0: ARG_TYPE_DOUBLE,
13269            key_spec_index: -(1 as libc::c_int),
13270            token: 0 as *const libc::c_char,
13271            summary: 0 as *const libc::c_char,
13272            since: 0 as *const libc::c_char,
13273            flags: 0 as libc::c_int,
13274            deprecated_since: 0 as *const libc::c_char,
13275            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13276            num_args: 0,
13277        };
13278        init
13279    },
13280    {
13281        let mut init = redisCommandArg {
13282            name: 0 as *const libc::c_char,
13283            type_0: ARG_TYPE_STRING,
13284            key_spec_index: 0,
13285            token: 0 as *const libc::c_char,
13286            summary: 0 as *const libc::c_char,
13287            since: 0 as *const libc::c_char,
13288            flags: 0,
13289            deprecated_since: 0 as *const libc::c_char,
13290            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13291            num_args: 0,
13292        };
13293        init
13294    },
13295];
13296#[no_mangle]
13297pub static mut GEOSEARCH_from_Subargs: [redisCommandArg; 3] = unsafe {
13298    [
13299        {
13300            let mut init = redisCommandArg {
13301                name: b"member\0" as *const u8 as *const libc::c_char,
13302                type_0: ARG_TYPE_STRING,
13303                key_spec_index: -(1 as libc::c_int),
13304                token: b"FROMMEMBER\0" as *const u8 as *const libc::c_char,
13305                summary: 0 as *const libc::c_char,
13306                since: 0 as *const libc::c_char,
13307                flags: 0 as libc::c_int,
13308                deprecated_since: 0 as *const libc::c_char,
13309                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13310                num_args: 0,
13311            };
13312            init
13313        },
13314        {
13315            let mut init = redisCommandArg {
13316                name: b"longitude_latitude\0" as *const u8 as *const libc::c_char,
13317                type_0: ARG_TYPE_BLOCK,
13318                key_spec_index: -(1 as libc::c_int),
13319                token: b"FROMLONLAT\0" as *const u8 as *const libc::c_char,
13320                summary: 0 as *const libc::c_char,
13321                since: 0 as *const libc::c_char,
13322                flags: 0 as libc::c_int,
13323                deprecated_since: 0 as *const libc::c_char,
13324                subargs: GEOSEARCH_from_longitude_latitude_Subargs.as_ptr() as *mut _,
13325                num_args: 0,
13326            };
13327            init
13328        },
13329        {
13330            let mut init = redisCommandArg {
13331                name: 0 as *const libc::c_char,
13332                type_0: ARG_TYPE_STRING,
13333                key_spec_index: 0,
13334                token: 0 as *const libc::c_char,
13335                summary: 0 as *const libc::c_char,
13336                since: 0 as *const libc::c_char,
13337                flags: 0,
13338                deprecated_since: 0 as *const libc::c_char,
13339                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13340                num_args: 0,
13341            };
13342            init
13343        },
13344    ]
13345};
13346#[no_mangle]
13347pub static mut GEOSEARCH_by_circle_unit_Subargs: [redisCommandArg; 5] = [
13348    {
13349        let mut init = redisCommandArg {
13350            name: b"m\0" as *const u8 as *const libc::c_char,
13351            type_0: ARG_TYPE_PURE_TOKEN,
13352            key_spec_index: -(1 as libc::c_int),
13353            token: b"M\0" as *const u8 as *const libc::c_char,
13354            summary: 0 as *const libc::c_char,
13355            since: 0 as *const libc::c_char,
13356            flags: 0 as libc::c_int,
13357            deprecated_since: 0 as *const libc::c_char,
13358            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13359            num_args: 0,
13360        };
13361        init
13362    },
13363    {
13364        let mut init = redisCommandArg {
13365            name: b"km\0" as *const u8 as *const libc::c_char,
13366            type_0: ARG_TYPE_PURE_TOKEN,
13367            key_spec_index: -(1 as libc::c_int),
13368            token: b"KM\0" as *const u8 as *const libc::c_char,
13369            summary: 0 as *const libc::c_char,
13370            since: 0 as *const libc::c_char,
13371            flags: 0 as libc::c_int,
13372            deprecated_since: 0 as *const libc::c_char,
13373            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13374            num_args: 0,
13375        };
13376        init
13377    },
13378    {
13379        let mut init = redisCommandArg {
13380            name: b"ft\0" as *const u8 as *const libc::c_char,
13381            type_0: ARG_TYPE_PURE_TOKEN,
13382            key_spec_index: -(1 as libc::c_int),
13383            token: b"FT\0" as *const u8 as *const libc::c_char,
13384            summary: 0 as *const libc::c_char,
13385            since: 0 as *const libc::c_char,
13386            flags: 0 as libc::c_int,
13387            deprecated_since: 0 as *const libc::c_char,
13388            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13389            num_args: 0,
13390        };
13391        init
13392    },
13393    {
13394        let mut init = redisCommandArg {
13395            name: b"mi\0" as *const u8 as *const libc::c_char,
13396            type_0: ARG_TYPE_PURE_TOKEN,
13397            key_spec_index: -(1 as libc::c_int),
13398            token: b"MI\0" as *const u8 as *const libc::c_char,
13399            summary: 0 as *const libc::c_char,
13400            since: 0 as *const libc::c_char,
13401            flags: 0 as libc::c_int,
13402            deprecated_since: 0 as *const libc::c_char,
13403            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13404            num_args: 0,
13405        };
13406        init
13407    },
13408    {
13409        let mut init = redisCommandArg {
13410            name: 0 as *const libc::c_char,
13411            type_0: ARG_TYPE_STRING,
13412            key_spec_index: 0,
13413            token: 0 as *const libc::c_char,
13414            summary: 0 as *const libc::c_char,
13415            since: 0 as *const libc::c_char,
13416            flags: 0,
13417            deprecated_since: 0 as *const libc::c_char,
13418            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13419            num_args: 0,
13420        };
13421        init
13422    },
13423];
13424#[no_mangle]
13425pub static mut GEOSEARCH_by_circle_Subargs: [redisCommandArg; 3] = unsafe {
13426    [
13427        {
13428            let mut init = redisCommandArg {
13429                name: b"radius\0" as *const u8 as *const libc::c_char,
13430                type_0: ARG_TYPE_DOUBLE,
13431                key_spec_index: -(1 as libc::c_int),
13432                token: b"BYRADIUS\0" as *const u8 as *const libc::c_char,
13433                summary: 0 as *const libc::c_char,
13434                since: 0 as *const libc::c_char,
13435                flags: 0 as libc::c_int,
13436                deprecated_since: 0 as *const libc::c_char,
13437                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13438                num_args: 0,
13439            };
13440            init
13441        },
13442        {
13443            let mut init = redisCommandArg {
13444                name: b"unit\0" as *const u8 as *const libc::c_char,
13445                type_0: ARG_TYPE_ONEOF,
13446                key_spec_index: -(1 as libc::c_int),
13447                token: 0 as *const libc::c_char,
13448                summary: 0 as *const libc::c_char,
13449                since: 0 as *const libc::c_char,
13450                flags: 0 as libc::c_int,
13451                deprecated_since: 0 as *const libc::c_char,
13452                subargs: GEOSEARCH_by_circle_unit_Subargs.as_ptr() as *mut _,
13453                num_args: 0,
13454            };
13455            init
13456        },
13457        {
13458            let mut init = redisCommandArg {
13459                name: 0 as *const libc::c_char,
13460                type_0: ARG_TYPE_STRING,
13461                key_spec_index: 0,
13462                token: 0 as *const libc::c_char,
13463                summary: 0 as *const libc::c_char,
13464                since: 0 as *const libc::c_char,
13465                flags: 0,
13466                deprecated_since: 0 as *const libc::c_char,
13467                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13468                num_args: 0,
13469            };
13470            init
13471        },
13472    ]
13473};
13474#[no_mangle]
13475pub static mut GEOSEARCH_by_box_unit_Subargs: [redisCommandArg; 5] = [
13476    {
13477        let mut init = redisCommandArg {
13478            name: b"m\0" as *const u8 as *const libc::c_char,
13479            type_0: ARG_TYPE_PURE_TOKEN,
13480            key_spec_index: -(1 as libc::c_int),
13481            token: b"M\0" as *const u8 as *const libc::c_char,
13482            summary: 0 as *const libc::c_char,
13483            since: 0 as *const libc::c_char,
13484            flags: 0 as libc::c_int,
13485            deprecated_since: 0 as *const libc::c_char,
13486            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13487            num_args: 0,
13488        };
13489        init
13490    },
13491    {
13492        let mut init = redisCommandArg {
13493            name: b"km\0" as *const u8 as *const libc::c_char,
13494            type_0: ARG_TYPE_PURE_TOKEN,
13495            key_spec_index: -(1 as libc::c_int),
13496            token: b"KM\0" as *const u8 as *const libc::c_char,
13497            summary: 0 as *const libc::c_char,
13498            since: 0 as *const libc::c_char,
13499            flags: 0 as libc::c_int,
13500            deprecated_since: 0 as *const libc::c_char,
13501            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13502            num_args: 0,
13503        };
13504        init
13505    },
13506    {
13507        let mut init = redisCommandArg {
13508            name: b"ft\0" as *const u8 as *const libc::c_char,
13509            type_0: ARG_TYPE_PURE_TOKEN,
13510            key_spec_index: -(1 as libc::c_int),
13511            token: b"FT\0" as *const u8 as *const libc::c_char,
13512            summary: 0 as *const libc::c_char,
13513            since: 0 as *const libc::c_char,
13514            flags: 0 as libc::c_int,
13515            deprecated_since: 0 as *const libc::c_char,
13516            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13517            num_args: 0,
13518        };
13519        init
13520    },
13521    {
13522        let mut init = redisCommandArg {
13523            name: b"mi\0" as *const u8 as *const libc::c_char,
13524            type_0: ARG_TYPE_PURE_TOKEN,
13525            key_spec_index: -(1 as libc::c_int),
13526            token: b"MI\0" as *const u8 as *const libc::c_char,
13527            summary: 0 as *const libc::c_char,
13528            since: 0 as *const libc::c_char,
13529            flags: 0 as libc::c_int,
13530            deprecated_since: 0 as *const libc::c_char,
13531            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13532            num_args: 0,
13533        };
13534        init
13535    },
13536    {
13537        let mut init = redisCommandArg {
13538            name: 0 as *const libc::c_char,
13539            type_0: ARG_TYPE_STRING,
13540            key_spec_index: 0,
13541            token: 0 as *const libc::c_char,
13542            summary: 0 as *const libc::c_char,
13543            since: 0 as *const libc::c_char,
13544            flags: 0,
13545            deprecated_since: 0 as *const libc::c_char,
13546            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13547            num_args: 0,
13548        };
13549        init
13550    },
13551];
13552#[no_mangle]
13553pub static mut GEOSEARCH_by_box_Subargs: [redisCommandArg; 4] = unsafe {
13554    [
13555        {
13556            let mut init = redisCommandArg {
13557                name: b"width\0" as *const u8 as *const libc::c_char,
13558                type_0: ARG_TYPE_DOUBLE,
13559                key_spec_index: -(1 as libc::c_int),
13560                token: b"BYBOX\0" as *const u8 as *const libc::c_char,
13561                summary: 0 as *const libc::c_char,
13562                since: 0 as *const libc::c_char,
13563                flags: 0 as libc::c_int,
13564                deprecated_since: 0 as *const libc::c_char,
13565                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13566                num_args: 0,
13567            };
13568            init
13569        },
13570        {
13571            let mut init = redisCommandArg {
13572                name: b"height\0" as *const u8 as *const libc::c_char,
13573                type_0: ARG_TYPE_DOUBLE,
13574                key_spec_index: -(1 as libc::c_int),
13575                token: 0 as *const libc::c_char,
13576                summary: 0 as *const libc::c_char,
13577                since: 0 as *const libc::c_char,
13578                flags: 0 as libc::c_int,
13579                deprecated_since: 0 as *const libc::c_char,
13580                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13581                num_args: 0,
13582            };
13583            init
13584        },
13585        {
13586            let mut init = redisCommandArg {
13587                name: b"unit\0" as *const u8 as *const libc::c_char,
13588                type_0: ARG_TYPE_ONEOF,
13589                key_spec_index: -(1 as libc::c_int),
13590                token: 0 as *const libc::c_char,
13591                summary: 0 as *const libc::c_char,
13592                since: 0 as *const libc::c_char,
13593                flags: 0 as libc::c_int,
13594                deprecated_since: 0 as *const libc::c_char,
13595                subargs: GEOSEARCH_by_box_unit_Subargs.as_ptr() as *mut _,
13596                num_args: 0,
13597            };
13598            init
13599        },
13600        {
13601            let mut init = redisCommandArg {
13602                name: 0 as *const libc::c_char,
13603                type_0: ARG_TYPE_STRING,
13604                key_spec_index: 0,
13605                token: 0 as *const libc::c_char,
13606                summary: 0 as *const libc::c_char,
13607                since: 0 as *const libc::c_char,
13608                flags: 0,
13609                deprecated_since: 0 as *const libc::c_char,
13610                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13611                num_args: 0,
13612            };
13613            init
13614        },
13615    ]
13616};
13617#[no_mangle]
13618pub static mut GEOSEARCH_by_Subargs: [redisCommandArg; 3] = unsafe {
13619    [
13620        {
13621            let mut init = redisCommandArg {
13622                name: b"circle\0" as *const u8 as *const libc::c_char,
13623                type_0: ARG_TYPE_BLOCK,
13624                key_spec_index: -(1 as libc::c_int),
13625                token: 0 as *const libc::c_char,
13626                summary: 0 as *const libc::c_char,
13627                since: 0 as *const libc::c_char,
13628                flags: 0 as libc::c_int,
13629                deprecated_since: 0 as *const libc::c_char,
13630                subargs: GEOSEARCH_by_circle_Subargs.as_ptr() as *mut _,
13631                num_args: 0,
13632            };
13633            init
13634        },
13635        {
13636            let mut init = redisCommandArg {
13637                name: b"box\0" as *const u8 as *const libc::c_char,
13638                type_0: ARG_TYPE_BLOCK,
13639                key_spec_index: -(1 as libc::c_int),
13640                token: 0 as *const libc::c_char,
13641                summary: 0 as *const libc::c_char,
13642                since: 0 as *const libc::c_char,
13643                flags: 0 as libc::c_int,
13644                deprecated_since: 0 as *const libc::c_char,
13645                subargs: GEOSEARCH_by_box_Subargs.as_ptr() as *mut _,
13646                num_args: 0,
13647            };
13648            init
13649        },
13650        {
13651            let mut init = redisCommandArg {
13652                name: 0 as *const libc::c_char,
13653                type_0: ARG_TYPE_STRING,
13654                key_spec_index: 0,
13655                token: 0 as *const libc::c_char,
13656                summary: 0 as *const libc::c_char,
13657                since: 0 as *const libc::c_char,
13658                flags: 0,
13659                deprecated_since: 0 as *const libc::c_char,
13660                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13661                num_args: 0,
13662            };
13663            init
13664        },
13665    ]
13666};
13667#[no_mangle]
13668pub static mut GEOSEARCH_order_Subargs: [redisCommandArg; 3] = [
13669    {
13670        let mut init = redisCommandArg {
13671            name: b"asc\0" as *const u8 as *const libc::c_char,
13672            type_0: ARG_TYPE_PURE_TOKEN,
13673            key_spec_index: -(1 as libc::c_int),
13674            token: b"ASC\0" as *const u8 as *const libc::c_char,
13675            summary: 0 as *const libc::c_char,
13676            since: 0 as *const libc::c_char,
13677            flags: 0 as libc::c_int,
13678            deprecated_since: 0 as *const libc::c_char,
13679            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13680            num_args: 0,
13681        };
13682        init
13683    },
13684    {
13685        let mut init = redisCommandArg {
13686            name: b"desc\0" as *const u8 as *const libc::c_char,
13687            type_0: ARG_TYPE_PURE_TOKEN,
13688            key_spec_index: -(1 as libc::c_int),
13689            token: b"DESC\0" as *const u8 as *const libc::c_char,
13690            summary: 0 as *const libc::c_char,
13691            since: 0 as *const libc::c_char,
13692            flags: 0 as libc::c_int,
13693            deprecated_since: 0 as *const libc::c_char,
13694            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13695            num_args: 0,
13696        };
13697        init
13698    },
13699    {
13700        let mut init = redisCommandArg {
13701            name: 0 as *const libc::c_char,
13702            type_0: ARG_TYPE_STRING,
13703            key_spec_index: 0,
13704            token: 0 as *const libc::c_char,
13705            summary: 0 as *const libc::c_char,
13706            since: 0 as *const libc::c_char,
13707            flags: 0,
13708            deprecated_since: 0 as *const libc::c_char,
13709            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13710            num_args: 0,
13711        };
13712        init
13713    },
13714];
13715#[no_mangle]
13716pub static mut GEOSEARCH_count_Subargs: [redisCommandArg; 3] = [
13717    {
13718        let mut init = redisCommandArg {
13719            name: b"count\0" as *const u8 as *const libc::c_char,
13720            type_0: ARG_TYPE_INTEGER,
13721            key_spec_index: -(1 as libc::c_int),
13722            token: b"COUNT\0" as *const u8 as *const libc::c_char,
13723            summary: 0 as *const libc::c_char,
13724            since: 0 as *const libc::c_char,
13725            flags: 0 as libc::c_int,
13726            deprecated_since: 0 as *const libc::c_char,
13727            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13728            num_args: 0,
13729        };
13730        init
13731    },
13732    {
13733        let mut init = redisCommandArg {
13734            name: b"any\0" as *const u8 as *const libc::c_char,
13735            type_0: ARG_TYPE_PURE_TOKEN,
13736            key_spec_index: -(1 as libc::c_int),
13737            token: b"ANY\0" as *const u8 as *const libc::c_char,
13738            summary: 0 as *const libc::c_char,
13739            since: 0 as *const libc::c_char,
13740            flags: (1 as libc::c_int) << 0 as libc::c_int,
13741            deprecated_since: 0 as *const libc::c_char,
13742            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13743            num_args: 0,
13744        };
13745        init
13746    },
13747    {
13748        let mut init = redisCommandArg {
13749            name: 0 as *const libc::c_char,
13750            type_0: ARG_TYPE_STRING,
13751            key_spec_index: 0,
13752            token: 0 as *const libc::c_char,
13753            summary: 0 as *const libc::c_char,
13754            since: 0 as *const libc::c_char,
13755            flags: 0,
13756            deprecated_since: 0 as *const libc::c_char,
13757            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13758            num_args: 0,
13759        };
13760        init
13761    },
13762];
13763#[no_mangle]
13764pub static mut GEOSEARCH_Args: [redisCommandArg; 9] = unsafe {
13765    [
13766        {
13767            let mut init = redisCommandArg {
13768                name: b"key\0" as *const u8 as *const libc::c_char,
13769                type_0: ARG_TYPE_KEY,
13770                key_spec_index: 0 as libc::c_int,
13771                token: 0 as *const libc::c_char,
13772                summary: 0 as *const libc::c_char,
13773                since: 0 as *const libc::c_char,
13774                flags: 0 as libc::c_int,
13775                deprecated_since: 0 as *const libc::c_char,
13776                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13777                num_args: 0,
13778            };
13779            init
13780        },
13781        {
13782            let mut init = redisCommandArg {
13783                name: b"from\0" as *const u8 as *const libc::c_char,
13784                type_0: ARG_TYPE_ONEOF,
13785                key_spec_index: -(1 as libc::c_int),
13786                token: 0 as *const libc::c_char,
13787                summary: 0 as *const libc::c_char,
13788                since: 0 as *const libc::c_char,
13789                flags: 0 as libc::c_int,
13790                deprecated_since: 0 as *const libc::c_char,
13791                subargs: GEOSEARCH_from_Subargs.as_ptr() as *mut _,
13792                num_args: 0,
13793            };
13794            init
13795        },
13796        {
13797            let mut init = redisCommandArg {
13798                name: b"by\0" as *const u8 as *const libc::c_char,
13799                type_0: ARG_TYPE_ONEOF,
13800                key_spec_index: -(1 as libc::c_int),
13801                token: 0 as *const libc::c_char,
13802                summary: 0 as *const libc::c_char,
13803                since: 0 as *const libc::c_char,
13804                flags: 0 as libc::c_int,
13805                deprecated_since: 0 as *const libc::c_char,
13806                subargs: GEOSEARCH_by_Subargs.as_ptr() as *mut _,
13807                num_args: 0,
13808            };
13809            init
13810        },
13811        {
13812            let mut init = redisCommandArg {
13813                name: b"order\0" as *const u8 as *const libc::c_char,
13814                type_0: ARG_TYPE_ONEOF,
13815                key_spec_index: -(1 as libc::c_int),
13816                token: 0 as *const libc::c_char,
13817                summary: 0 as *const libc::c_char,
13818                since: 0 as *const libc::c_char,
13819                flags: (1 as libc::c_int) << 0 as libc::c_int,
13820                deprecated_since: 0 as *const libc::c_char,
13821                subargs: GEOSEARCH_order_Subargs.as_ptr() as *mut _,
13822                num_args: 0,
13823            };
13824            init
13825        },
13826        {
13827            let mut init = redisCommandArg {
13828                name: b"count\0" as *const u8 as *const libc::c_char,
13829                type_0: ARG_TYPE_BLOCK,
13830                key_spec_index: -(1 as libc::c_int),
13831                token: 0 as *const libc::c_char,
13832                summary: 0 as *const libc::c_char,
13833                since: 0 as *const libc::c_char,
13834                flags: (1 as libc::c_int) << 0 as libc::c_int,
13835                deprecated_since: 0 as *const libc::c_char,
13836                subargs: GEOSEARCH_count_Subargs.as_ptr() as *mut _,
13837                num_args: 0,
13838            };
13839            init
13840        },
13841        {
13842            let mut init = redisCommandArg {
13843                name: b"withcoord\0" as *const u8 as *const libc::c_char,
13844                type_0: ARG_TYPE_PURE_TOKEN,
13845                key_spec_index: -(1 as libc::c_int),
13846                token: b"WITHCOORD\0" as *const u8 as *const libc::c_char,
13847                summary: 0 as *const libc::c_char,
13848                since: 0 as *const libc::c_char,
13849                flags: (1 as libc::c_int) << 0 as libc::c_int,
13850                deprecated_since: 0 as *const libc::c_char,
13851                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13852                num_args: 0,
13853            };
13854            init
13855        },
13856        {
13857            let mut init = redisCommandArg {
13858                name: b"withdist\0" as *const u8 as *const libc::c_char,
13859                type_0: ARG_TYPE_PURE_TOKEN,
13860                key_spec_index: -(1 as libc::c_int),
13861                token: b"WITHDIST\0" as *const u8 as *const libc::c_char,
13862                summary: 0 as *const libc::c_char,
13863                since: 0 as *const libc::c_char,
13864                flags: (1 as libc::c_int) << 0 as libc::c_int,
13865                deprecated_since: 0 as *const libc::c_char,
13866                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13867                num_args: 0,
13868            };
13869            init
13870        },
13871        {
13872            let mut init = redisCommandArg {
13873                name: b"withhash\0" as *const u8 as *const libc::c_char,
13874                type_0: ARG_TYPE_PURE_TOKEN,
13875                key_spec_index: -(1 as libc::c_int),
13876                token: b"WITHHASH\0" as *const u8 as *const libc::c_char,
13877                summary: 0 as *const libc::c_char,
13878                since: 0 as *const libc::c_char,
13879                flags: (1 as libc::c_int) << 0 as libc::c_int,
13880                deprecated_since: 0 as *const libc::c_char,
13881                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13882                num_args: 0,
13883            };
13884            init
13885        },
13886        {
13887            let mut init = redisCommandArg {
13888                name: 0 as *const libc::c_char,
13889                type_0: ARG_TYPE_STRING,
13890                key_spec_index: 0,
13891                token: 0 as *const libc::c_char,
13892                summary: 0 as *const libc::c_char,
13893                since: 0 as *const libc::c_char,
13894                flags: 0,
13895                deprecated_since: 0 as *const libc::c_char,
13896                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13897                num_args: 0,
13898            };
13899            init
13900        },
13901    ]
13902};
13903#[no_mangle]
13904pub static mut GEOSEARCHSTORE_History: [commandHistory; 2] = [
13905    {
13906        let mut init = commandHistory {
13907            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
13908            changes: b"Added support for uppercase unit names.\0" as *const u8
13909                as *const libc::c_char,
13910        };
13911        init
13912    },
13913    {
13914        let mut init = commandHistory {
13915            since: 0 as *const libc::c_char,
13916            changes: 0 as *const libc::c_char,
13917        };
13918        init
13919    },
13920];
13921#[no_mangle]
13922pub static mut GEOSEARCHSTORE_from_longitude_latitude_Subargs: [redisCommandArg; 3] = [
13923    {
13924        let mut init = redisCommandArg {
13925            name: b"longitude\0" as *const u8 as *const libc::c_char,
13926            type_0: ARG_TYPE_DOUBLE,
13927            key_spec_index: -(1 as libc::c_int),
13928            token: 0 as *const libc::c_char,
13929            summary: 0 as *const libc::c_char,
13930            since: 0 as *const libc::c_char,
13931            flags: 0 as libc::c_int,
13932            deprecated_since: 0 as *const libc::c_char,
13933            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13934            num_args: 0,
13935        };
13936        init
13937    },
13938    {
13939        let mut init = redisCommandArg {
13940            name: b"latitude\0" as *const u8 as *const libc::c_char,
13941            type_0: ARG_TYPE_DOUBLE,
13942            key_spec_index: -(1 as libc::c_int),
13943            token: 0 as *const libc::c_char,
13944            summary: 0 as *const libc::c_char,
13945            since: 0 as *const libc::c_char,
13946            flags: 0 as libc::c_int,
13947            deprecated_since: 0 as *const libc::c_char,
13948            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13949            num_args: 0,
13950        };
13951        init
13952    },
13953    {
13954        let mut init = redisCommandArg {
13955            name: 0 as *const libc::c_char,
13956            type_0: ARG_TYPE_STRING,
13957            key_spec_index: 0,
13958            token: 0 as *const libc::c_char,
13959            summary: 0 as *const libc::c_char,
13960            since: 0 as *const libc::c_char,
13961            flags: 0,
13962            deprecated_since: 0 as *const libc::c_char,
13963            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13964            num_args: 0,
13965        };
13966        init
13967    },
13968];
13969#[no_mangle]
13970pub static mut GEOSEARCHSTORE_from_Subargs: [redisCommandArg; 3] = unsafe {
13971    [
13972        {
13973            let mut init = redisCommandArg {
13974                name: b"member\0" as *const u8 as *const libc::c_char,
13975                type_0: ARG_TYPE_STRING,
13976                key_spec_index: -(1 as libc::c_int),
13977                token: b"FROMMEMBER\0" as *const u8 as *const libc::c_char,
13978                summary: 0 as *const libc::c_char,
13979                since: 0 as *const libc::c_char,
13980                flags: 0 as libc::c_int,
13981                deprecated_since: 0 as *const libc::c_char,
13982                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
13983                num_args: 0,
13984            };
13985            init
13986        },
13987        {
13988            let mut init = redisCommandArg {
13989                name: b"longitude_latitude\0" as *const u8 as *const libc::c_char,
13990                type_0: ARG_TYPE_BLOCK,
13991                key_spec_index: -(1 as libc::c_int),
13992                token: b"FROMLONLAT\0" as *const u8 as *const libc::c_char,
13993                summary: 0 as *const libc::c_char,
13994                since: 0 as *const libc::c_char,
13995                flags: 0 as libc::c_int,
13996                deprecated_since: 0 as *const libc::c_char,
13997                subargs: GEOSEARCHSTORE_from_longitude_latitude_Subargs.as_ptr()
13998                    as *mut _,
13999                num_args: 0,
14000            };
14001            init
14002        },
14003        {
14004            let mut init = redisCommandArg {
14005                name: 0 as *const libc::c_char,
14006                type_0: ARG_TYPE_STRING,
14007                key_spec_index: 0,
14008                token: 0 as *const libc::c_char,
14009                summary: 0 as *const libc::c_char,
14010                since: 0 as *const libc::c_char,
14011                flags: 0,
14012                deprecated_since: 0 as *const libc::c_char,
14013                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14014                num_args: 0,
14015            };
14016            init
14017        },
14018    ]
14019};
14020#[no_mangle]
14021pub static mut GEOSEARCHSTORE_by_circle_unit_Subargs: [redisCommandArg; 5] = [
14022    {
14023        let mut init = redisCommandArg {
14024            name: b"m\0" as *const u8 as *const libc::c_char,
14025            type_0: ARG_TYPE_PURE_TOKEN,
14026            key_spec_index: -(1 as libc::c_int),
14027            token: b"M\0" as *const u8 as *const libc::c_char,
14028            summary: 0 as *const libc::c_char,
14029            since: 0 as *const libc::c_char,
14030            flags: 0 as libc::c_int,
14031            deprecated_since: 0 as *const libc::c_char,
14032            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14033            num_args: 0,
14034        };
14035        init
14036    },
14037    {
14038        let mut init = redisCommandArg {
14039            name: b"km\0" as *const u8 as *const libc::c_char,
14040            type_0: ARG_TYPE_PURE_TOKEN,
14041            key_spec_index: -(1 as libc::c_int),
14042            token: b"KM\0" as *const u8 as *const libc::c_char,
14043            summary: 0 as *const libc::c_char,
14044            since: 0 as *const libc::c_char,
14045            flags: 0 as libc::c_int,
14046            deprecated_since: 0 as *const libc::c_char,
14047            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14048            num_args: 0,
14049        };
14050        init
14051    },
14052    {
14053        let mut init = redisCommandArg {
14054            name: b"ft\0" as *const u8 as *const libc::c_char,
14055            type_0: ARG_TYPE_PURE_TOKEN,
14056            key_spec_index: -(1 as libc::c_int),
14057            token: b"FT\0" as *const u8 as *const libc::c_char,
14058            summary: 0 as *const libc::c_char,
14059            since: 0 as *const libc::c_char,
14060            flags: 0 as libc::c_int,
14061            deprecated_since: 0 as *const libc::c_char,
14062            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14063            num_args: 0,
14064        };
14065        init
14066    },
14067    {
14068        let mut init = redisCommandArg {
14069            name: b"mi\0" as *const u8 as *const libc::c_char,
14070            type_0: ARG_TYPE_PURE_TOKEN,
14071            key_spec_index: -(1 as libc::c_int),
14072            token: b"MI\0" as *const u8 as *const libc::c_char,
14073            summary: 0 as *const libc::c_char,
14074            since: 0 as *const libc::c_char,
14075            flags: 0 as libc::c_int,
14076            deprecated_since: 0 as *const libc::c_char,
14077            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14078            num_args: 0,
14079        };
14080        init
14081    },
14082    {
14083        let mut init = redisCommandArg {
14084            name: 0 as *const libc::c_char,
14085            type_0: ARG_TYPE_STRING,
14086            key_spec_index: 0,
14087            token: 0 as *const libc::c_char,
14088            summary: 0 as *const libc::c_char,
14089            since: 0 as *const libc::c_char,
14090            flags: 0,
14091            deprecated_since: 0 as *const libc::c_char,
14092            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14093            num_args: 0,
14094        };
14095        init
14096    },
14097];
14098#[no_mangle]
14099pub static mut GEOSEARCHSTORE_by_circle_Subargs: [redisCommandArg; 3] = unsafe {
14100    [
14101        {
14102            let mut init = redisCommandArg {
14103                name: b"radius\0" as *const u8 as *const libc::c_char,
14104                type_0: ARG_TYPE_DOUBLE,
14105                key_spec_index: -(1 as libc::c_int),
14106                token: b"BYRADIUS\0" as *const u8 as *const libc::c_char,
14107                summary: 0 as *const libc::c_char,
14108                since: 0 as *const libc::c_char,
14109                flags: 0 as libc::c_int,
14110                deprecated_since: 0 as *const libc::c_char,
14111                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14112                num_args: 0,
14113            };
14114            init
14115        },
14116        {
14117            let mut init = redisCommandArg {
14118                name: b"unit\0" as *const u8 as *const libc::c_char,
14119                type_0: ARG_TYPE_ONEOF,
14120                key_spec_index: -(1 as libc::c_int),
14121                token: 0 as *const libc::c_char,
14122                summary: 0 as *const libc::c_char,
14123                since: 0 as *const libc::c_char,
14124                flags: 0 as libc::c_int,
14125                deprecated_since: 0 as *const libc::c_char,
14126                subargs: GEOSEARCHSTORE_by_circle_unit_Subargs.as_ptr() as *mut _,
14127                num_args: 0,
14128            };
14129            init
14130        },
14131        {
14132            let mut init = redisCommandArg {
14133                name: 0 as *const libc::c_char,
14134                type_0: ARG_TYPE_STRING,
14135                key_spec_index: 0,
14136                token: 0 as *const libc::c_char,
14137                summary: 0 as *const libc::c_char,
14138                since: 0 as *const libc::c_char,
14139                flags: 0,
14140                deprecated_since: 0 as *const libc::c_char,
14141                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14142                num_args: 0,
14143            };
14144            init
14145        },
14146    ]
14147};
14148#[no_mangle]
14149pub static mut GEOSEARCHSTORE_by_box_unit_Subargs: [redisCommandArg; 5] = [
14150    {
14151        let mut init = redisCommandArg {
14152            name: b"m\0" as *const u8 as *const libc::c_char,
14153            type_0: ARG_TYPE_PURE_TOKEN,
14154            key_spec_index: -(1 as libc::c_int),
14155            token: b"M\0" as *const u8 as *const libc::c_char,
14156            summary: 0 as *const libc::c_char,
14157            since: 0 as *const libc::c_char,
14158            flags: 0 as libc::c_int,
14159            deprecated_since: 0 as *const libc::c_char,
14160            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14161            num_args: 0,
14162        };
14163        init
14164    },
14165    {
14166        let mut init = redisCommandArg {
14167            name: b"km\0" as *const u8 as *const libc::c_char,
14168            type_0: ARG_TYPE_PURE_TOKEN,
14169            key_spec_index: -(1 as libc::c_int),
14170            token: b"KM\0" as *const u8 as *const libc::c_char,
14171            summary: 0 as *const libc::c_char,
14172            since: 0 as *const libc::c_char,
14173            flags: 0 as libc::c_int,
14174            deprecated_since: 0 as *const libc::c_char,
14175            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14176            num_args: 0,
14177        };
14178        init
14179    },
14180    {
14181        let mut init = redisCommandArg {
14182            name: b"ft\0" as *const u8 as *const libc::c_char,
14183            type_0: ARG_TYPE_PURE_TOKEN,
14184            key_spec_index: -(1 as libc::c_int),
14185            token: b"FT\0" as *const u8 as *const libc::c_char,
14186            summary: 0 as *const libc::c_char,
14187            since: 0 as *const libc::c_char,
14188            flags: 0 as libc::c_int,
14189            deprecated_since: 0 as *const libc::c_char,
14190            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14191            num_args: 0,
14192        };
14193        init
14194    },
14195    {
14196        let mut init = redisCommandArg {
14197            name: b"mi\0" as *const u8 as *const libc::c_char,
14198            type_0: ARG_TYPE_PURE_TOKEN,
14199            key_spec_index: -(1 as libc::c_int),
14200            token: b"MI\0" as *const u8 as *const libc::c_char,
14201            summary: 0 as *const libc::c_char,
14202            since: 0 as *const libc::c_char,
14203            flags: 0 as libc::c_int,
14204            deprecated_since: 0 as *const libc::c_char,
14205            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14206            num_args: 0,
14207        };
14208        init
14209    },
14210    {
14211        let mut init = redisCommandArg {
14212            name: 0 as *const libc::c_char,
14213            type_0: ARG_TYPE_STRING,
14214            key_spec_index: 0,
14215            token: 0 as *const libc::c_char,
14216            summary: 0 as *const libc::c_char,
14217            since: 0 as *const libc::c_char,
14218            flags: 0,
14219            deprecated_since: 0 as *const libc::c_char,
14220            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14221            num_args: 0,
14222        };
14223        init
14224    },
14225];
14226#[no_mangle]
14227pub static mut GEOSEARCHSTORE_by_box_Subargs: [redisCommandArg; 4] = unsafe {
14228    [
14229        {
14230            let mut init = redisCommandArg {
14231                name: b"width\0" as *const u8 as *const libc::c_char,
14232                type_0: ARG_TYPE_DOUBLE,
14233                key_spec_index: -(1 as libc::c_int),
14234                token: b"BYBOX\0" as *const u8 as *const libc::c_char,
14235                summary: 0 as *const libc::c_char,
14236                since: 0 as *const libc::c_char,
14237                flags: 0 as libc::c_int,
14238                deprecated_since: 0 as *const libc::c_char,
14239                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14240                num_args: 0,
14241            };
14242            init
14243        },
14244        {
14245            let mut init = redisCommandArg {
14246                name: b"height\0" as *const u8 as *const libc::c_char,
14247                type_0: ARG_TYPE_DOUBLE,
14248                key_spec_index: -(1 as libc::c_int),
14249                token: 0 as *const libc::c_char,
14250                summary: 0 as *const libc::c_char,
14251                since: 0 as *const libc::c_char,
14252                flags: 0 as libc::c_int,
14253                deprecated_since: 0 as *const libc::c_char,
14254                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14255                num_args: 0,
14256            };
14257            init
14258        },
14259        {
14260            let mut init = redisCommandArg {
14261                name: b"unit\0" as *const u8 as *const libc::c_char,
14262                type_0: ARG_TYPE_ONEOF,
14263                key_spec_index: -(1 as libc::c_int),
14264                token: 0 as *const libc::c_char,
14265                summary: 0 as *const libc::c_char,
14266                since: 0 as *const libc::c_char,
14267                flags: 0 as libc::c_int,
14268                deprecated_since: 0 as *const libc::c_char,
14269                subargs: GEOSEARCHSTORE_by_box_unit_Subargs.as_ptr() as *mut _,
14270                num_args: 0,
14271            };
14272            init
14273        },
14274        {
14275            let mut init = redisCommandArg {
14276                name: 0 as *const libc::c_char,
14277                type_0: ARG_TYPE_STRING,
14278                key_spec_index: 0,
14279                token: 0 as *const libc::c_char,
14280                summary: 0 as *const libc::c_char,
14281                since: 0 as *const libc::c_char,
14282                flags: 0,
14283                deprecated_since: 0 as *const libc::c_char,
14284                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14285                num_args: 0,
14286            };
14287            init
14288        },
14289    ]
14290};
14291#[no_mangle]
14292pub static mut GEOSEARCHSTORE_by_Subargs: [redisCommandArg; 3] = unsafe {
14293    [
14294        {
14295            let mut init = redisCommandArg {
14296                name: b"circle\0" as *const u8 as *const libc::c_char,
14297                type_0: ARG_TYPE_BLOCK,
14298                key_spec_index: -(1 as libc::c_int),
14299                token: 0 as *const libc::c_char,
14300                summary: 0 as *const libc::c_char,
14301                since: 0 as *const libc::c_char,
14302                flags: 0 as libc::c_int,
14303                deprecated_since: 0 as *const libc::c_char,
14304                subargs: GEOSEARCHSTORE_by_circle_Subargs.as_ptr() as *mut _,
14305                num_args: 0,
14306            };
14307            init
14308        },
14309        {
14310            let mut init = redisCommandArg {
14311                name: b"box\0" as *const u8 as *const libc::c_char,
14312                type_0: ARG_TYPE_BLOCK,
14313                key_spec_index: -(1 as libc::c_int),
14314                token: 0 as *const libc::c_char,
14315                summary: 0 as *const libc::c_char,
14316                since: 0 as *const libc::c_char,
14317                flags: 0 as libc::c_int,
14318                deprecated_since: 0 as *const libc::c_char,
14319                subargs: GEOSEARCHSTORE_by_box_Subargs.as_ptr() as *mut _,
14320                num_args: 0,
14321            };
14322            init
14323        },
14324        {
14325            let mut init = redisCommandArg {
14326                name: 0 as *const libc::c_char,
14327                type_0: ARG_TYPE_STRING,
14328                key_spec_index: 0,
14329                token: 0 as *const libc::c_char,
14330                summary: 0 as *const libc::c_char,
14331                since: 0 as *const libc::c_char,
14332                flags: 0,
14333                deprecated_since: 0 as *const libc::c_char,
14334                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14335                num_args: 0,
14336            };
14337            init
14338        },
14339    ]
14340};
14341#[no_mangle]
14342pub static mut GEOSEARCHSTORE_order_Subargs: [redisCommandArg; 3] = [
14343    {
14344        let mut init = redisCommandArg {
14345            name: b"asc\0" as *const u8 as *const libc::c_char,
14346            type_0: ARG_TYPE_PURE_TOKEN,
14347            key_spec_index: -(1 as libc::c_int),
14348            token: b"ASC\0" as *const u8 as *const libc::c_char,
14349            summary: 0 as *const libc::c_char,
14350            since: 0 as *const libc::c_char,
14351            flags: 0 as libc::c_int,
14352            deprecated_since: 0 as *const libc::c_char,
14353            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14354            num_args: 0,
14355        };
14356        init
14357    },
14358    {
14359        let mut init = redisCommandArg {
14360            name: b"desc\0" as *const u8 as *const libc::c_char,
14361            type_0: ARG_TYPE_PURE_TOKEN,
14362            key_spec_index: -(1 as libc::c_int),
14363            token: b"DESC\0" as *const u8 as *const libc::c_char,
14364            summary: 0 as *const libc::c_char,
14365            since: 0 as *const libc::c_char,
14366            flags: 0 as libc::c_int,
14367            deprecated_since: 0 as *const libc::c_char,
14368            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14369            num_args: 0,
14370        };
14371        init
14372    },
14373    {
14374        let mut init = redisCommandArg {
14375            name: 0 as *const libc::c_char,
14376            type_0: ARG_TYPE_STRING,
14377            key_spec_index: 0,
14378            token: 0 as *const libc::c_char,
14379            summary: 0 as *const libc::c_char,
14380            since: 0 as *const libc::c_char,
14381            flags: 0,
14382            deprecated_since: 0 as *const libc::c_char,
14383            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14384            num_args: 0,
14385        };
14386        init
14387    },
14388];
14389#[no_mangle]
14390pub static mut GEOSEARCHSTORE_count_Subargs: [redisCommandArg; 3] = [
14391    {
14392        let mut init = redisCommandArg {
14393            name: b"count\0" as *const u8 as *const libc::c_char,
14394            type_0: ARG_TYPE_INTEGER,
14395            key_spec_index: -(1 as libc::c_int),
14396            token: b"COUNT\0" as *const u8 as *const libc::c_char,
14397            summary: 0 as *const libc::c_char,
14398            since: 0 as *const libc::c_char,
14399            flags: 0 as libc::c_int,
14400            deprecated_since: 0 as *const libc::c_char,
14401            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14402            num_args: 0,
14403        };
14404        init
14405    },
14406    {
14407        let mut init = redisCommandArg {
14408            name: b"any\0" as *const u8 as *const libc::c_char,
14409            type_0: ARG_TYPE_PURE_TOKEN,
14410            key_spec_index: -(1 as libc::c_int),
14411            token: b"ANY\0" as *const u8 as *const libc::c_char,
14412            summary: 0 as *const libc::c_char,
14413            since: 0 as *const libc::c_char,
14414            flags: (1 as libc::c_int) << 0 as libc::c_int,
14415            deprecated_since: 0 as *const libc::c_char,
14416            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14417            num_args: 0,
14418        };
14419        init
14420    },
14421    {
14422        let mut init = redisCommandArg {
14423            name: 0 as *const libc::c_char,
14424            type_0: ARG_TYPE_STRING,
14425            key_spec_index: 0,
14426            token: 0 as *const libc::c_char,
14427            summary: 0 as *const libc::c_char,
14428            since: 0 as *const libc::c_char,
14429            flags: 0,
14430            deprecated_since: 0 as *const libc::c_char,
14431            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14432            num_args: 0,
14433        };
14434        init
14435    },
14436];
14437#[no_mangle]
14438pub static mut GEOSEARCHSTORE_Args: [redisCommandArg; 8] = unsafe {
14439    [
14440        {
14441            let mut init = redisCommandArg {
14442                name: b"destination\0" as *const u8 as *const libc::c_char,
14443                type_0: ARG_TYPE_KEY,
14444                key_spec_index: 0 as libc::c_int,
14445                token: 0 as *const libc::c_char,
14446                summary: 0 as *const libc::c_char,
14447                since: 0 as *const libc::c_char,
14448                flags: 0 as libc::c_int,
14449                deprecated_since: 0 as *const libc::c_char,
14450                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14451                num_args: 0,
14452            };
14453            init
14454        },
14455        {
14456            let mut init = redisCommandArg {
14457                name: b"source\0" as *const u8 as *const libc::c_char,
14458                type_0: ARG_TYPE_KEY,
14459                key_spec_index: 1 as libc::c_int,
14460                token: 0 as *const libc::c_char,
14461                summary: 0 as *const libc::c_char,
14462                since: 0 as *const libc::c_char,
14463                flags: 0 as libc::c_int,
14464                deprecated_since: 0 as *const libc::c_char,
14465                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14466                num_args: 0,
14467            };
14468            init
14469        },
14470        {
14471            let mut init = redisCommandArg {
14472                name: b"from\0" as *const u8 as *const libc::c_char,
14473                type_0: ARG_TYPE_ONEOF,
14474                key_spec_index: -(1 as libc::c_int),
14475                token: 0 as *const libc::c_char,
14476                summary: 0 as *const libc::c_char,
14477                since: 0 as *const libc::c_char,
14478                flags: 0 as libc::c_int,
14479                deprecated_since: 0 as *const libc::c_char,
14480                subargs: GEOSEARCHSTORE_from_Subargs.as_ptr() as *mut _,
14481                num_args: 0,
14482            };
14483            init
14484        },
14485        {
14486            let mut init = redisCommandArg {
14487                name: b"by\0" as *const u8 as *const libc::c_char,
14488                type_0: ARG_TYPE_ONEOF,
14489                key_spec_index: -(1 as libc::c_int),
14490                token: 0 as *const libc::c_char,
14491                summary: 0 as *const libc::c_char,
14492                since: 0 as *const libc::c_char,
14493                flags: 0 as libc::c_int,
14494                deprecated_since: 0 as *const libc::c_char,
14495                subargs: GEOSEARCHSTORE_by_Subargs.as_ptr() as *mut _,
14496                num_args: 0,
14497            };
14498            init
14499        },
14500        {
14501            let mut init = redisCommandArg {
14502                name: b"order\0" as *const u8 as *const libc::c_char,
14503                type_0: ARG_TYPE_ONEOF,
14504                key_spec_index: -(1 as libc::c_int),
14505                token: 0 as *const libc::c_char,
14506                summary: 0 as *const libc::c_char,
14507                since: 0 as *const libc::c_char,
14508                flags: (1 as libc::c_int) << 0 as libc::c_int,
14509                deprecated_since: 0 as *const libc::c_char,
14510                subargs: GEOSEARCHSTORE_order_Subargs.as_ptr() as *mut _,
14511                num_args: 0,
14512            };
14513            init
14514        },
14515        {
14516            let mut init = redisCommandArg {
14517                name: b"count\0" as *const u8 as *const libc::c_char,
14518                type_0: ARG_TYPE_BLOCK,
14519                key_spec_index: -(1 as libc::c_int),
14520                token: 0 as *const libc::c_char,
14521                summary: 0 as *const libc::c_char,
14522                since: 0 as *const libc::c_char,
14523                flags: (1 as libc::c_int) << 0 as libc::c_int,
14524                deprecated_since: 0 as *const libc::c_char,
14525                subargs: GEOSEARCHSTORE_count_Subargs.as_ptr() as *mut _,
14526                num_args: 0,
14527            };
14528            init
14529        },
14530        {
14531            let mut init = redisCommandArg {
14532                name: b"storedist\0" as *const u8 as *const libc::c_char,
14533                type_0: ARG_TYPE_PURE_TOKEN,
14534                key_spec_index: -(1 as libc::c_int),
14535                token: b"STOREDIST\0" as *const u8 as *const libc::c_char,
14536                summary: 0 as *const libc::c_char,
14537                since: 0 as *const libc::c_char,
14538                flags: (1 as libc::c_int) << 0 as libc::c_int,
14539                deprecated_since: 0 as *const libc::c_char,
14540                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14541                num_args: 0,
14542            };
14543            init
14544        },
14545        {
14546            let mut init = redisCommandArg {
14547                name: 0 as *const libc::c_char,
14548                type_0: ARG_TYPE_STRING,
14549                key_spec_index: 0,
14550                token: 0 as *const libc::c_char,
14551                summary: 0 as *const libc::c_char,
14552                since: 0 as *const libc::c_char,
14553                flags: 0,
14554                deprecated_since: 0 as *const libc::c_char,
14555                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14556                num_args: 0,
14557            };
14558            init
14559        },
14560    ]
14561};
14562#[no_mangle]
14563pub static mut HDEL_History: [commandHistory; 2] = [
14564    {
14565        let mut init = commandHistory {
14566            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
14567            changes: b"Accepts multiple `field` arguments.\0" as *const u8
14568                as *const libc::c_char,
14569        };
14570        init
14571    },
14572    {
14573        let mut init = commandHistory {
14574            since: 0 as *const libc::c_char,
14575            changes: 0 as *const libc::c_char,
14576        };
14577        init
14578    },
14579];
14580#[no_mangle]
14581pub static mut HDEL_Args: [redisCommandArg; 3] = [
14582    {
14583        let mut init = redisCommandArg {
14584            name: b"key\0" as *const u8 as *const libc::c_char,
14585            type_0: ARG_TYPE_KEY,
14586            key_spec_index: 0 as libc::c_int,
14587            token: 0 as *const libc::c_char,
14588            summary: 0 as *const libc::c_char,
14589            since: 0 as *const libc::c_char,
14590            flags: 0 as libc::c_int,
14591            deprecated_since: 0 as *const libc::c_char,
14592            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14593            num_args: 0,
14594        };
14595        init
14596    },
14597    {
14598        let mut init = redisCommandArg {
14599            name: b"field\0" as *const u8 as *const libc::c_char,
14600            type_0: ARG_TYPE_STRING,
14601            key_spec_index: -(1 as libc::c_int),
14602            token: 0 as *const libc::c_char,
14603            summary: 0 as *const libc::c_char,
14604            since: 0 as *const libc::c_char,
14605            flags: (1 as libc::c_int) << 1 as libc::c_int,
14606            deprecated_since: 0 as *const libc::c_char,
14607            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14608            num_args: 0,
14609        };
14610        init
14611    },
14612    {
14613        let mut init = redisCommandArg {
14614            name: 0 as *const libc::c_char,
14615            type_0: ARG_TYPE_STRING,
14616            key_spec_index: 0,
14617            token: 0 as *const libc::c_char,
14618            summary: 0 as *const libc::c_char,
14619            since: 0 as *const libc::c_char,
14620            flags: 0,
14621            deprecated_since: 0 as *const libc::c_char,
14622            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14623            num_args: 0,
14624        };
14625        init
14626    },
14627];
14628#[no_mangle]
14629pub static mut HEXISTS_Args: [redisCommandArg; 3] = [
14630    {
14631        let mut init = redisCommandArg {
14632            name: b"key\0" as *const u8 as *const libc::c_char,
14633            type_0: ARG_TYPE_KEY,
14634            key_spec_index: 0 as libc::c_int,
14635            token: 0 as *const libc::c_char,
14636            summary: 0 as *const libc::c_char,
14637            since: 0 as *const libc::c_char,
14638            flags: 0 as libc::c_int,
14639            deprecated_since: 0 as *const libc::c_char,
14640            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14641            num_args: 0,
14642        };
14643        init
14644    },
14645    {
14646        let mut init = redisCommandArg {
14647            name: b"field\0" as *const u8 as *const libc::c_char,
14648            type_0: ARG_TYPE_STRING,
14649            key_spec_index: -(1 as libc::c_int),
14650            token: 0 as *const libc::c_char,
14651            summary: 0 as *const libc::c_char,
14652            since: 0 as *const libc::c_char,
14653            flags: 0 as libc::c_int,
14654            deprecated_since: 0 as *const libc::c_char,
14655            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14656            num_args: 0,
14657        };
14658        init
14659    },
14660    {
14661        let mut init = redisCommandArg {
14662            name: 0 as *const libc::c_char,
14663            type_0: ARG_TYPE_STRING,
14664            key_spec_index: 0,
14665            token: 0 as *const libc::c_char,
14666            summary: 0 as *const libc::c_char,
14667            since: 0 as *const libc::c_char,
14668            flags: 0,
14669            deprecated_since: 0 as *const libc::c_char,
14670            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14671            num_args: 0,
14672        };
14673        init
14674    },
14675];
14676#[no_mangle]
14677pub static mut HGET_Args: [redisCommandArg; 3] = [
14678    {
14679        let mut init = redisCommandArg {
14680            name: b"key\0" as *const u8 as *const libc::c_char,
14681            type_0: ARG_TYPE_KEY,
14682            key_spec_index: 0 as libc::c_int,
14683            token: 0 as *const libc::c_char,
14684            summary: 0 as *const libc::c_char,
14685            since: 0 as *const libc::c_char,
14686            flags: 0 as libc::c_int,
14687            deprecated_since: 0 as *const libc::c_char,
14688            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14689            num_args: 0,
14690        };
14691        init
14692    },
14693    {
14694        let mut init = redisCommandArg {
14695            name: b"field\0" as *const u8 as *const libc::c_char,
14696            type_0: ARG_TYPE_STRING,
14697            key_spec_index: -(1 as libc::c_int),
14698            token: 0 as *const libc::c_char,
14699            summary: 0 as *const libc::c_char,
14700            since: 0 as *const libc::c_char,
14701            flags: 0 as libc::c_int,
14702            deprecated_since: 0 as *const libc::c_char,
14703            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14704            num_args: 0,
14705        };
14706        init
14707    },
14708    {
14709        let mut init = redisCommandArg {
14710            name: 0 as *const libc::c_char,
14711            type_0: ARG_TYPE_STRING,
14712            key_spec_index: 0,
14713            token: 0 as *const libc::c_char,
14714            summary: 0 as *const libc::c_char,
14715            since: 0 as *const libc::c_char,
14716            flags: 0,
14717            deprecated_since: 0 as *const libc::c_char,
14718            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14719            num_args: 0,
14720        };
14721        init
14722    },
14723];
14724#[no_mangle]
14725pub static mut HGETALL_tips: [*const libc::c_char; 2] = [
14726    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
14727    0 as *const libc::c_char,
14728];
14729#[no_mangle]
14730pub static mut HGETALL_Args: [redisCommandArg; 2] = [
14731    {
14732        let mut init = redisCommandArg {
14733            name: b"key\0" as *const u8 as *const libc::c_char,
14734            type_0: ARG_TYPE_KEY,
14735            key_spec_index: 0 as libc::c_int,
14736            token: 0 as *const libc::c_char,
14737            summary: 0 as *const libc::c_char,
14738            since: 0 as *const libc::c_char,
14739            flags: 0 as libc::c_int,
14740            deprecated_since: 0 as *const libc::c_char,
14741            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14742            num_args: 0,
14743        };
14744        init
14745    },
14746    {
14747        let mut init = redisCommandArg {
14748            name: 0 as *const libc::c_char,
14749            type_0: ARG_TYPE_STRING,
14750            key_spec_index: 0,
14751            token: 0 as *const libc::c_char,
14752            summary: 0 as *const libc::c_char,
14753            since: 0 as *const libc::c_char,
14754            flags: 0,
14755            deprecated_since: 0 as *const libc::c_char,
14756            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14757            num_args: 0,
14758        };
14759        init
14760    },
14761];
14762#[no_mangle]
14763pub static mut HINCRBY_Args: [redisCommandArg; 4] = [
14764    {
14765        let mut init = redisCommandArg {
14766            name: b"key\0" as *const u8 as *const libc::c_char,
14767            type_0: ARG_TYPE_KEY,
14768            key_spec_index: 0 as libc::c_int,
14769            token: 0 as *const libc::c_char,
14770            summary: 0 as *const libc::c_char,
14771            since: 0 as *const libc::c_char,
14772            flags: 0 as libc::c_int,
14773            deprecated_since: 0 as *const libc::c_char,
14774            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14775            num_args: 0,
14776        };
14777        init
14778    },
14779    {
14780        let mut init = redisCommandArg {
14781            name: b"field\0" as *const u8 as *const libc::c_char,
14782            type_0: ARG_TYPE_STRING,
14783            key_spec_index: -(1 as libc::c_int),
14784            token: 0 as *const libc::c_char,
14785            summary: 0 as *const libc::c_char,
14786            since: 0 as *const libc::c_char,
14787            flags: 0 as libc::c_int,
14788            deprecated_since: 0 as *const libc::c_char,
14789            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14790            num_args: 0,
14791        };
14792        init
14793    },
14794    {
14795        let mut init = redisCommandArg {
14796            name: b"increment\0" as *const u8 as *const libc::c_char,
14797            type_0: ARG_TYPE_INTEGER,
14798            key_spec_index: -(1 as libc::c_int),
14799            token: 0 as *const libc::c_char,
14800            summary: 0 as *const libc::c_char,
14801            since: 0 as *const libc::c_char,
14802            flags: 0 as libc::c_int,
14803            deprecated_since: 0 as *const libc::c_char,
14804            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14805            num_args: 0,
14806        };
14807        init
14808    },
14809    {
14810        let mut init = redisCommandArg {
14811            name: 0 as *const libc::c_char,
14812            type_0: ARG_TYPE_STRING,
14813            key_spec_index: 0,
14814            token: 0 as *const libc::c_char,
14815            summary: 0 as *const libc::c_char,
14816            since: 0 as *const libc::c_char,
14817            flags: 0,
14818            deprecated_since: 0 as *const libc::c_char,
14819            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14820            num_args: 0,
14821        };
14822        init
14823    },
14824];
14825#[no_mangle]
14826pub static mut HINCRBYFLOAT_Args: [redisCommandArg; 4] = [
14827    {
14828        let mut init = redisCommandArg {
14829            name: b"key\0" as *const u8 as *const libc::c_char,
14830            type_0: ARG_TYPE_KEY,
14831            key_spec_index: 0 as libc::c_int,
14832            token: 0 as *const libc::c_char,
14833            summary: 0 as *const libc::c_char,
14834            since: 0 as *const libc::c_char,
14835            flags: 0 as libc::c_int,
14836            deprecated_since: 0 as *const libc::c_char,
14837            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14838            num_args: 0,
14839        };
14840        init
14841    },
14842    {
14843        let mut init = redisCommandArg {
14844            name: b"field\0" as *const u8 as *const libc::c_char,
14845            type_0: ARG_TYPE_STRING,
14846            key_spec_index: -(1 as libc::c_int),
14847            token: 0 as *const libc::c_char,
14848            summary: 0 as *const libc::c_char,
14849            since: 0 as *const libc::c_char,
14850            flags: 0 as libc::c_int,
14851            deprecated_since: 0 as *const libc::c_char,
14852            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14853            num_args: 0,
14854        };
14855        init
14856    },
14857    {
14858        let mut init = redisCommandArg {
14859            name: b"increment\0" as *const u8 as *const libc::c_char,
14860            type_0: ARG_TYPE_DOUBLE,
14861            key_spec_index: -(1 as libc::c_int),
14862            token: 0 as *const libc::c_char,
14863            summary: 0 as *const libc::c_char,
14864            since: 0 as *const libc::c_char,
14865            flags: 0 as libc::c_int,
14866            deprecated_since: 0 as *const libc::c_char,
14867            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14868            num_args: 0,
14869        };
14870        init
14871    },
14872    {
14873        let mut init = redisCommandArg {
14874            name: 0 as *const libc::c_char,
14875            type_0: ARG_TYPE_STRING,
14876            key_spec_index: 0,
14877            token: 0 as *const libc::c_char,
14878            summary: 0 as *const libc::c_char,
14879            since: 0 as *const libc::c_char,
14880            flags: 0,
14881            deprecated_since: 0 as *const libc::c_char,
14882            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14883            num_args: 0,
14884        };
14885        init
14886    },
14887];
14888#[no_mangle]
14889pub static mut HKEYS_tips: [*const libc::c_char; 2] = [
14890    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
14891    0 as *const libc::c_char,
14892];
14893#[no_mangle]
14894pub static mut HKEYS_Args: [redisCommandArg; 2] = [
14895    {
14896        let mut init = redisCommandArg {
14897            name: b"key\0" as *const u8 as *const libc::c_char,
14898            type_0: ARG_TYPE_KEY,
14899            key_spec_index: 0 as libc::c_int,
14900            token: 0 as *const libc::c_char,
14901            summary: 0 as *const libc::c_char,
14902            since: 0 as *const libc::c_char,
14903            flags: 0 as libc::c_int,
14904            deprecated_since: 0 as *const libc::c_char,
14905            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14906            num_args: 0,
14907        };
14908        init
14909    },
14910    {
14911        let mut init = redisCommandArg {
14912            name: 0 as *const libc::c_char,
14913            type_0: ARG_TYPE_STRING,
14914            key_spec_index: 0,
14915            token: 0 as *const libc::c_char,
14916            summary: 0 as *const libc::c_char,
14917            since: 0 as *const libc::c_char,
14918            flags: 0,
14919            deprecated_since: 0 as *const libc::c_char,
14920            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14921            num_args: 0,
14922        };
14923        init
14924    },
14925];
14926#[no_mangle]
14927pub static mut HLEN_Args: [redisCommandArg; 2] = [
14928    {
14929        let mut init = redisCommandArg {
14930            name: b"key\0" as *const u8 as *const libc::c_char,
14931            type_0: ARG_TYPE_KEY,
14932            key_spec_index: 0 as libc::c_int,
14933            token: 0 as *const libc::c_char,
14934            summary: 0 as *const libc::c_char,
14935            since: 0 as *const libc::c_char,
14936            flags: 0 as libc::c_int,
14937            deprecated_since: 0 as *const libc::c_char,
14938            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14939            num_args: 0,
14940        };
14941        init
14942    },
14943    {
14944        let mut init = redisCommandArg {
14945            name: 0 as *const libc::c_char,
14946            type_0: ARG_TYPE_STRING,
14947            key_spec_index: 0,
14948            token: 0 as *const libc::c_char,
14949            summary: 0 as *const libc::c_char,
14950            since: 0 as *const libc::c_char,
14951            flags: 0,
14952            deprecated_since: 0 as *const libc::c_char,
14953            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14954            num_args: 0,
14955        };
14956        init
14957    },
14958];
14959#[no_mangle]
14960pub static mut HMGET_Args: [redisCommandArg; 3] = [
14961    {
14962        let mut init = redisCommandArg {
14963            name: b"key\0" as *const u8 as *const libc::c_char,
14964            type_0: ARG_TYPE_KEY,
14965            key_spec_index: 0 as libc::c_int,
14966            token: 0 as *const libc::c_char,
14967            summary: 0 as *const libc::c_char,
14968            since: 0 as *const libc::c_char,
14969            flags: 0 as libc::c_int,
14970            deprecated_since: 0 as *const libc::c_char,
14971            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14972            num_args: 0,
14973        };
14974        init
14975    },
14976    {
14977        let mut init = redisCommandArg {
14978            name: b"field\0" as *const u8 as *const libc::c_char,
14979            type_0: ARG_TYPE_STRING,
14980            key_spec_index: -(1 as libc::c_int),
14981            token: 0 as *const libc::c_char,
14982            summary: 0 as *const libc::c_char,
14983            since: 0 as *const libc::c_char,
14984            flags: (1 as libc::c_int) << 1 as libc::c_int,
14985            deprecated_since: 0 as *const libc::c_char,
14986            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
14987            num_args: 0,
14988        };
14989        init
14990    },
14991    {
14992        let mut init = redisCommandArg {
14993            name: 0 as *const libc::c_char,
14994            type_0: ARG_TYPE_STRING,
14995            key_spec_index: 0,
14996            token: 0 as *const libc::c_char,
14997            summary: 0 as *const libc::c_char,
14998            since: 0 as *const libc::c_char,
14999            flags: 0,
15000            deprecated_since: 0 as *const libc::c_char,
15001            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15002            num_args: 0,
15003        };
15004        init
15005    },
15006];
15007#[no_mangle]
15008pub static mut HMSET_field_value_Subargs: [redisCommandArg; 3] = [
15009    {
15010        let mut init = redisCommandArg {
15011            name: b"field\0" as *const u8 as *const libc::c_char,
15012            type_0: ARG_TYPE_STRING,
15013            key_spec_index: -(1 as libc::c_int),
15014            token: 0 as *const libc::c_char,
15015            summary: 0 as *const libc::c_char,
15016            since: 0 as *const libc::c_char,
15017            flags: 0 as libc::c_int,
15018            deprecated_since: 0 as *const libc::c_char,
15019            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15020            num_args: 0,
15021        };
15022        init
15023    },
15024    {
15025        let mut init = redisCommandArg {
15026            name: b"value\0" as *const u8 as *const libc::c_char,
15027            type_0: ARG_TYPE_STRING,
15028            key_spec_index: -(1 as libc::c_int),
15029            token: 0 as *const libc::c_char,
15030            summary: 0 as *const libc::c_char,
15031            since: 0 as *const libc::c_char,
15032            flags: 0 as libc::c_int,
15033            deprecated_since: 0 as *const libc::c_char,
15034            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15035            num_args: 0,
15036        };
15037        init
15038    },
15039    {
15040        let mut init = redisCommandArg {
15041            name: 0 as *const libc::c_char,
15042            type_0: ARG_TYPE_STRING,
15043            key_spec_index: 0,
15044            token: 0 as *const libc::c_char,
15045            summary: 0 as *const libc::c_char,
15046            since: 0 as *const libc::c_char,
15047            flags: 0,
15048            deprecated_since: 0 as *const libc::c_char,
15049            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15050            num_args: 0,
15051        };
15052        init
15053    },
15054];
15055#[no_mangle]
15056pub static mut HMSET_Args: [redisCommandArg; 3] = unsafe {
15057    [
15058        {
15059            let mut init = redisCommandArg {
15060                name: b"key\0" as *const u8 as *const libc::c_char,
15061                type_0: ARG_TYPE_KEY,
15062                key_spec_index: 0 as libc::c_int,
15063                token: 0 as *const libc::c_char,
15064                summary: 0 as *const libc::c_char,
15065                since: 0 as *const libc::c_char,
15066                flags: 0 as libc::c_int,
15067                deprecated_since: 0 as *const libc::c_char,
15068                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15069                num_args: 0,
15070            };
15071            init
15072        },
15073        {
15074            let mut init = redisCommandArg {
15075                name: b"field_value\0" as *const u8 as *const libc::c_char,
15076                type_0: ARG_TYPE_BLOCK,
15077                key_spec_index: -(1 as libc::c_int),
15078                token: 0 as *const libc::c_char,
15079                summary: 0 as *const libc::c_char,
15080                since: 0 as *const libc::c_char,
15081                flags: (1 as libc::c_int) << 1 as libc::c_int,
15082                deprecated_since: 0 as *const libc::c_char,
15083                subargs: HMSET_field_value_Subargs.as_ptr() as *mut _,
15084                num_args: 0,
15085            };
15086            init
15087        },
15088        {
15089            let mut init = redisCommandArg {
15090                name: 0 as *const libc::c_char,
15091                type_0: ARG_TYPE_STRING,
15092                key_spec_index: 0,
15093                token: 0 as *const libc::c_char,
15094                summary: 0 as *const libc::c_char,
15095                since: 0 as *const libc::c_char,
15096                flags: 0,
15097                deprecated_since: 0 as *const libc::c_char,
15098                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15099                num_args: 0,
15100            };
15101            init
15102        },
15103    ]
15104};
15105#[no_mangle]
15106pub static mut HRANDFIELD_tips: [*const libc::c_char; 2] = [
15107    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
15108    0 as *const libc::c_char,
15109];
15110#[no_mangle]
15111pub static mut HRANDFIELD_options_Subargs: [redisCommandArg; 3] = [
15112    {
15113        let mut init = redisCommandArg {
15114            name: b"count\0" as *const u8 as *const libc::c_char,
15115            type_0: ARG_TYPE_INTEGER,
15116            key_spec_index: -(1 as libc::c_int),
15117            token: 0 as *const libc::c_char,
15118            summary: 0 as *const libc::c_char,
15119            since: 0 as *const libc::c_char,
15120            flags: 0 as libc::c_int,
15121            deprecated_since: 0 as *const libc::c_char,
15122            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15123            num_args: 0,
15124        };
15125        init
15126    },
15127    {
15128        let mut init = redisCommandArg {
15129            name: b"withvalues\0" as *const u8 as *const libc::c_char,
15130            type_0: ARG_TYPE_PURE_TOKEN,
15131            key_spec_index: -(1 as libc::c_int),
15132            token: b"WITHVALUES\0" as *const u8 as *const libc::c_char,
15133            summary: 0 as *const libc::c_char,
15134            since: 0 as *const libc::c_char,
15135            flags: (1 as libc::c_int) << 0 as libc::c_int,
15136            deprecated_since: 0 as *const libc::c_char,
15137            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15138            num_args: 0,
15139        };
15140        init
15141    },
15142    {
15143        let mut init = redisCommandArg {
15144            name: 0 as *const libc::c_char,
15145            type_0: ARG_TYPE_STRING,
15146            key_spec_index: 0,
15147            token: 0 as *const libc::c_char,
15148            summary: 0 as *const libc::c_char,
15149            since: 0 as *const libc::c_char,
15150            flags: 0,
15151            deprecated_since: 0 as *const libc::c_char,
15152            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15153            num_args: 0,
15154        };
15155        init
15156    },
15157];
15158#[no_mangle]
15159pub static mut HRANDFIELD_Args: [redisCommandArg; 3] = unsafe {
15160    [
15161        {
15162            let mut init = redisCommandArg {
15163                name: b"key\0" as *const u8 as *const libc::c_char,
15164                type_0: ARG_TYPE_KEY,
15165                key_spec_index: 0 as libc::c_int,
15166                token: 0 as *const libc::c_char,
15167                summary: 0 as *const libc::c_char,
15168                since: 0 as *const libc::c_char,
15169                flags: 0 as libc::c_int,
15170                deprecated_since: 0 as *const libc::c_char,
15171                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15172                num_args: 0,
15173            };
15174            init
15175        },
15176        {
15177            let mut init = redisCommandArg {
15178                name: b"options\0" as *const u8 as *const libc::c_char,
15179                type_0: ARG_TYPE_BLOCK,
15180                key_spec_index: -(1 as libc::c_int),
15181                token: 0 as *const libc::c_char,
15182                summary: 0 as *const libc::c_char,
15183                since: 0 as *const libc::c_char,
15184                flags: (1 as libc::c_int) << 0 as libc::c_int,
15185                deprecated_since: 0 as *const libc::c_char,
15186                subargs: HRANDFIELD_options_Subargs.as_ptr() as *mut _,
15187                num_args: 0,
15188            };
15189            init
15190        },
15191        {
15192            let mut init = redisCommandArg {
15193                name: 0 as *const libc::c_char,
15194                type_0: ARG_TYPE_STRING,
15195                key_spec_index: 0,
15196                token: 0 as *const libc::c_char,
15197                summary: 0 as *const libc::c_char,
15198                since: 0 as *const libc::c_char,
15199                flags: 0,
15200                deprecated_since: 0 as *const libc::c_char,
15201                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15202                num_args: 0,
15203            };
15204            init
15205        },
15206    ]
15207};
15208#[no_mangle]
15209pub static mut HSCAN_tips: [*const libc::c_char; 2] = [
15210    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
15211    0 as *const libc::c_char,
15212];
15213#[no_mangle]
15214pub static mut HSCAN_Args: [redisCommandArg; 5] = [
15215    {
15216        let mut init = redisCommandArg {
15217            name: b"key\0" as *const u8 as *const libc::c_char,
15218            type_0: ARG_TYPE_KEY,
15219            key_spec_index: 0 as libc::c_int,
15220            token: 0 as *const libc::c_char,
15221            summary: 0 as *const libc::c_char,
15222            since: 0 as *const libc::c_char,
15223            flags: 0 as libc::c_int,
15224            deprecated_since: 0 as *const libc::c_char,
15225            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15226            num_args: 0,
15227        };
15228        init
15229    },
15230    {
15231        let mut init = redisCommandArg {
15232            name: b"cursor\0" as *const u8 as *const libc::c_char,
15233            type_0: ARG_TYPE_INTEGER,
15234            key_spec_index: -(1 as libc::c_int),
15235            token: 0 as *const libc::c_char,
15236            summary: 0 as *const libc::c_char,
15237            since: 0 as *const libc::c_char,
15238            flags: 0 as libc::c_int,
15239            deprecated_since: 0 as *const libc::c_char,
15240            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15241            num_args: 0,
15242        };
15243        init
15244    },
15245    {
15246        let mut init = redisCommandArg {
15247            name: b"pattern\0" as *const u8 as *const libc::c_char,
15248            type_0: ARG_TYPE_PATTERN,
15249            key_spec_index: -(1 as libc::c_int),
15250            token: b"MATCH\0" as *const u8 as *const libc::c_char,
15251            summary: 0 as *const libc::c_char,
15252            since: 0 as *const libc::c_char,
15253            flags: (1 as libc::c_int) << 0 as libc::c_int,
15254            deprecated_since: 0 as *const libc::c_char,
15255            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15256            num_args: 0,
15257        };
15258        init
15259    },
15260    {
15261        let mut init = redisCommandArg {
15262            name: b"count\0" as *const u8 as *const libc::c_char,
15263            type_0: ARG_TYPE_INTEGER,
15264            key_spec_index: -(1 as libc::c_int),
15265            token: b"COUNT\0" as *const u8 as *const libc::c_char,
15266            summary: 0 as *const libc::c_char,
15267            since: 0 as *const libc::c_char,
15268            flags: (1 as libc::c_int) << 0 as libc::c_int,
15269            deprecated_since: 0 as *const libc::c_char,
15270            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15271            num_args: 0,
15272        };
15273        init
15274    },
15275    {
15276        let mut init = redisCommandArg {
15277            name: 0 as *const libc::c_char,
15278            type_0: ARG_TYPE_STRING,
15279            key_spec_index: 0,
15280            token: 0 as *const libc::c_char,
15281            summary: 0 as *const libc::c_char,
15282            since: 0 as *const libc::c_char,
15283            flags: 0,
15284            deprecated_since: 0 as *const libc::c_char,
15285            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15286            num_args: 0,
15287        };
15288        init
15289    },
15290];
15291#[no_mangle]
15292pub static mut HSET_History: [commandHistory; 2] = [
15293    {
15294        let mut init = commandHistory {
15295            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
15296            changes: b"Accepts multiple `field` and `value` arguments.\0" as *const u8
15297                as *const libc::c_char,
15298        };
15299        init
15300    },
15301    {
15302        let mut init = commandHistory {
15303            since: 0 as *const libc::c_char,
15304            changes: 0 as *const libc::c_char,
15305        };
15306        init
15307    },
15308];
15309#[no_mangle]
15310pub static mut HSET_field_value_Subargs: [redisCommandArg; 3] = [
15311    {
15312        let mut init = redisCommandArg {
15313            name: b"field\0" as *const u8 as *const libc::c_char,
15314            type_0: ARG_TYPE_STRING,
15315            key_spec_index: -(1 as libc::c_int),
15316            token: 0 as *const libc::c_char,
15317            summary: 0 as *const libc::c_char,
15318            since: 0 as *const libc::c_char,
15319            flags: 0 as libc::c_int,
15320            deprecated_since: 0 as *const libc::c_char,
15321            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15322            num_args: 0,
15323        };
15324        init
15325    },
15326    {
15327        let mut init = redisCommandArg {
15328            name: b"value\0" as *const u8 as *const libc::c_char,
15329            type_0: ARG_TYPE_STRING,
15330            key_spec_index: -(1 as libc::c_int),
15331            token: 0 as *const libc::c_char,
15332            summary: 0 as *const libc::c_char,
15333            since: 0 as *const libc::c_char,
15334            flags: 0 as libc::c_int,
15335            deprecated_since: 0 as *const libc::c_char,
15336            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15337            num_args: 0,
15338        };
15339        init
15340    },
15341    {
15342        let mut init = redisCommandArg {
15343            name: 0 as *const libc::c_char,
15344            type_0: ARG_TYPE_STRING,
15345            key_spec_index: 0,
15346            token: 0 as *const libc::c_char,
15347            summary: 0 as *const libc::c_char,
15348            since: 0 as *const libc::c_char,
15349            flags: 0,
15350            deprecated_since: 0 as *const libc::c_char,
15351            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15352            num_args: 0,
15353        };
15354        init
15355    },
15356];
15357#[no_mangle]
15358pub static mut HSET_Args: [redisCommandArg; 3] = unsafe {
15359    [
15360        {
15361            let mut init = redisCommandArg {
15362                name: b"key\0" as *const u8 as *const libc::c_char,
15363                type_0: ARG_TYPE_KEY,
15364                key_spec_index: 0 as libc::c_int,
15365                token: 0 as *const libc::c_char,
15366                summary: 0 as *const libc::c_char,
15367                since: 0 as *const libc::c_char,
15368                flags: 0 as libc::c_int,
15369                deprecated_since: 0 as *const libc::c_char,
15370                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15371                num_args: 0,
15372            };
15373            init
15374        },
15375        {
15376            let mut init = redisCommandArg {
15377                name: b"field_value\0" as *const u8 as *const libc::c_char,
15378                type_0: ARG_TYPE_BLOCK,
15379                key_spec_index: -(1 as libc::c_int),
15380                token: 0 as *const libc::c_char,
15381                summary: 0 as *const libc::c_char,
15382                since: 0 as *const libc::c_char,
15383                flags: (1 as libc::c_int) << 1 as libc::c_int,
15384                deprecated_since: 0 as *const libc::c_char,
15385                subargs: HSET_field_value_Subargs.as_ptr() as *mut _,
15386                num_args: 0,
15387            };
15388            init
15389        },
15390        {
15391            let mut init = redisCommandArg {
15392                name: 0 as *const libc::c_char,
15393                type_0: ARG_TYPE_STRING,
15394                key_spec_index: 0,
15395                token: 0 as *const libc::c_char,
15396                summary: 0 as *const libc::c_char,
15397                since: 0 as *const libc::c_char,
15398                flags: 0,
15399                deprecated_since: 0 as *const libc::c_char,
15400                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15401                num_args: 0,
15402            };
15403            init
15404        },
15405    ]
15406};
15407#[no_mangle]
15408pub static mut HSETNX_Args: [redisCommandArg; 4] = [
15409    {
15410        let mut init = redisCommandArg {
15411            name: b"key\0" as *const u8 as *const libc::c_char,
15412            type_0: ARG_TYPE_KEY,
15413            key_spec_index: 0 as libc::c_int,
15414            token: 0 as *const libc::c_char,
15415            summary: 0 as *const libc::c_char,
15416            since: 0 as *const libc::c_char,
15417            flags: 0 as libc::c_int,
15418            deprecated_since: 0 as *const libc::c_char,
15419            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15420            num_args: 0,
15421        };
15422        init
15423    },
15424    {
15425        let mut init = redisCommandArg {
15426            name: b"field\0" as *const u8 as *const libc::c_char,
15427            type_0: ARG_TYPE_STRING,
15428            key_spec_index: -(1 as libc::c_int),
15429            token: 0 as *const libc::c_char,
15430            summary: 0 as *const libc::c_char,
15431            since: 0 as *const libc::c_char,
15432            flags: 0 as libc::c_int,
15433            deprecated_since: 0 as *const libc::c_char,
15434            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15435            num_args: 0,
15436        };
15437        init
15438    },
15439    {
15440        let mut init = redisCommandArg {
15441            name: b"value\0" as *const u8 as *const libc::c_char,
15442            type_0: ARG_TYPE_STRING,
15443            key_spec_index: -(1 as libc::c_int),
15444            token: 0 as *const libc::c_char,
15445            summary: 0 as *const libc::c_char,
15446            since: 0 as *const libc::c_char,
15447            flags: 0 as libc::c_int,
15448            deprecated_since: 0 as *const libc::c_char,
15449            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15450            num_args: 0,
15451        };
15452        init
15453    },
15454    {
15455        let mut init = redisCommandArg {
15456            name: 0 as *const libc::c_char,
15457            type_0: ARG_TYPE_STRING,
15458            key_spec_index: 0,
15459            token: 0 as *const libc::c_char,
15460            summary: 0 as *const libc::c_char,
15461            since: 0 as *const libc::c_char,
15462            flags: 0,
15463            deprecated_since: 0 as *const libc::c_char,
15464            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15465            num_args: 0,
15466        };
15467        init
15468    },
15469];
15470#[no_mangle]
15471pub static mut HSTRLEN_Args: [redisCommandArg; 3] = [
15472    {
15473        let mut init = redisCommandArg {
15474            name: b"key\0" as *const u8 as *const libc::c_char,
15475            type_0: ARG_TYPE_KEY,
15476            key_spec_index: 0 as libc::c_int,
15477            token: 0 as *const libc::c_char,
15478            summary: 0 as *const libc::c_char,
15479            since: 0 as *const libc::c_char,
15480            flags: 0 as libc::c_int,
15481            deprecated_since: 0 as *const libc::c_char,
15482            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15483            num_args: 0,
15484        };
15485        init
15486    },
15487    {
15488        let mut init = redisCommandArg {
15489            name: b"field\0" as *const u8 as *const libc::c_char,
15490            type_0: ARG_TYPE_STRING,
15491            key_spec_index: -(1 as libc::c_int),
15492            token: 0 as *const libc::c_char,
15493            summary: 0 as *const libc::c_char,
15494            since: 0 as *const libc::c_char,
15495            flags: 0 as libc::c_int,
15496            deprecated_since: 0 as *const libc::c_char,
15497            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15498            num_args: 0,
15499        };
15500        init
15501    },
15502    {
15503        let mut init = redisCommandArg {
15504            name: 0 as *const libc::c_char,
15505            type_0: ARG_TYPE_STRING,
15506            key_spec_index: 0,
15507            token: 0 as *const libc::c_char,
15508            summary: 0 as *const libc::c_char,
15509            since: 0 as *const libc::c_char,
15510            flags: 0,
15511            deprecated_since: 0 as *const libc::c_char,
15512            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15513            num_args: 0,
15514        };
15515        init
15516    },
15517];
15518#[no_mangle]
15519pub static mut HVALS_tips: [*const libc::c_char; 2] = [
15520    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
15521    0 as *const libc::c_char,
15522];
15523#[no_mangle]
15524pub static mut HVALS_Args: [redisCommandArg; 2] = [
15525    {
15526        let mut init = redisCommandArg {
15527            name: b"key\0" as *const u8 as *const libc::c_char,
15528            type_0: ARG_TYPE_KEY,
15529            key_spec_index: 0 as libc::c_int,
15530            token: 0 as *const libc::c_char,
15531            summary: 0 as *const libc::c_char,
15532            since: 0 as *const libc::c_char,
15533            flags: 0 as libc::c_int,
15534            deprecated_since: 0 as *const libc::c_char,
15535            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15536            num_args: 0,
15537        };
15538        init
15539    },
15540    {
15541        let mut init = redisCommandArg {
15542            name: 0 as *const libc::c_char,
15543            type_0: ARG_TYPE_STRING,
15544            key_spec_index: 0,
15545            token: 0 as *const libc::c_char,
15546            summary: 0 as *const libc::c_char,
15547            since: 0 as *const libc::c_char,
15548            flags: 0,
15549            deprecated_since: 0 as *const libc::c_char,
15550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15551            num_args: 0,
15552        };
15553        init
15554    },
15555];
15556#[no_mangle]
15557pub static mut PFADD_Args: [redisCommandArg; 3] = [
15558    {
15559        let mut init = redisCommandArg {
15560            name: b"key\0" as *const u8 as *const libc::c_char,
15561            type_0: ARG_TYPE_KEY,
15562            key_spec_index: 0 as libc::c_int,
15563            token: 0 as *const libc::c_char,
15564            summary: 0 as *const libc::c_char,
15565            since: 0 as *const libc::c_char,
15566            flags: 0 as libc::c_int,
15567            deprecated_since: 0 as *const libc::c_char,
15568            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15569            num_args: 0,
15570        };
15571        init
15572    },
15573    {
15574        let mut init = redisCommandArg {
15575            name: b"element\0" as *const u8 as *const libc::c_char,
15576            type_0: ARG_TYPE_STRING,
15577            key_spec_index: -(1 as libc::c_int),
15578            token: 0 as *const libc::c_char,
15579            summary: 0 as *const libc::c_char,
15580            since: 0 as *const libc::c_char,
15581            flags: (1 as libc::c_int) << 0 as libc::c_int
15582                | (1 as libc::c_int) << 1 as libc::c_int,
15583            deprecated_since: 0 as *const libc::c_char,
15584            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15585            num_args: 0,
15586        };
15587        init
15588    },
15589    {
15590        let mut init = redisCommandArg {
15591            name: 0 as *const libc::c_char,
15592            type_0: ARG_TYPE_STRING,
15593            key_spec_index: 0,
15594            token: 0 as *const libc::c_char,
15595            summary: 0 as *const libc::c_char,
15596            since: 0 as *const libc::c_char,
15597            flags: 0,
15598            deprecated_since: 0 as *const libc::c_char,
15599            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15600            num_args: 0,
15601        };
15602        init
15603    },
15604];
15605#[no_mangle]
15606pub static mut PFCOUNT_Args: [redisCommandArg; 2] = [
15607    {
15608        let mut init = redisCommandArg {
15609            name: b"key\0" as *const u8 as *const libc::c_char,
15610            type_0: ARG_TYPE_KEY,
15611            key_spec_index: 0 as libc::c_int,
15612            token: 0 as *const libc::c_char,
15613            summary: 0 as *const libc::c_char,
15614            since: 0 as *const libc::c_char,
15615            flags: (1 as libc::c_int) << 1 as libc::c_int,
15616            deprecated_since: 0 as *const libc::c_char,
15617            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15618            num_args: 0,
15619        };
15620        init
15621    },
15622    {
15623        let mut init = redisCommandArg {
15624            name: 0 as *const libc::c_char,
15625            type_0: ARG_TYPE_STRING,
15626            key_spec_index: 0,
15627            token: 0 as *const libc::c_char,
15628            summary: 0 as *const libc::c_char,
15629            since: 0 as *const libc::c_char,
15630            flags: 0,
15631            deprecated_since: 0 as *const libc::c_char,
15632            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15633            num_args: 0,
15634        };
15635        init
15636    },
15637];
15638#[no_mangle]
15639pub static mut PFDEBUG_Args: [redisCommandArg; 3] = [
15640    {
15641        let mut init = redisCommandArg {
15642            name: b"subcommand\0" as *const u8 as *const libc::c_char,
15643            type_0: ARG_TYPE_STRING,
15644            key_spec_index: -(1 as libc::c_int),
15645            token: 0 as *const libc::c_char,
15646            summary: 0 as *const libc::c_char,
15647            since: 0 as *const libc::c_char,
15648            flags: 0 as libc::c_int,
15649            deprecated_since: 0 as *const libc::c_char,
15650            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15651            num_args: 0,
15652        };
15653        init
15654    },
15655    {
15656        let mut init = redisCommandArg {
15657            name: b"key\0" as *const u8 as *const libc::c_char,
15658            type_0: ARG_TYPE_KEY,
15659            key_spec_index: 0 as libc::c_int,
15660            token: 0 as *const libc::c_char,
15661            summary: 0 as *const libc::c_char,
15662            since: 0 as *const libc::c_char,
15663            flags: 0 as libc::c_int,
15664            deprecated_since: 0 as *const libc::c_char,
15665            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15666            num_args: 0,
15667        };
15668        init
15669    },
15670    {
15671        let mut init = redisCommandArg {
15672            name: 0 as *const libc::c_char,
15673            type_0: ARG_TYPE_STRING,
15674            key_spec_index: 0,
15675            token: 0 as *const libc::c_char,
15676            summary: 0 as *const libc::c_char,
15677            since: 0 as *const libc::c_char,
15678            flags: 0,
15679            deprecated_since: 0 as *const libc::c_char,
15680            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15681            num_args: 0,
15682        };
15683        init
15684    },
15685];
15686#[no_mangle]
15687pub static mut PFMERGE_Args: [redisCommandArg; 3] = [
15688    {
15689        let mut init = redisCommandArg {
15690            name: b"destkey\0" as *const u8 as *const libc::c_char,
15691            type_0: ARG_TYPE_KEY,
15692            key_spec_index: 0 as libc::c_int,
15693            token: 0 as *const libc::c_char,
15694            summary: 0 as *const libc::c_char,
15695            since: 0 as *const libc::c_char,
15696            flags: 0 as libc::c_int,
15697            deprecated_since: 0 as *const libc::c_char,
15698            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15699            num_args: 0,
15700        };
15701        init
15702    },
15703    {
15704        let mut init = redisCommandArg {
15705            name: b"sourcekey\0" as *const u8 as *const libc::c_char,
15706            type_0: ARG_TYPE_KEY,
15707            key_spec_index: 1 as libc::c_int,
15708            token: 0 as *const libc::c_char,
15709            summary: 0 as *const libc::c_char,
15710            since: 0 as *const libc::c_char,
15711            flags: (1 as libc::c_int) << 1 as libc::c_int,
15712            deprecated_since: 0 as *const libc::c_char,
15713            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15714            num_args: 0,
15715        };
15716        init
15717    },
15718    {
15719        let mut init = redisCommandArg {
15720            name: 0 as *const libc::c_char,
15721            type_0: ARG_TYPE_STRING,
15722            key_spec_index: 0,
15723            token: 0 as *const libc::c_char,
15724            summary: 0 as *const libc::c_char,
15725            since: 0 as *const libc::c_char,
15726            flags: 0,
15727            deprecated_since: 0 as *const libc::c_char,
15728            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15729            num_args: 0,
15730        };
15731        init
15732    },
15733];
15734#[no_mangle]
15735pub static mut BLMOVE_wherefrom_Subargs: [redisCommandArg; 3] = [
15736    {
15737        let mut init = redisCommandArg {
15738            name: b"left\0" as *const u8 as *const libc::c_char,
15739            type_0: ARG_TYPE_PURE_TOKEN,
15740            key_spec_index: -(1 as libc::c_int),
15741            token: b"LEFT\0" as *const u8 as *const libc::c_char,
15742            summary: 0 as *const libc::c_char,
15743            since: 0 as *const libc::c_char,
15744            flags: 0 as libc::c_int,
15745            deprecated_since: 0 as *const libc::c_char,
15746            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15747            num_args: 0,
15748        };
15749        init
15750    },
15751    {
15752        let mut init = redisCommandArg {
15753            name: b"right\0" as *const u8 as *const libc::c_char,
15754            type_0: ARG_TYPE_PURE_TOKEN,
15755            key_spec_index: -(1 as libc::c_int),
15756            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
15757            summary: 0 as *const libc::c_char,
15758            since: 0 as *const libc::c_char,
15759            flags: 0 as libc::c_int,
15760            deprecated_since: 0 as *const libc::c_char,
15761            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15762            num_args: 0,
15763        };
15764        init
15765    },
15766    {
15767        let mut init = redisCommandArg {
15768            name: 0 as *const libc::c_char,
15769            type_0: ARG_TYPE_STRING,
15770            key_spec_index: 0,
15771            token: 0 as *const libc::c_char,
15772            summary: 0 as *const libc::c_char,
15773            since: 0 as *const libc::c_char,
15774            flags: 0,
15775            deprecated_since: 0 as *const libc::c_char,
15776            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15777            num_args: 0,
15778        };
15779        init
15780    },
15781];
15782#[no_mangle]
15783pub static mut BLMOVE_whereto_Subargs: [redisCommandArg; 3] = [
15784    {
15785        let mut init = redisCommandArg {
15786            name: b"left\0" as *const u8 as *const libc::c_char,
15787            type_0: ARG_TYPE_PURE_TOKEN,
15788            key_spec_index: -(1 as libc::c_int),
15789            token: b"LEFT\0" as *const u8 as *const libc::c_char,
15790            summary: 0 as *const libc::c_char,
15791            since: 0 as *const libc::c_char,
15792            flags: 0 as libc::c_int,
15793            deprecated_since: 0 as *const libc::c_char,
15794            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15795            num_args: 0,
15796        };
15797        init
15798    },
15799    {
15800        let mut init = redisCommandArg {
15801            name: b"right\0" as *const u8 as *const libc::c_char,
15802            type_0: ARG_TYPE_PURE_TOKEN,
15803            key_spec_index: -(1 as libc::c_int),
15804            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
15805            summary: 0 as *const libc::c_char,
15806            since: 0 as *const libc::c_char,
15807            flags: 0 as libc::c_int,
15808            deprecated_since: 0 as *const libc::c_char,
15809            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15810            num_args: 0,
15811        };
15812        init
15813    },
15814    {
15815        let mut init = redisCommandArg {
15816            name: 0 as *const libc::c_char,
15817            type_0: ARG_TYPE_STRING,
15818            key_spec_index: 0,
15819            token: 0 as *const libc::c_char,
15820            summary: 0 as *const libc::c_char,
15821            since: 0 as *const libc::c_char,
15822            flags: 0,
15823            deprecated_since: 0 as *const libc::c_char,
15824            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15825            num_args: 0,
15826        };
15827        init
15828    },
15829];
15830#[no_mangle]
15831pub static mut BLMOVE_Args: [redisCommandArg; 6] = unsafe {
15832    [
15833        {
15834            let mut init = redisCommandArg {
15835                name: b"source\0" as *const u8 as *const libc::c_char,
15836                type_0: ARG_TYPE_KEY,
15837                key_spec_index: 0 as libc::c_int,
15838                token: 0 as *const libc::c_char,
15839                summary: 0 as *const libc::c_char,
15840                since: 0 as *const libc::c_char,
15841                flags: 0 as libc::c_int,
15842                deprecated_since: 0 as *const libc::c_char,
15843                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15844                num_args: 0,
15845            };
15846            init
15847        },
15848        {
15849            let mut init = redisCommandArg {
15850                name: b"destination\0" as *const u8 as *const libc::c_char,
15851                type_0: ARG_TYPE_KEY,
15852                key_spec_index: 1 as libc::c_int,
15853                token: 0 as *const libc::c_char,
15854                summary: 0 as *const libc::c_char,
15855                since: 0 as *const libc::c_char,
15856                flags: 0 as libc::c_int,
15857                deprecated_since: 0 as *const libc::c_char,
15858                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15859                num_args: 0,
15860            };
15861            init
15862        },
15863        {
15864            let mut init = redisCommandArg {
15865                name: b"wherefrom\0" as *const u8 as *const libc::c_char,
15866                type_0: ARG_TYPE_ONEOF,
15867                key_spec_index: -(1 as libc::c_int),
15868                token: 0 as *const libc::c_char,
15869                summary: 0 as *const libc::c_char,
15870                since: 0 as *const libc::c_char,
15871                flags: 0 as libc::c_int,
15872                deprecated_since: 0 as *const libc::c_char,
15873                subargs: BLMOVE_wherefrom_Subargs.as_ptr() as *mut _,
15874                num_args: 0,
15875            };
15876            init
15877        },
15878        {
15879            let mut init = redisCommandArg {
15880                name: b"whereto\0" as *const u8 as *const libc::c_char,
15881                type_0: ARG_TYPE_ONEOF,
15882                key_spec_index: -(1 as libc::c_int),
15883                token: 0 as *const libc::c_char,
15884                summary: 0 as *const libc::c_char,
15885                since: 0 as *const libc::c_char,
15886                flags: 0 as libc::c_int,
15887                deprecated_since: 0 as *const libc::c_char,
15888                subargs: BLMOVE_whereto_Subargs.as_ptr() as *mut _,
15889                num_args: 0,
15890            };
15891            init
15892        },
15893        {
15894            let mut init = redisCommandArg {
15895                name: b"timeout\0" as *const u8 as *const libc::c_char,
15896                type_0: ARG_TYPE_DOUBLE,
15897                key_spec_index: -(1 as libc::c_int),
15898                token: 0 as *const libc::c_char,
15899                summary: 0 as *const libc::c_char,
15900                since: 0 as *const libc::c_char,
15901                flags: 0 as libc::c_int,
15902                deprecated_since: 0 as *const libc::c_char,
15903                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15904                num_args: 0,
15905            };
15906            init
15907        },
15908        {
15909            let mut init = redisCommandArg {
15910                name: 0 as *const libc::c_char,
15911                type_0: ARG_TYPE_STRING,
15912                key_spec_index: 0,
15913                token: 0 as *const libc::c_char,
15914                summary: 0 as *const libc::c_char,
15915                since: 0 as *const libc::c_char,
15916                flags: 0,
15917                deprecated_since: 0 as *const libc::c_char,
15918                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15919                num_args: 0,
15920            };
15921            init
15922        },
15923    ]
15924};
15925#[no_mangle]
15926pub static mut BLMPOP_where_Subargs: [redisCommandArg; 3] = [
15927    {
15928        let mut init = redisCommandArg {
15929            name: b"left\0" as *const u8 as *const libc::c_char,
15930            type_0: ARG_TYPE_PURE_TOKEN,
15931            key_spec_index: -(1 as libc::c_int),
15932            token: b"LEFT\0" as *const u8 as *const libc::c_char,
15933            summary: 0 as *const libc::c_char,
15934            since: 0 as *const libc::c_char,
15935            flags: 0 as libc::c_int,
15936            deprecated_since: 0 as *const libc::c_char,
15937            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15938            num_args: 0,
15939        };
15940        init
15941    },
15942    {
15943        let mut init = redisCommandArg {
15944            name: b"right\0" as *const u8 as *const libc::c_char,
15945            type_0: ARG_TYPE_PURE_TOKEN,
15946            key_spec_index: -(1 as libc::c_int),
15947            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
15948            summary: 0 as *const libc::c_char,
15949            since: 0 as *const libc::c_char,
15950            flags: 0 as libc::c_int,
15951            deprecated_since: 0 as *const libc::c_char,
15952            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15953            num_args: 0,
15954        };
15955        init
15956    },
15957    {
15958        let mut init = redisCommandArg {
15959            name: 0 as *const libc::c_char,
15960            type_0: ARG_TYPE_STRING,
15961            key_spec_index: 0,
15962            token: 0 as *const libc::c_char,
15963            summary: 0 as *const libc::c_char,
15964            since: 0 as *const libc::c_char,
15965            flags: 0,
15966            deprecated_since: 0 as *const libc::c_char,
15967            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15968            num_args: 0,
15969        };
15970        init
15971    },
15972];
15973#[no_mangle]
15974pub static mut BLMPOP_Args: [redisCommandArg; 6] = unsafe {
15975    [
15976        {
15977            let mut init = redisCommandArg {
15978                name: b"timeout\0" as *const u8 as *const libc::c_char,
15979                type_0: ARG_TYPE_DOUBLE,
15980                key_spec_index: -(1 as libc::c_int),
15981                token: 0 as *const libc::c_char,
15982                summary: 0 as *const libc::c_char,
15983                since: 0 as *const libc::c_char,
15984                flags: 0 as libc::c_int,
15985                deprecated_since: 0 as *const libc::c_char,
15986                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
15987                num_args: 0,
15988            };
15989            init
15990        },
15991        {
15992            let mut init = redisCommandArg {
15993                name: b"numkeys\0" as *const u8 as *const libc::c_char,
15994                type_0: ARG_TYPE_INTEGER,
15995                key_spec_index: -(1 as libc::c_int),
15996                token: 0 as *const libc::c_char,
15997                summary: 0 as *const libc::c_char,
15998                since: 0 as *const libc::c_char,
15999                flags: 0 as libc::c_int,
16000                deprecated_since: 0 as *const libc::c_char,
16001                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16002                num_args: 0,
16003            };
16004            init
16005        },
16006        {
16007            let mut init = redisCommandArg {
16008                name: b"key\0" as *const u8 as *const libc::c_char,
16009                type_0: ARG_TYPE_KEY,
16010                key_spec_index: 0 as libc::c_int,
16011                token: 0 as *const libc::c_char,
16012                summary: 0 as *const libc::c_char,
16013                since: 0 as *const libc::c_char,
16014                flags: (1 as libc::c_int) << 1 as libc::c_int,
16015                deprecated_since: 0 as *const libc::c_char,
16016                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16017                num_args: 0,
16018            };
16019            init
16020        },
16021        {
16022            let mut init = redisCommandArg {
16023                name: b"where\0" as *const u8 as *const libc::c_char,
16024                type_0: ARG_TYPE_ONEOF,
16025                key_spec_index: -(1 as libc::c_int),
16026                token: 0 as *const libc::c_char,
16027                summary: 0 as *const libc::c_char,
16028                since: 0 as *const libc::c_char,
16029                flags: 0 as libc::c_int,
16030                deprecated_since: 0 as *const libc::c_char,
16031                subargs: BLMPOP_where_Subargs.as_ptr() as *mut _,
16032                num_args: 0,
16033            };
16034            init
16035        },
16036        {
16037            let mut init = redisCommandArg {
16038                name: b"count\0" as *const u8 as *const libc::c_char,
16039                type_0: ARG_TYPE_INTEGER,
16040                key_spec_index: -(1 as libc::c_int),
16041                token: b"COUNT\0" as *const u8 as *const libc::c_char,
16042                summary: 0 as *const libc::c_char,
16043                since: 0 as *const libc::c_char,
16044                flags: (1 as libc::c_int) << 0 as libc::c_int,
16045                deprecated_since: 0 as *const libc::c_char,
16046                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16047                num_args: 0,
16048            };
16049            init
16050        },
16051        {
16052            let mut init = redisCommandArg {
16053                name: 0 as *const libc::c_char,
16054                type_0: ARG_TYPE_STRING,
16055                key_spec_index: 0,
16056                token: 0 as *const libc::c_char,
16057                summary: 0 as *const libc::c_char,
16058                since: 0 as *const libc::c_char,
16059                flags: 0,
16060                deprecated_since: 0 as *const libc::c_char,
16061                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16062                num_args: 0,
16063            };
16064            init
16065        },
16066    ]
16067};
16068#[no_mangle]
16069pub static mut BLPOP_History: [commandHistory; 2] = [
16070    {
16071        let mut init = commandHistory {
16072            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
16073            changes: b"`timeout` is interpreted as a double instead of an integer.\0"
16074                as *const u8 as *const libc::c_char,
16075        };
16076        init
16077    },
16078    {
16079        let mut init = commandHistory {
16080            since: 0 as *const libc::c_char,
16081            changes: 0 as *const libc::c_char,
16082        };
16083        init
16084    },
16085];
16086#[no_mangle]
16087pub static mut BLPOP_Args: [redisCommandArg; 3] = [
16088    {
16089        let mut init = redisCommandArg {
16090            name: b"key\0" as *const u8 as *const libc::c_char,
16091            type_0: ARG_TYPE_KEY,
16092            key_spec_index: 0 as libc::c_int,
16093            token: 0 as *const libc::c_char,
16094            summary: 0 as *const libc::c_char,
16095            since: 0 as *const libc::c_char,
16096            flags: (1 as libc::c_int) << 1 as libc::c_int,
16097            deprecated_since: 0 as *const libc::c_char,
16098            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16099            num_args: 0,
16100        };
16101        init
16102    },
16103    {
16104        let mut init = redisCommandArg {
16105            name: b"timeout\0" as *const u8 as *const libc::c_char,
16106            type_0: ARG_TYPE_DOUBLE,
16107            key_spec_index: -(1 as libc::c_int),
16108            token: 0 as *const libc::c_char,
16109            summary: 0 as *const libc::c_char,
16110            since: 0 as *const libc::c_char,
16111            flags: 0 as libc::c_int,
16112            deprecated_since: 0 as *const libc::c_char,
16113            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16114            num_args: 0,
16115        };
16116        init
16117    },
16118    {
16119        let mut init = redisCommandArg {
16120            name: 0 as *const libc::c_char,
16121            type_0: ARG_TYPE_STRING,
16122            key_spec_index: 0,
16123            token: 0 as *const libc::c_char,
16124            summary: 0 as *const libc::c_char,
16125            since: 0 as *const libc::c_char,
16126            flags: 0,
16127            deprecated_since: 0 as *const libc::c_char,
16128            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16129            num_args: 0,
16130        };
16131        init
16132    },
16133];
16134#[no_mangle]
16135pub static mut BRPOP_History: [commandHistory; 2] = [
16136    {
16137        let mut init = commandHistory {
16138            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
16139            changes: b"`timeout` is interpreted as a double instead of an integer.\0"
16140                as *const u8 as *const libc::c_char,
16141        };
16142        init
16143    },
16144    {
16145        let mut init = commandHistory {
16146            since: 0 as *const libc::c_char,
16147            changes: 0 as *const libc::c_char,
16148        };
16149        init
16150    },
16151];
16152#[no_mangle]
16153pub static mut BRPOP_Args: [redisCommandArg; 3] = [
16154    {
16155        let mut init = redisCommandArg {
16156            name: b"key\0" as *const u8 as *const libc::c_char,
16157            type_0: ARG_TYPE_KEY,
16158            key_spec_index: 0 as libc::c_int,
16159            token: 0 as *const libc::c_char,
16160            summary: 0 as *const libc::c_char,
16161            since: 0 as *const libc::c_char,
16162            flags: (1 as libc::c_int) << 1 as libc::c_int,
16163            deprecated_since: 0 as *const libc::c_char,
16164            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16165            num_args: 0,
16166        };
16167        init
16168    },
16169    {
16170        let mut init = redisCommandArg {
16171            name: b"timeout\0" as *const u8 as *const libc::c_char,
16172            type_0: ARG_TYPE_DOUBLE,
16173            key_spec_index: -(1 as libc::c_int),
16174            token: 0 as *const libc::c_char,
16175            summary: 0 as *const libc::c_char,
16176            since: 0 as *const libc::c_char,
16177            flags: 0 as libc::c_int,
16178            deprecated_since: 0 as *const libc::c_char,
16179            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16180            num_args: 0,
16181        };
16182        init
16183    },
16184    {
16185        let mut init = redisCommandArg {
16186            name: 0 as *const libc::c_char,
16187            type_0: ARG_TYPE_STRING,
16188            key_spec_index: 0,
16189            token: 0 as *const libc::c_char,
16190            summary: 0 as *const libc::c_char,
16191            since: 0 as *const libc::c_char,
16192            flags: 0,
16193            deprecated_since: 0 as *const libc::c_char,
16194            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16195            num_args: 0,
16196        };
16197        init
16198    },
16199];
16200#[no_mangle]
16201pub static mut BRPOPLPUSH_History: [commandHistory; 2] = [
16202    {
16203        let mut init = commandHistory {
16204            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
16205            changes: b"`timeout` is interpreted as a double instead of an integer.\0"
16206                as *const u8 as *const libc::c_char,
16207        };
16208        init
16209    },
16210    {
16211        let mut init = commandHistory {
16212            since: 0 as *const libc::c_char,
16213            changes: 0 as *const libc::c_char,
16214        };
16215        init
16216    },
16217];
16218#[no_mangle]
16219pub static mut BRPOPLPUSH_Args: [redisCommandArg; 4] = [
16220    {
16221        let mut init = redisCommandArg {
16222            name: b"source\0" as *const u8 as *const libc::c_char,
16223            type_0: ARG_TYPE_KEY,
16224            key_spec_index: 0 as libc::c_int,
16225            token: 0 as *const libc::c_char,
16226            summary: 0 as *const libc::c_char,
16227            since: 0 as *const libc::c_char,
16228            flags: 0 as libc::c_int,
16229            deprecated_since: 0 as *const libc::c_char,
16230            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16231            num_args: 0,
16232        };
16233        init
16234    },
16235    {
16236        let mut init = redisCommandArg {
16237            name: b"destination\0" as *const u8 as *const libc::c_char,
16238            type_0: ARG_TYPE_KEY,
16239            key_spec_index: 1 as libc::c_int,
16240            token: 0 as *const libc::c_char,
16241            summary: 0 as *const libc::c_char,
16242            since: 0 as *const libc::c_char,
16243            flags: 0 as libc::c_int,
16244            deprecated_since: 0 as *const libc::c_char,
16245            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16246            num_args: 0,
16247        };
16248        init
16249    },
16250    {
16251        let mut init = redisCommandArg {
16252            name: b"timeout\0" as *const u8 as *const libc::c_char,
16253            type_0: ARG_TYPE_DOUBLE,
16254            key_spec_index: -(1 as libc::c_int),
16255            token: 0 as *const libc::c_char,
16256            summary: 0 as *const libc::c_char,
16257            since: 0 as *const libc::c_char,
16258            flags: 0 as libc::c_int,
16259            deprecated_since: 0 as *const libc::c_char,
16260            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16261            num_args: 0,
16262        };
16263        init
16264    },
16265    {
16266        let mut init = redisCommandArg {
16267            name: 0 as *const libc::c_char,
16268            type_0: ARG_TYPE_STRING,
16269            key_spec_index: 0,
16270            token: 0 as *const libc::c_char,
16271            summary: 0 as *const libc::c_char,
16272            since: 0 as *const libc::c_char,
16273            flags: 0,
16274            deprecated_since: 0 as *const libc::c_char,
16275            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16276            num_args: 0,
16277        };
16278        init
16279    },
16280];
16281#[no_mangle]
16282pub static mut LINDEX_Args: [redisCommandArg; 3] = [
16283    {
16284        let mut init = redisCommandArg {
16285            name: b"key\0" as *const u8 as *const libc::c_char,
16286            type_0: ARG_TYPE_KEY,
16287            key_spec_index: 0 as libc::c_int,
16288            token: 0 as *const libc::c_char,
16289            summary: 0 as *const libc::c_char,
16290            since: 0 as *const libc::c_char,
16291            flags: 0 as libc::c_int,
16292            deprecated_since: 0 as *const libc::c_char,
16293            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16294            num_args: 0,
16295        };
16296        init
16297    },
16298    {
16299        let mut init = redisCommandArg {
16300            name: b"index\0" as *const u8 as *const libc::c_char,
16301            type_0: ARG_TYPE_INTEGER,
16302            key_spec_index: -(1 as libc::c_int),
16303            token: 0 as *const libc::c_char,
16304            summary: 0 as *const libc::c_char,
16305            since: 0 as *const libc::c_char,
16306            flags: 0 as libc::c_int,
16307            deprecated_since: 0 as *const libc::c_char,
16308            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16309            num_args: 0,
16310        };
16311        init
16312    },
16313    {
16314        let mut init = redisCommandArg {
16315            name: 0 as *const libc::c_char,
16316            type_0: ARG_TYPE_STRING,
16317            key_spec_index: 0,
16318            token: 0 as *const libc::c_char,
16319            summary: 0 as *const libc::c_char,
16320            since: 0 as *const libc::c_char,
16321            flags: 0,
16322            deprecated_since: 0 as *const libc::c_char,
16323            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16324            num_args: 0,
16325        };
16326        init
16327    },
16328];
16329#[no_mangle]
16330pub static mut LINSERT_where_Subargs: [redisCommandArg; 3] = [
16331    {
16332        let mut init = redisCommandArg {
16333            name: b"before\0" as *const u8 as *const libc::c_char,
16334            type_0: ARG_TYPE_PURE_TOKEN,
16335            key_spec_index: -(1 as libc::c_int),
16336            token: b"BEFORE\0" as *const u8 as *const libc::c_char,
16337            summary: 0 as *const libc::c_char,
16338            since: 0 as *const libc::c_char,
16339            flags: 0 as libc::c_int,
16340            deprecated_since: 0 as *const libc::c_char,
16341            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16342            num_args: 0,
16343        };
16344        init
16345    },
16346    {
16347        let mut init = redisCommandArg {
16348            name: b"after\0" as *const u8 as *const libc::c_char,
16349            type_0: ARG_TYPE_PURE_TOKEN,
16350            key_spec_index: -(1 as libc::c_int),
16351            token: b"AFTER\0" as *const u8 as *const libc::c_char,
16352            summary: 0 as *const libc::c_char,
16353            since: 0 as *const libc::c_char,
16354            flags: 0 as libc::c_int,
16355            deprecated_since: 0 as *const libc::c_char,
16356            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16357            num_args: 0,
16358        };
16359        init
16360    },
16361    {
16362        let mut init = redisCommandArg {
16363            name: 0 as *const libc::c_char,
16364            type_0: ARG_TYPE_STRING,
16365            key_spec_index: 0,
16366            token: 0 as *const libc::c_char,
16367            summary: 0 as *const libc::c_char,
16368            since: 0 as *const libc::c_char,
16369            flags: 0,
16370            deprecated_since: 0 as *const libc::c_char,
16371            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16372            num_args: 0,
16373        };
16374        init
16375    },
16376];
16377#[no_mangle]
16378pub static mut LINSERT_Args: [redisCommandArg; 5] = unsafe {
16379    [
16380        {
16381            let mut init = redisCommandArg {
16382                name: b"key\0" as *const u8 as *const libc::c_char,
16383                type_0: ARG_TYPE_KEY,
16384                key_spec_index: 0 as libc::c_int,
16385                token: 0 as *const libc::c_char,
16386                summary: 0 as *const libc::c_char,
16387                since: 0 as *const libc::c_char,
16388                flags: 0 as libc::c_int,
16389                deprecated_since: 0 as *const libc::c_char,
16390                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16391                num_args: 0,
16392            };
16393            init
16394        },
16395        {
16396            let mut init = redisCommandArg {
16397                name: b"where\0" as *const u8 as *const libc::c_char,
16398                type_0: ARG_TYPE_ONEOF,
16399                key_spec_index: -(1 as libc::c_int),
16400                token: 0 as *const libc::c_char,
16401                summary: 0 as *const libc::c_char,
16402                since: 0 as *const libc::c_char,
16403                flags: 0 as libc::c_int,
16404                deprecated_since: 0 as *const libc::c_char,
16405                subargs: LINSERT_where_Subargs.as_ptr() as *mut _,
16406                num_args: 0,
16407            };
16408            init
16409        },
16410        {
16411            let mut init = redisCommandArg {
16412                name: b"pivot\0" as *const u8 as *const libc::c_char,
16413                type_0: ARG_TYPE_STRING,
16414                key_spec_index: -(1 as libc::c_int),
16415                token: 0 as *const libc::c_char,
16416                summary: 0 as *const libc::c_char,
16417                since: 0 as *const libc::c_char,
16418                flags: 0 as libc::c_int,
16419                deprecated_since: 0 as *const libc::c_char,
16420                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16421                num_args: 0,
16422            };
16423            init
16424        },
16425        {
16426            let mut init = redisCommandArg {
16427                name: b"element\0" as *const u8 as *const libc::c_char,
16428                type_0: ARG_TYPE_STRING,
16429                key_spec_index: -(1 as libc::c_int),
16430                token: 0 as *const libc::c_char,
16431                summary: 0 as *const libc::c_char,
16432                since: 0 as *const libc::c_char,
16433                flags: 0 as libc::c_int,
16434                deprecated_since: 0 as *const libc::c_char,
16435                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16436                num_args: 0,
16437            };
16438            init
16439        },
16440        {
16441            let mut init = redisCommandArg {
16442                name: 0 as *const libc::c_char,
16443                type_0: ARG_TYPE_STRING,
16444                key_spec_index: 0,
16445                token: 0 as *const libc::c_char,
16446                summary: 0 as *const libc::c_char,
16447                since: 0 as *const libc::c_char,
16448                flags: 0,
16449                deprecated_since: 0 as *const libc::c_char,
16450                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16451                num_args: 0,
16452            };
16453            init
16454        },
16455    ]
16456};
16457#[no_mangle]
16458pub static mut LLEN_Args: [redisCommandArg; 2] = [
16459    {
16460        let mut init = redisCommandArg {
16461            name: b"key\0" as *const u8 as *const libc::c_char,
16462            type_0: ARG_TYPE_KEY,
16463            key_spec_index: 0 as libc::c_int,
16464            token: 0 as *const libc::c_char,
16465            summary: 0 as *const libc::c_char,
16466            since: 0 as *const libc::c_char,
16467            flags: 0 as libc::c_int,
16468            deprecated_since: 0 as *const libc::c_char,
16469            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16470            num_args: 0,
16471        };
16472        init
16473    },
16474    {
16475        let mut init = redisCommandArg {
16476            name: 0 as *const libc::c_char,
16477            type_0: ARG_TYPE_STRING,
16478            key_spec_index: 0,
16479            token: 0 as *const libc::c_char,
16480            summary: 0 as *const libc::c_char,
16481            since: 0 as *const libc::c_char,
16482            flags: 0,
16483            deprecated_since: 0 as *const libc::c_char,
16484            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16485            num_args: 0,
16486        };
16487        init
16488    },
16489];
16490#[no_mangle]
16491pub static mut LMOVE_wherefrom_Subargs: [redisCommandArg; 3] = [
16492    {
16493        let mut init = redisCommandArg {
16494            name: b"left\0" as *const u8 as *const libc::c_char,
16495            type_0: ARG_TYPE_PURE_TOKEN,
16496            key_spec_index: -(1 as libc::c_int),
16497            token: b"LEFT\0" as *const u8 as *const libc::c_char,
16498            summary: 0 as *const libc::c_char,
16499            since: 0 as *const libc::c_char,
16500            flags: 0 as libc::c_int,
16501            deprecated_since: 0 as *const libc::c_char,
16502            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16503            num_args: 0,
16504        };
16505        init
16506    },
16507    {
16508        let mut init = redisCommandArg {
16509            name: b"right\0" as *const u8 as *const libc::c_char,
16510            type_0: ARG_TYPE_PURE_TOKEN,
16511            key_spec_index: -(1 as libc::c_int),
16512            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
16513            summary: 0 as *const libc::c_char,
16514            since: 0 as *const libc::c_char,
16515            flags: 0 as libc::c_int,
16516            deprecated_since: 0 as *const libc::c_char,
16517            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16518            num_args: 0,
16519        };
16520        init
16521    },
16522    {
16523        let mut init = redisCommandArg {
16524            name: 0 as *const libc::c_char,
16525            type_0: ARG_TYPE_STRING,
16526            key_spec_index: 0,
16527            token: 0 as *const libc::c_char,
16528            summary: 0 as *const libc::c_char,
16529            since: 0 as *const libc::c_char,
16530            flags: 0,
16531            deprecated_since: 0 as *const libc::c_char,
16532            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16533            num_args: 0,
16534        };
16535        init
16536    },
16537];
16538#[no_mangle]
16539pub static mut LMOVE_whereto_Subargs: [redisCommandArg; 3] = [
16540    {
16541        let mut init = redisCommandArg {
16542            name: b"left\0" as *const u8 as *const libc::c_char,
16543            type_0: ARG_TYPE_PURE_TOKEN,
16544            key_spec_index: -(1 as libc::c_int),
16545            token: b"LEFT\0" as *const u8 as *const libc::c_char,
16546            summary: 0 as *const libc::c_char,
16547            since: 0 as *const libc::c_char,
16548            flags: 0 as libc::c_int,
16549            deprecated_since: 0 as *const libc::c_char,
16550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16551            num_args: 0,
16552        };
16553        init
16554    },
16555    {
16556        let mut init = redisCommandArg {
16557            name: b"right\0" as *const u8 as *const libc::c_char,
16558            type_0: ARG_TYPE_PURE_TOKEN,
16559            key_spec_index: -(1 as libc::c_int),
16560            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
16561            summary: 0 as *const libc::c_char,
16562            since: 0 as *const libc::c_char,
16563            flags: 0 as libc::c_int,
16564            deprecated_since: 0 as *const libc::c_char,
16565            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16566            num_args: 0,
16567        };
16568        init
16569    },
16570    {
16571        let mut init = redisCommandArg {
16572            name: 0 as *const libc::c_char,
16573            type_0: ARG_TYPE_STRING,
16574            key_spec_index: 0,
16575            token: 0 as *const libc::c_char,
16576            summary: 0 as *const libc::c_char,
16577            since: 0 as *const libc::c_char,
16578            flags: 0,
16579            deprecated_since: 0 as *const libc::c_char,
16580            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16581            num_args: 0,
16582        };
16583        init
16584    },
16585];
16586#[no_mangle]
16587pub static mut LMOVE_Args: [redisCommandArg; 5] = unsafe {
16588    [
16589        {
16590            let mut init = redisCommandArg {
16591                name: b"source\0" as *const u8 as *const libc::c_char,
16592                type_0: ARG_TYPE_KEY,
16593                key_spec_index: 0 as libc::c_int,
16594                token: 0 as *const libc::c_char,
16595                summary: 0 as *const libc::c_char,
16596                since: 0 as *const libc::c_char,
16597                flags: 0 as libc::c_int,
16598                deprecated_since: 0 as *const libc::c_char,
16599                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16600                num_args: 0,
16601            };
16602            init
16603        },
16604        {
16605            let mut init = redisCommandArg {
16606                name: b"destination\0" as *const u8 as *const libc::c_char,
16607                type_0: ARG_TYPE_KEY,
16608                key_spec_index: 1 as libc::c_int,
16609                token: 0 as *const libc::c_char,
16610                summary: 0 as *const libc::c_char,
16611                since: 0 as *const libc::c_char,
16612                flags: 0 as libc::c_int,
16613                deprecated_since: 0 as *const libc::c_char,
16614                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16615                num_args: 0,
16616            };
16617            init
16618        },
16619        {
16620            let mut init = redisCommandArg {
16621                name: b"wherefrom\0" as *const u8 as *const libc::c_char,
16622                type_0: ARG_TYPE_ONEOF,
16623                key_spec_index: -(1 as libc::c_int),
16624                token: 0 as *const libc::c_char,
16625                summary: 0 as *const libc::c_char,
16626                since: 0 as *const libc::c_char,
16627                flags: 0 as libc::c_int,
16628                deprecated_since: 0 as *const libc::c_char,
16629                subargs: LMOVE_wherefrom_Subargs.as_ptr() as *mut _,
16630                num_args: 0,
16631            };
16632            init
16633        },
16634        {
16635            let mut init = redisCommandArg {
16636                name: b"whereto\0" as *const u8 as *const libc::c_char,
16637                type_0: ARG_TYPE_ONEOF,
16638                key_spec_index: -(1 as libc::c_int),
16639                token: 0 as *const libc::c_char,
16640                summary: 0 as *const libc::c_char,
16641                since: 0 as *const libc::c_char,
16642                flags: 0 as libc::c_int,
16643                deprecated_since: 0 as *const libc::c_char,
16644                subargs: LMOVE_whereto_Subargs.as_ptr() as *mut _,
16645                num_args: 0,
16646            };
16647            init
16648        },
16649        {
16650            let mut init = redisCommandArg {
16651                name: 0 as *const libc::c_char,
16652                type_0: ARG_TYPE_STRING,
16653                key_spec_index: 0,
16654                token: 0 as *const libc::c_char,
16655                summary: 0 as *const libc::c_char,
16656                since: 0 as *const libc::c_char,
16657                flags: 0,
16658                deprecated_since: 0 as *const libc::c_char,
16659                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16660                num_args: 0,
16661            };
16662            init
16663        },
16664    ]
16665};
16666#[no_mangle]
16667pub static mut LMPOP_where_Subargs: [redisCommandArg; 3] = [
16668    {
16669        let mut init = redisCommandArg {
16670            name: b"left\0" as *const u8 as *const libc::c_char,
16671            type_0: ARG_TYPE_PURE_TOKEN,
16672            key_spec_index: -(1 as libc::c_int),
16673            token: b"LEFT\0" as *const u8 as *const libc::c_char,
16674            summary: 0 as *const libc::c_char,
16675            since: 0 as *const libc::c_char,
16676            flags: 0 as libc::c_int,
16677            deprecated_since: 0 as *const libc::c_char,
16678            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16679            num_args: 0,
16680        };
16681        init
16682    },
16683    {
16684        let mut init = redisCommandArg {
16685            name: b"right\0" as *const u8 as *const libc::c_char,
16686            type_0: ARG_TYPE_PURE_TOKEN,
16687            key_spec_index: -(1 as libc::c_int),
16688            token: b"RIGHT\0" as *const u8 as *const libc::c_char,
16689            summary: 0 as *const libc::c_char,
16690            since: 0 as *const libc::c_char,
16691            flags: 0 as libc::c_int,
16692            deprecated_since: 0 as *const libc::c_char,
16693            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16694            num_args: 0,
16695        };
16696        init
16697    },
16698    {
16699        let mut init = redisCommandArg {
16700            name: 0 as *const libc::c_char,
16701            type_0: ARG_TYPE_STRING,
16702            key_spec_index: 0,
16703            token: 0 as *const libc::c_char,
16704            summary: 0 as *const libc::c_char,
16705            since: 0 as *const libc::c_char,
16706            flags: 0,
16707            deprecated_since: 0 as *const libc::c_char,
16708            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16709            num_args: 0,
16710        };
16711        init
16712    },
16713];
16714#[no_mangle]
16715pub static mut LMPOP_Args: [redisCommandArg; 5] = unsafe {
16716    [
16717        {
16718            let mut init = redisCommandArg {
16719                name: b"numkeys\0" as *const u8 as *const libc::c_char,
16720                type_0: ARG_TYPE_INTEGER,
16721                key_spec_index: -(1 as libc::c_int),
16722                token: 0 as *const libc::c_char,
16723                summary: 0 as *const libc::c_char,
16724                since: 0 as *const libc::c_char,
16725                flags: 0 as libc::c_int,
16726                deprecated_since: 0 as *const libc::c_char,
16727                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16728                num_args: 0,
16729            };
16730            init
16731        },
16732        {
16733            let mut init = redisCommandArg {
16734                name: b"key\0" as *const u8 as *const libc::c_char,
16735                type_0: ARG_TYPE_KEY,
16736                key_spec_index: 0 as libc::c_int,
16737                token: 0 as *const libc::c_char,
16738                summary: 0 as *const libc::c_char,
16739                since: 0 as *const libc::c_char,
16740                flags: (1 as libc::c_int) << 1 as libc::c_int,
16741                deprecated_since: 0 as *const libc::c_char,
16742                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16743                num_args: 0,
16744            };
16745            init
16746        },
16747        {
16748            let mut init = redisCommandArg {
16749                name: b"where\0" as *const u8 as *const libc::c_char,
16750                type_0: ARG_TYPE_ONEOF,
16751                key_spec_index: -(1 as libc::c_int),
16752                token: 0 as *const libc::c_char,
16753                summary: 0 as *const libc::c_char,
16754                since: 0 as *const libc::c_char,
16755                flags: 0 as libc::c_int,
16756                deprecated_since: 0 as *const libc::c_char,
16757                subargs: LMPOP_where_Subargs.as_ptr() as *mut _,
16758                num_args: 0,
16759            };
16760            init
16761        },
16762        {
16763            let mut init = redisCommandArg {
16764                name: b"count\0" as *const u8 as *const libc::c_char,
16765                type_0: ARG_TYPE_INTEGER,
16766                key_spec_index: -(1 as libc::c_int),
16767                token: b"COUNT\0" as *const u8 as *const libc::c_char,
16768                summary: 0 as *const libc::c_char,
16769                since: 0 as *const libc::c_char,
16770                flags: (1 as libc::c_int) << 0 as libc::c_int,
16771                deprecated_since: 0 as *const libc::c_char,
16772                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16773                num_args: 0,
16774            };
16775            init
16776        },
16777        {
16778            let mut init = redisCommandArg {
16779                name: 0 as *const libc::c_char,
16780                type_0: ARG_TYPE_STRING,
16781                key_spec_index: 0,
16782                token: 0 as *const libc::c_char,
16783                summary: 0 as *const libc::c_char,
16784                since: 0 as *const libc::c_char,
16785                flags: 0,
16786                deprecated_since: 0 as *const libc::c_char,
16787                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16788                num_args: 0,
16789            };
16790            init
16791        },
16792    ]
16793};
16794#[no_mangle]
16795pub static mut LPOP_History: [commandHistory; 2] = [
16796    {
16797        let mut init = commandHistory {
16798            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
16799            changes: b"Added the `count` argument.\0" as *const u8 as *const libc::c_char,
16800        };
16801        init
16802    },
16803    {
16804        let mut init = commandHistory {
16805            since: 0 as *const libc::c_char,
16806            changes: 0 as *const libc::c_char,
16807        };
16808        init
16809    },
16810];
16811#[no_mangle]
16812pub static mut LPOP_Args: [redisCommandArg; 3] = [
16813    {
16814        let mut init = redisCommandArg {
16815            name: b"key\0" as *const u8 as *const libc::c_char,
16816            type_0: ARG_TYPE_KEY,
16817            key_spec_index: 0 as libc::c_int,
16818            token: 0 as *const libc::c_char,
16819            summary: 0 as *const libc::c_char,
16820            since: 0 as *const libc::c_char,
16821            flags: 0 as libc::c_int,
16822            deprecated_since: 0 as *const libc::c_char,
16823            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16824            num_args: 0,
16825        };
16826        init
16827    },
16828    {
16829        let mut init = redisCommandArg {
16830            name: b"count\0" as *const u8 as *const libc::c_char,
16831            type_0: ARG_TYPE_INTEGER,
16832            key_spec_index: -(1 as libc::c_int),
16833            token: 0 as *const libc::c_char,
16834            summary: 0 as *const libc::c_char,
16835            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
16836            flags: (1 as libc::c_int) << 0 as libc::c_int,
16837            deprecated_since: 0 as *const libc::c_char,
16838            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16839            num_args: 0,
16840        };
16841        init
16842    },
16843    {
16844        let mut init = redisCommandArg {
16845            name: 0 as *const libc::c_char,
16846            type_0: ARG_TYPE_STRING,
16847            key_spec_index: 0,
16848            token: 0 as *const libc::c_char,
16849            summary: 0 as *const libc::c_char,
16850            since: 0 as *const libc::c_char,
16851            flags: 0,
16852            deprecated_since: 0 as *const libc::c_char,
16853            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16854            num_args: 0,
16855        };
16856        init
16857    },
16858];
16859#[no_mangle]
16860pub static mut LPOS_Args: [redisCommandArg; 6] = [
16861    {
16862        let mut init = redisCommandArg {
16863            name: b"key\0" as *const u8 as *const libc::c_char,
16864            type_0: ARG_TYPE_KEY,
16865            key_spec_index: 0 as libc::c_int,
16866            token: 0 as *const libc::c_char,
16867            summary: 0 as *const libc::c_char,
16868            since: 0 as *const libc::c_char,
16869            flags: 0 as libc::c_int,
16870            deprecated_since: 0 as *const libc::c_char,
16871            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16872            num_args: 0,
16873        };
16874        init
16875    },
16876    {
16877        let mut init = redisCommandArg {
16878            name: b"element\0" as *const u8 as *const libc::c_char,
16879            type_0: ARG_TYPE_STRING,
16880            key_spec_index: -(1 as libc::c_int),
16881            token: 0 as *const libc::c_char,
16882            summary: 0 as *const libc::c_char,
16883            since: 0 as *const libc::c_char,
16884            flags: 0 as libc::c_int,
16885            deprecated_since: 0 as *const libc::c_char,
16886            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16887            num_args: 0,
16888        };
16889        init
16890    },
16891    {
16892        let mut init = redisCommandArg {
16893            name: b"rank\0" as *const u8 as *const libc::c_char,
16894            type_0: ARG_TYPE_INTEGER,
16895            key_spec_index: -(1 as libc::c_int),
16896            token: b"RANK\0" as *const u8 as *const libc::c_char,
16897            summary: 0 as *const libc::c_char,
16898            since: 0 as *const libc::c_char,
16899            flags: (1 as libc::c_int) << 0 as libc::c_int,
16900            deprecated_since: 0 as *const libc::c_char,
16901            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16902            num_args: 0,
16903        };
16904        init
16905    },
16906    {
16907        let mut init = redisCommandArg {
16908            name: b"num-matches\0" as *const u8 as *const libc::c_char,
16909            type_0: ARG_TYPE_INTEGER,
16910            key_spec_index: -(1 as libc::c_int),
16911            token: b"COUNT\0" as *const u8 as *const libc::c_char,
16912            summary: 0 as *const libc::c_char,
16913            since: 0 as *const libc::c_char,
16914            flags: (1 as libc::c_int) << 0 as libc::c_int,
16915            deprecated_since: 0 as *const libc::c_char,
16916            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16917            num_args: 0,
16918        };
16919        init
16920    },
16921    {
16922        let mut init = redisCommandArg {
16923            name: b"len\0" as *const u8 as *const libc::c_char,
16924            type_0: ARG_TYPE_INTEGER,
16925            key_spec_index: -(1 as libc::c_int),
16926            token: b"MAXLEN\0" as *const u8 as *const libc::c_char,
16927            summary: 0 as *const libc::c_char,
16928            since: 0 as *const libc::c_char,
16929            flags: (1 as libc::c_int) << 0 as libc::c_int,
16930            deprecated_since: 0 as *const libc::c_char,
16931            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16932            num_args: 0,
16933        };
16934        init
16935    },
16936    {
16937        let mut init = redisCommandArg {
16938            name: 0 as *const libc::c_char,
16939            type_0: ARG_TYPE_STRING,
16940            key_spec_index: 0,
16941            token: 0 as *const libc::c_char,
16942            summary: 0 as *const libc::c_char,
16943            since: 0 as *const libc::c_char,
16944            flags: 0,
16945            deprecated_since: 0 as *const libc::c_char,
16946            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16947            num_args: 0,
16948        };
16949        init
16950    },
16951];
16952#[no_mangle]
16953pub static mut LPUSH_History: [commandHistory; 2] = [
16954    {
16955        let mut init = commandHistory {
16956            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
16957            changes: b"Accepts multiple `element` arguments.\0" as *const u8
16958                as *const libc::c_char,
16959        };
16960        init
16961    },
16962    {
16963        let mut init = commandHistory {
16964            since: 0 as *const libc::c_char,
16965            changes: 0 as *const libc::c_char,
16966        };
16967        init
16968    },
16969];
16970#[no_mangle]
16971pub static mut LPUSH_Args: [redisCommandArg; 3] = [
16972    {
16973        let mut init = redisCommandArg {
16974            name: b"key\0" as *const u8 as *const libc::c_char,
16975            type_0: ARG_TYPE_KEY,
16976            key_spec_index: 0 as libc::c_int,
16977            token: 0 as *const libc::c_char,
16978            summary: 0 as *const libc::c_char,
16979            since: 0 as *const libc::c_char,
16980            flags: 0 as libc::c_int,
16981            deprecated_since: 0 as *const libc::c_char,
16982            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16983            num_args: 0,
16984        };
16985        init
16986    },
16987    {
16988        let mut init = redisCommandArg {
16989            name: b"element\0" as *const u8 as *const libc::c_char,
16990            type_0: ARG_TYPE_STRING,
16991            key_spec_index: -(1 as libc::c_int),
16992            token: 0 as *const libc::c_char,
16993            summary: 0 as *const libc::c_char,
16994            since: 0 as *const libc::c_char,
16995            flags: (1 as libc::c_int) << 1 as libc::c_int,
16996            deprecated_since: 0 as *const libc::c_char,
16997            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
16998            num_args: 0,
16999        };
17000        init
17001    },
17002    {
17003        let mut init = redisCommandArg {
17004            name: 0 as *const libc::c_char,
17005            type_0: ARG_TYPE_STRING,
17006            key_spec_index: 0,
17007            token: 0 as *const libc::c_char,
17008            summary: 0 as *const libc::c_char,
17009            since: 0 as *const libc::c_char,
17010            flags: 0,
17011            deprecated_since: 0 as *const libc::c_char,
17012            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17013            num_args: 0,
17014        };
17015        init
17016    },
17017];
17018#[no_mangle]
17019pub static mut LPUSHX_History: [commandHistory; 2] = [
17020    {
17021        let mut init = commandHistory {
17022            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
17023            changes: b"Accepts multiple `element` arguments.\0" as *const u8
17024                as *const libc::c_char,
17025        };
17026        init
17027    },
17028    {
17029        let mut init = commandHistory {
17030            since: 0 as *const libc::c_char,
17031            changes: 0 as *const libc::c_char,
17032        };
17033        init
17034    },
17035];
17036#[no_mangle]
17037pub static mut LPUSHX_Args: [redisCommandArg; 3] = [
17038    {
17039        let mut init = redisCommandArg {
17040            name: b"key\0" as *const u8 as *const libc::c_char,
17041            type_0: ARG_TYPE_KEY,
17042            key_spec_index: 0 as libc::c_int,
17043            token: 0 as *const libc::c_char,
17044            summary: 0 as *const libc::c_char,
17045            since: 0 as *const libc::c_char,
17046            flags: 0 as libc::c_int,
17047            deprecated_since: 0 as *const libc::c_char,
17048            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17049            num_args: 0,
17050        };
17051        init
17052    },
17053    {
17054        let mut init = redisCommandArg {
17055            name: b"element\0" as *const u8 as *const libc::c_char,
17056            type_0: ARG_TYPE_STRING,
17057            key_spec_index: -(1 as libc::c_int),
17058            token: 0 as *const libc::c_char,
17059            summary: 0 as *const libc::c_char,
17060            since: 0 as *const libc::c_char,
17061            flags: (1 as libc::c_int) << 1 as libc::c_int,
17062            deprecated_since: 0 as *const libc::c_char,
17063            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17064            num_args: 0,
17065        };
17066        init
17067    },
17068    {
17069        let mut init = redisCommandArg {
17070            name: 0 as *const libc::c_char,
17071            type_0: ARG_TYPE_STRING,
17072            key_spec_index: 0,
17073            token: 0 as *const libc::c_char,
17074            summary: 0 as *const libc::c_char,
17075            since: 0 as *const libc::c_char,
17076            flags: 0,
17077            deprecated_since: 0 as *const libc::c_char,
17078            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17079            num_args: 0,
17080        };
17081        init
17082    },
17083];
17084#[no_mangle]
17085pub static mut LRANGE_Args: [redisCommandArg; 4] = [
17086    {
17087        let mut init = redisCommandArg {
17088            name: b"key\0" as *const u8 as *const libc::c_char,
17089            type_0: ARG_TYPE_KEY,
17090            key_spec_index: 0 as libc::c_int,
17091            token: 0 as *const libc::c_char,
17092            summary: 0 as *const libc::c_char,
17093            since: 0 as *const libc::c_char,
17094            flags: 0 as libc::c_int,
17095            deprecated_since: 0 as *const libc::c_char,
17096            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17097            num_args: 0,
17098        };
17099        init
17100    },
17101    {
17102        let mut init = redisCommandArg {
17103            name: b"start\0" as *const u8 as *const libc::c_char,
17104            type_0: ARG_TYPE_INTEGER,
17105            key_spec_index: -(1 as libc::c_int),
17106            token: 0 as *const libc::c_char,
17107            summary: 0 as *const libc::c_char,
17108            since: 0 as *const libc::c_char,
17109            flags: 0 as libc::c_int,
17110            deprecated_since: 0 as *const libc::c_char,
17111            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17112            num_args: 0,
17113        };
17114        init
17115    },
17116    {
17117        let mut init = redisCommandArg {
17118            name: b"stop\0" as *const u8 as *const libc::c_char,
17119            type_0: ARG_TYPE_INTEGER,
17120            key_spec_index: -(1 as libc::c_int),
17121            token: 0 as *const libc::c_char,
17122            summary: 0 as *const libc::c_char,
17123            since: 0 as *const libc::c_char,
17124            flags: 0 as libc::c_int,
17125            deprecated_since: 0 as *const libc::c_char,
17126            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17127            num_args: 0,
17128        };
17129        init
17130    },
17131    {
17132        let mut init = redisCommandArg {
17133            name: 0 as *const libc::c_char,
17134            type_0: ARG_TYPE_STRING,
17135            key_spec_index: 0,
17136            token: 0 as *const libc::c_char,
17137            summary: 0 as *const libc::c_char,
17138            since: 0 as *const libc::c_char,
17139            flags: 0,
17140            deprecated_since: 0 as *const libc::c_char,
17141            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17142            num_args: 0,
17143        };
17144        init
17145    },
17146];
17147#[no_mangle]
17148pub static mut LREM_Args: [redisCommandArg; 4] = [
17149    {
17150        let mut init = redisCommandArg {
17151            name: b"key\0" as *const u8 as *const libc::c_char,
17152            type_0: ARG_TYPE_KEY,
17153            key_spec_index: 0 as libc::c_int,
17154            token: 0 as *const libc::c_char,
17155            summary: 0 as *const libc::c_char,
17156            since: 0 as *const libc::c_char,
17157            flags: 0 as libc::c_int,
17158            deprecated_since: 0 as *const libc::c_char,
17159            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17160            num_args: 0,
17161        };
17162        init
17163    },
17164    {
17165        let mut init = redisCommandArg {
17166            name: b"count\0" as *const u8 as *const libc::c_char,
17167            type_0: ARG_TYPE_INTEGER,
17168            key_spec_index: -(1 as libc::c_int),
17169            token: 0 as *const libc::c_char,
17170            summary: 0 as *const libc::c_char,
17171            since: 0 as *const libc::c_char,
17172            flags: 0 as libc::c_int,
17173            deprecated_since: 0 as *const libc::c_char,
17174            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17175            num_args: 0,
17176        };
17177        init
17178    },
17179    {
17180        let mut init = redisCommandArg {
17181            name: b"element\0" as *const u8 as *const libc::c_char,
17182            type_0: ARG_TYPE_STRING,
17183            key_spec_index: -(1 as libc::c_int),
17184            token: 0 as *const libc::c_char,
17185            summary: 0 as *const libc::c_char,
17186            since: 0 as *const libc::c_char,
17187            flags: 0 as libc::c_int,
17188            deprecated_since: 0 as *const libc::c_char,
17189            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17190            num_args: 0,
17191        };
17192        init
17193    },
17194    {
17195        let mut init = redisCommandArg {
17196            name: 0 as *const libc::c_char,
17197            type_0: ARG_TYPE_STRING,
17198            key_spec_index: 0,
17199            token: 0 as *const libc::c_char,
17200            summary: 0 as *const libc::c_char,
17201            since: 0 as *const libc::c_char,
17202            flags: 0,
17203            deprecated_since: 0 as *const libc::c_char,
17204            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17205            num_args: 0,
17206        };
17207        init
17208    },
17209];
17210#[no_mangle]
17211pub static mut LSET_Args: [redisCommandArg; 4] = [
17212    {
17213        let mut init = redisCommandArg {
17214            name: b"key\0" as *const u8 as *const libc::c_char,
17215            type_0: ARG_TYPE_KEY,
17216            key_spec_index: 0 as libc::c_int,
17217            token: 0 as *const libc::c_char,
17218            summary: 0 as *const libc::c_char,
17219            since: 0 as *const libc::c_char,
17220            flags: 0 as libc::c_int,
17221            deprecated_since: 0 as *const libc::c_char,
17222            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17223            num_args: 0,
17224        };
17225        init
17226    },
17227    {
17228        let mut init = redisCommandArg {
17229            name: b"index\0" as *const u8 as *const libc::c_char,
17230            type_0: ARG_TYPE_INTEGER,
17231            key_spec_index: -(1 as libc::c_int),
17232            token: 0 as *const libc::c_char,
17233            summary: 0 as *const libc::c_char,
17234            since: 0 as *const libc::c_char,
17235            flags: 0 as libc::c_int,
17236            deprecated_since: 0 as *const libc::c_char,
17237            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17238            num_args: 0,
17239        };
17240        init
17241    },
17242    {
17243        let mut init = redisCommandArg {
17244            name: b"element\0" as *const u8 as *const libc::c_char,
17245            type_0: ARG_TYPE_STRING,
17246            key_spec_index: -(1 as libc::c_int),
17247            token: 0 as *const libc::c_char,
17248            summary: 0 as *const libc::c_char,
17249            since: 0 as *const libc::c_char,
17250            flags: 0 as libc::c_int,
17251            deprecated_since: 0 as *const libc::c_char,
17252            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17253            num_args: 0,
17254        };
17255        init
17256    },
17257    {
17258        let mut init = redisCommandArg {
17259            name: 0 as *const libc::c_char,
17260            type_0: ARG_TYPE_STRING,
17261            key_spec_index: 0,
17262            token: 0 as *const libc::c_char,
17263            summary: 0 as *const libc::c_char,
17264            since: 0 as *const libc::c_char,
17265            flags: 0,
17266            deprecated_since: 0 as *const libc::c_char,
17267            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17268            num_args: 0,
17269        };
17270        init
17271    },
17272];
17273#[no_mangle]
17274pub static mut LTRIM_Args: [redisCommandArg; 4] = [
17275    {
17276        let mut init = redisCommandArg {
17277            name: b"key\0" as *const u8 as *const libc::c_char,
17278            type_0: ARG_TYPE_KEY,
17279            key_spec_index: 0 as libc::c_int,
17280            token: 0 as *const libc::c_char,
17281            summary: 0 as *const libc::c_char,
17282            since: 0 as *const libc::c_char,
17283            flags: 0 as libc::c_int,
17284            deprecated_since: 0 as *const libc::c_char,
17285            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17286            num_args: 0,
17287        };
17288        init
17289    },
17290    {
17291        let mut init = redisCommandArg {
17292            name: b"start\0" as *const u8 as *const libc::c_char,
17293            type_0: ARG_TYPE_INTEGER,
17294            key_spec_index: -(1 as libc::c_int),
17295            token: 0 as *const libc::c_char,
17296            summary: 0 as *const libc::c_char,
17297            since: 0 as *const libc::c_char,
17298            flags: 0 as libc::c_int,
17299            deprecated_since: 0 as *const libc::c_char,
17300            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17301            num_args: 0,
17302        };
17303        init
17304    },
17305    {
17306        let mut init = redisCommandArg {
17307            name: b"stop\0" as *const u8 as *const libc::c_char,
17308            type_0: ARG_TYPE_INTEGER,
17309            key_spec_index: -(1 as libc::c_int),
17310            token: 0 as *const libc::c_char,
17311            summary: 0 as *const libc::c_char,
17312            since: 0 as *const libc::c_char,
17313            flags: 0 as libc::c_int,
17314            deprecated_since: 0 as *const libc::c_char,
17315            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17316            num_args: 0,
17317        };
17318        init
17319    },
17320    {
17321        let mut init = redisCommandArg {
17322            name: 0 as *const libc::c_char,
17323            type_0: ARG_TYPE_STRING,
17324            key_spec_index: 0,
17325            token: 0 as *const libc::c_char,
17326            summary: 0 as *const libc::c_char,
17327            since: 0 as *const libc::c_char,
17328            flags: 0,
17329            deprecated_since: 0 as *const libc::c_char,
17330            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17331            num_args: 0,
17332        };
17333        init
17334    },
17335];
17336#[no_mangle]
17337pub static mut RPOP_History: [commandHistory; 2] = [
17338    {
17339        let mut init = commandHistory {
17340            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
17341            changes: b"Added the `count` argument.\0" as *const u8 as *const libc::c_char,
17342        };
17343        init
17344    },
17345    {
17346        let mut init = commandHistory {
17347            since: 0 as *const libc::c_char,
17348            changes: 0 as *const libc::c_char,
17349        };
17350        init
17351    },
17352];
17353#[no_mangle]
17354pub static mut RPOP_Args: [redisCommandArg; 3] = [
17355    {
17356        let mut init = redisCommandArg {
17357            name: b"key\0" as *const u8 as *const libc::c_char,
17358            type_0: ARG_TYPE_KEY,
17359            key_spec_index: 0 as libc::c_int,
17360            token: 0 as *const libc::c_char,
17361            summary: 0 as *const libc::c_char,
17362            since: 0 as *const libc::c_char,
17363            flags: 0 as libc::c_int,
17364            deprecated_since: 0 as *const libc::c_char,
17365            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17366            num_args: 0,
17367        };
17368        init
17369    },
17370    {
17371        let mut init = redisCommandArg {
17372            name: b"count\0" as *const u8 as *const libc::c_char,
17373            type_0: ARG_TYPE_INTEGER,
17374            key_spec_index: -(1 as libc::c_int),
17375            token: 0 as *const libc::c_char,
17376            summary: 0 as *const libc::c_char,
17377            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
17378            flags: (1 as libc::c_int) << 0 as libc::c_int,
17379            deprecated_since: 0 as *const libc::c_char,
17380            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17381            num_args: 0,
17382        };
17383        init
17384    },
17385    {
17386        let mut init = redisCommandArg {
17387            name: 0 as *const libc::c_char,
17388            type_0: ARG_TYPE_STRING,
17389            key_spec_index: 0,
17390            token: 0 as *const libc::c_char,
17391            summary: 0 as *const libc::c_char,
17392            since: 0 as *const libc::c_char,
17393            flags: 0,
17394            deprecated_since: 0 as *const libc::c_char,
17395            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17396            num_args: 0,
17397        };
17398        init
17399    },
17400];
17401#[no_mangle]
17402pub static mut RPOPLPUSH_Args: [redisCommandArg; 3] = [
17403    {
17404        let mut init = redisCommandArg {
17405            name: b"source\0" as *const u8 as *const libc::c_char,
17406            type_0: ARG_TYPE_KEY,
17407            key_spec_index: 0 as libc::c_int,
17408            token: 0 as *const libc::c_char,
17409            summary: 0 as *const libc::c_char,
17410            since: 0 as *const libc::c_char,
17411            flags: 0 as libc::c_int,
17412            deprecated_since: 0 as *const libc::c_char,
17413            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17414            num_args: 0,
17415        };
17416        init
17417    },
17418    {
17419        let mut init = redisCommandArg {
17420            name: b"destination\0" as *const u8 as *const libc::c_char,
17421            type_0: ARG_TYPE_KEY,
17422            key_spec_index: 1 as libc::c_int,
17423            token: 0 as *const libc::c_char,
17424            summary: 0 as *const libc::c_char,
17425            since: 0 as *const libc::c_char,
17426            flags: 0 as libc::c_int,
17427            deprecated_since: 0 as *const libc::c_char,
17428            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17429            num_args: 0,
17430        };
17431        init
17432    },
17433    {
17434        let mut init = redisCommandArg {
17435            name: 0 as *const libc::c_char,
17436            type_0: ARG_TYPE_STRING,
17437            key_spec_index: 0,
17438            token: 0 as *const libc::c_char,
17439            summary: 0 as *const libc::c_char,
17440            since: 0 as *const libc::c_char,
17441            flags: 0,
17442            deprecated_since: 0 as *const libc::c_char,
17443            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17444            num_args: 0,
17445        };
17446        init
17447    },
17448];
17449#[no_mangle]
17450pub static mut RPUSH_History: [commandHistory; 2] = [
17451    {
17452        let mut init = commandHistory {
17453            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
17454            changes: b"Accepts multiple `element` arguments.\0" as *const u8
17455                as *const libc::c_char,
17456        };
17457        init
17458    },
17459    {
17460        let mut init = commandHistory {
17461            since: 0 as *const libc::c_char,
17462            changes: 0 as *const libc::c_char,
17463        };
17464        init
17465    },
17466];
17467#[no_mangle]
17468pub static mut RPUSH_Args: [redisCommandArg; 3] = [
17469    {
17470        let mut init = redisCommandArg {
17471            name: b"key\0" as *const u8 as *const libc::c_char,
17472            type_0: ARG_TYPE_KEY,
17473            key_spec_index: 0 as libc::c_int,
17474            token: 0 as *const libc::c_char,
17475            summary: 0 as *const libc::c_char,
17476            since: 0 as *const libc::c_char,
17477            flags: 0 as libc::c_int,
17478            deprecated_since: 0 as *const libc::c_char,
17479            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17480            num_args: 0,
17481        };
17482        init
17483    },
17484    {
17485        let mut init = redisCommandArg {
17486            name: b"element\0" as *const u8 as *const libc::c_char,
17487            type_0: ARG_TYPE_STRING,
17488            key_spec_index: -(1 as libc::c_int),
17489            token: 0 as *const libc::c_char,
17490            summary: 0 as *const libc::c_char,
17491            since: 0 as *const libc::c_char,
17492            flags: (1 as libc::c_int) << 1 as libc::c_int,
17493            deprecated_since: 0 as *const libc::c_char,
17494            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17495            num_args: 0,
17496        };
17497        init
17498    },
17499    {
17500        let mut init = redisCommandArg {
17501            name: 0 as *const libc::c_char,
17502            type_0: ARG_TYPE_STRING,
17503            key_spec_index: 0,
17504            token: 0 as *const libc::c_char,
17505            summary: 0 as *const libc::c_char,
17506            since: 0 as *const libc::c_char,
17507            flags: 0,
17508            deprecated_since: 0 as *const libc::c_char,
17509            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17510            num_args: 0,
17511        };
17512        init
17513    },
17514];
17515#[no_mangle]
17516pub static mut RPUSHX_History: [commandHistory; 2] = [
17517    {
17518        let mut init = commandHistory {
17519            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
17520            changes: b"Accepts multiple `element` arguments.\0" as *const u8
17521                as *const libc::c_char,
17522        };
17523        init
17524    },
17525    {
17526        let mut init = commandHistory {
17527            since: 0 as *const libc::c_char,
17528            changes: 0 as *const libc::c_char,
17529        };
17530        init
17531    },
17532];
17533#[no_mangle]
17534pub static mut RPUSHX_Args: [redisCommandArg; 3] = [
17535    {
17536        let mut init = redisCommandArg {
17537            name: b"key\0" as *const u8 as *const libc::c_char,
17538            type_0: ARG_TYPE_KEY,
17539            key_spec_index: 0 as libc::c_int,
17540            token: 0 as *const libc::c_char,
17541            summary: 0 as *const libc::c_char,
17542            since: 0 as *const libc::c_char,
17543            flags: 0 as libc::c_int,
17544            deprecated_since: 0 as *const libc::c_char,
17545            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17546            num_args: 0,
17547        };
17548        init
17549    },
17550    {
17551        let mut init = redisCommandArg {
17552            name: b"element\0" as *const u8 as *const libc::c_char,
17553            type_0: ARG_TYPE_STRING,
17554            key_spec_index: -(1 as libc::c_int),
17555            token: 0 as *const libc::c_char,
17556            summary: 0 as *const libc::c_char,
17557            since: 0 as *const libc::c_char,
17558            flags: (1 as libc::c_int) << 1 as libc::c_int,
17559            deprecated_since: 0 as *const libc::c_char,
17560            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17561            num_args: 0,
17562        };
17563        init
17564    },
17565    {
17566        let mut init = redisCommandArg {
17567            name: 0 as *const libc::c_char,
17568            type_0: ARG_TYPE_STRING,
17569            key_spec_index: 0,
17570            token: 0 as *const libc::c_char,
17571            summary: 0 as *const libc::c_char,
17572            since: 0 as *const libc::c_char,
17573            flags: 0,
17574            deprecated_since: 0 as *const libc::c_char,
17575            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17576            num_args: 0,
17577        };
17578        init
17579    },
17580];
17581#[no_mangle]
17582pub static mut PSUBSCRIBE_pattern_Subargs: [redisCommandArg; 2] = [
17583    {
17584        let mut init = redisCommandArg {
17585            name: b"pattern\0" as *const u8 as *const libc::c_char,
17586            type_0: ARG_TYPE_PATTERN,
17587            key_spec_index: -(1 as libc::c_int),
17588            token: 0 as *const libc::c_char,
17589            summary: 0 as *const libc::c_char,
17590            since: 0 as *const libc::c_char,
17591            flags: 0 as libc::c_int,
17592            deprecated_since: 0 as *const libc::c_char,
17593            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17594            num_args: 0,
17595        };
17596        init
17597    },
17598    {
17599        let mut init = redisCommandArg {
17600            name: 0 as *const libc::c_char,
17601            type_0: ARG_TYPE_STRING,
17602            key_spec_index: 0,
17603            token: 0 as *const libc::c_char,
17604            summary: 0 as *const libc::c_char,
17605            since: 0 as *const libc::c_char,
17606            flags: 0,
17607            deprecated_since: 0 as *const libc::c_char,
17608            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17609            num_args: 0,
17610        };
17611        init
17612    },
17613];
17614#[no_mangle]
17615pub static mut PSUBSCRIBE_Args: [redisCommandArg; 2] = unsafe {
17616    [
17617        {
17618            let mut init = redisCommandArg {
17619                name: b"pattern\0" as *const u8 as *const libc::c_char,
17620                type_0: ARG_TYPE_BLOCK,
17621                key_spec_index: -(1 as libc::c_int),
17622                token: 0 as *const libc::c_char,
17623                summary: 0 as *const libc::c_char,
17624                since: 0 as *const libc::c_char,
17625                flags: (1 as libc::c_int) << 1 as libc::c_int,
17626                deprecated_since: 0 as *const libc::c_char,
17627                subargs: PSUBSCRIBE_pattern_Subargs.as_ptr() as *mut _,
17628                num_args: 0,
17629            };
17630            init
17631        },
17632        {
17633            let mut init = redisCommandArg {
17634                name: 0 as *const libc::c_char,
17635                type_0: ARG_TYPE_STRING,
17636                key_spec_index: 0,
17637                token: 0 as *const libc::c_char,
17638                summary: 0 as *const libc::c_char,
17639                since: 0 as *const libc::c_char,
17640                flags: 0,
17641                deprecated_since: 0 as *const libc::c_char,
17642                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17643                num_args: 0,
17644            };
17645            init
17646        },
17647    ]
17648};
17649#[no_mangle]
17650pub static mut PUBLISH_Args: [redisCommandArg; 3] = [
17651    {
17652        let mut init = redisCommandArg {
17653            name: b"channel\0" as *const u8 as *const libc::c_char,
17654            type_0: ARG_TYPE_STRING,
17655            key_spec_index: -(1 as libc::c_int),
17656            token: 0 as *const libc::c_char,
17657            summary: 0 as *const libc::c_char,
17658            since: 0 as *const libc::c_char,
17659            flags: 0 as libc::c_int,
17660            deprecated_since: 0 as *const libc::c_char,
17661            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17662            num_args: 0,
17663        };
17664        init
17665    },
17666    {
17667        let mut init = redisCommandArg {
17668            name: b"message\0" as *const u8 as *const libc::c_char,
17669            type_0: ARG_TYPE_STRING,
17670            key_spec_index: -(1 as libc::c_int),
17671            token: 0 as *const libc::c_char,
17672            summary: 0 as *const libc::c_char,
17673            since: 0 as *const libc::c_char,
17674            flags: 0 as libc::c_int,
17675            deprecated_since: 0 as *const libc::c_char,
17676            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17677            num_args: 0,
17678        };
17679        init
17680    },
17681    {
17682        let mut init = redisCommandArg {
17683            name: 0 as *const libc::c_char,
17684            type_0: ARG_TYPE_STRING,
17685            key_spec_index: 0,
17686            token: 0 as *const libc::c_char,
17687            summary: 0 as *const libc::c_char,
17688            since: 0 as *const libc::c_char,
17689            flags: 0,
17690            deprecated_since: 0 as *const libc::c_char,
17691            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17692            num_args: 0,
17693        };
17694        init
17695    },
17696];
17697#[no_mangle]
17698pub static mut PUBSUB_CHANNELS_Args: [redisCommandArg; 2] = [
17699    {
17700        let mut init = redisCommandArg {
17701            name: b"pattern\0" as *const u8 as *const libc::c_char,
17702            type_0: ARG_TYPE_PATTERN,
17703            key_spec_index: -(1 as libc::c_int),
17704            token: 0 as *const libc::c_char,
17705            summary: 0 as *const libc::c_char,
17706            since: 0 as *const libc::c_char,
17707            flags: (1 as libc::c_int) << 0 as libc::c_int,
17708            deprecated_since: 0 as *const libc::c_char,
17709            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17710            num_args: 0,
17711        };
17712        init
17713    },
17714    {
17715        let mut init = redisCommandArg {
17716            name: 0 as *const libc::c_char,
17717            type_0: ARG_TYPE_STRING,
17718            key_spec_index: 0,
17719            token: 0 as *const libc::c_char,
17720            summary: 0 as *const libc::c_char,
17721            since: 0 as *const libc::c_char,
17722            flags: 0,
17723            deprecated_since: 0 as *const libc::c_char,
17724            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17725            num_args: 0,
17726        };
17727        init
17728    },
17729];
17730#[no_mangle]
17731pub static mut PUBSUB_NUMSUB_Args: [redisCommandArg; 2] = [
17732    {
17733        let mut init = redisCommandArg {
17734            name: b"channel\0" as *const u8 as *const libc::c_char,
17735            type_0: ARG_TYPE_STRING,
17736            key_spec_index: -(1 as libc::c_int),
17737            token: 0 as *const libc::c_char,
17738            summary: 0 as *const libc::c_char,
17739            since: 0 as *const libc::c_char,
17740            flags: (1 as libc::c_int) << 0 as libc::c_int
17741                | (1 as libc::c_int) << 1 as libc::c_int,
17742            deprecated_since: 0 as *const libc::c_char,
17743            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17744            num_args: 0,
17745        };
17746        init
17747    },
17748    {
17749        let mut init = redisCommandArg {
17750            name: 0 as *const libc::c_char,
17751            type_0: ARG_TYPE_STRING,
17752            key_spec_index: 0,
17753            token: 0 as *const libc::c_char,
17754            summary: 0 as *const libc::c_char,
17755            since: 0 as *const libc::c_char,
17756            flags: 0,
17757            deprecated_since: 0 as *const libc::c_char,
17758            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17759            num_args: 0,
17760        };
17761        init
17762    },
17763];
17764#[no_mangle]
17765pub static mut PUBSUB_SHARDCHANNELS_Args: [redisCommandArg; 2] = [
17766    {
17767        let mut init = redisCommandArg {
17768            name: b"pattern\0" as *const u8 as *const libc::c_char,
17769            type_0: ARG_TYPE_PATTERN,
17770            key_spec_index: -(1 as libc::c_int),
17771            token: 0 as *const libc::c_char,
17772            summary: 0 as *const libc::c_char,
17773            since: 0 as *const libc::c_char,
17774            flags: (1 as libc::c_int) << 0 as libc::c_int,
17775            deprecated_since: 0 as *const libc::c_char,
17776            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17777            num_args: 0,
17778        };
17779        init
17780    },
17781    {
17782        let mut init = redisCommandArg {
17783            name: 0 as *const libc::c_char,
17784            type_0: ARG_TYPE_STRING,
17785            key_spec_index: 0,
17786            token: 0 as *const libc::c_char,
17787            summary: 0 as *const libc::c_char,
17788            since: 0 as *const libc::c_char,
17789            flags: 0,
17790            deprecated_since: 0 as *const libc::c_char,
17791            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17792            num_args: 0,
17793        };
17794        init
17795    },
17796];
17797#[no_mangle]
17798pub static mut PUBSUB_SHARDNUMSUB_Args: [redisCommandArg; 2] = [
17799    {
17800        let mut init = redisCommandArg {
17801            name: b"shardchannel\0" as *const u8 as *const libc::c_char,
17802            type_0: ARG_TYPE_STRING,
17803            key_spec_index: -(1 as libc::c_int),
17804            token: 0 as *const libc::c_char,
17805            summary: 0 as *const libc::c_char,
17806            since: 0 as *const libc::c_char,
17807            flags: (1 as libc::c_int) << 0 as libc::c_int
17808                | (1 as libc::c_int) << 1 as libc::c_int,
17809            deprecated_since: 0 as *const libc::c_char,
17810            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17811            num_args: 0,
17812        };
17813        init
17814    },
17815    {
17816        let mut init = redisCommandArg {
17817            name: 0 as *const libc::c_char,
17818            type_0: ARG_TYPE_STRING,
17819            key_spec_index: 0,
17820            token: 0 as *const libc::c_char,
17821            summary: 0 as *const libc::c_char,
17822            since: 0 as *const libc::c_char,
17823            flags: 0,
17824            deprecated_since: 0 as *const libc::c_char,
17825            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
17826            num_args: 0,
17827        };
17828        init
17829    },
17830];
17831#[no_mangle]
17832pub static mut PUBSUB_Subcommands: [redisCommand; 7] = unsafe {
17833    [
17834        {
17835            let mut init = redisCommand {
17836                declared_name: b"channels\0" as *const u8 as *const libc::c_char,
17837                summary: b"List active channels\0" as *const u8 as *const libc::c_char,
17838                complexity: b"O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)\0"
17839                    as *const u8 as *const libc::c_char,
17840                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
17841                doc_flags: 0 as libc::c_int,
17842                replaced_by: 0 as *const libc::c_char,
17843                deprecated_since: 0 as *const libc::c_char,
17844                group: COMMAND_GROUP_PUBSUB,
17845                history: 0 as *const commandHistory as *mut commandHistory,
17846                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
17847                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
17848                arity: -(2 as libc::c_int),
17849                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
17850                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
17851                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
17852                acl_categories: 0 as libc::c_int as uint64_t,
17853                key_specs_static: [keySpec {
17854                    notes: 0 as *const libc::c_char,
17855                    flags: 0,
17856                    begin_search_type: KSPEC_BS_INVALID,
17857                    bs: C2RustUnnamed_3 {
17858                        index: C2RustUnnamed_5 { pos: 0 },
17859                    },
17860                    find_keys_type: KSPEC_FK_INVALID,
17861                    fk: C2RustUnnamed_0 {
17862                        range: C2RustUnnamed_2 {
17863                            lastkey: 0,
17864                            keystep: 0,
17865                            limit: 0,
17866                        },
17867                    },
17868                }; 4],
17869                getkeys_proc: None,
17870                subcommands: 0 as *const redisCommand as *mut redisCommand,
17871                args: PUBSUB_CHANNELS_Args.as_ptr() as *mut _,
17872                microseconds: 0,
17873                calls: 0,
17874                rejected_calls: 0,
17875                failed_calls: 0,
17876                id: 0,
17877                fullname: 0 as *const libc::c_char as *mut libc::c_char,
17878                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
17879                key_specs: 0 as *const keySpec as *mut keySpec,
17880                legacy_range_key_spec: keySpec {
17881                    notes: 0 as *const libc::c_char,
17882                    flags: 0,
17883                    begin_search_type: KSPEC_BS_INVALID,
17884                    bs: C2RustUnnamed_3 {
17885                        index: C2RustUnnamed_5 { pos: 0 },
17886                    },
17887                    find_keys_type: KSPEC_FK_INVALID,
17888                    fk: C2RustUnnamed_0 {
17889                        range: C2RustUnnamed_2 {
17890                            lastkey: 0,
17891                            keystep: 0,
17892                            limit: 0,
17893                        },
17894                    },
17895                },
17896                num_args: 0,
17897                num_history: 0,
17898                num_tips: 0,
17899                key_specs_num: 0,
17900                key_specs_max: 0,
17901                subcommands_dict: 0 as *const dict as *mut dict,
17902                parent: 0 as *const redisCommand as *mut redisCommand,
17903                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
17904            };
17905            init
17906        },
17907        {
17908            let mut init = redisCommand {
17909                declared_name: b"help\0" as *const u8 as *const libc::c_char,
17910                summary: b"Show helpful text about the different subcommands\0"
17911                    as *const u8 as *const libc::c_char,
17912                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
17913                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
17914                doc_flags: 0 as libc::c_int,
17915                replaced_by: 0 as *const libc::c_char,
17916                deprecated_since: 0 as *const libc::c_char,
17917                group: COMMAND_GROUP_PUBSUB,
17918                history: 0 as *const commandHistory as *mut commandHistory,
17919                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
17920                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
17921                arity: 2 as libc::c_int,
17922                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
17923                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
17924                acl_categories: 0 as libc::c_int as uint64_t,
17925                key_specs_static: [keySpec {
17926                    notes: 0 as *const libc::c_char,
17927                    flags: 0,
17928                    begin_search_type: KSPEC_BS_INVALID,
17929                    bs: C2RustUnnamed_3 {
17930                        index: C2RustUnnamed_5 { pos: 0 },
17931                    },
17932                    find_keys_type: KSPEC_FK_INVALID,
17933                    fk: C2RustUnnamed_0 {
17934                        range: C2RustUnnamed_2 {
17935                            lastkey: 0,
17936                            keystep: 0,
17937                            limit: 0,
17938                        },
17939                    },
17940                }; 4],
17941                getkeys_proc: None,
17942                subcommands: 0 as *const redisCommand as *mut redisCommand,
17943                args: 0 as *const redisCommandArg as *mut redisCommandArg,
17944                microseconds: 0,
17945                calls: 0,
17946                rejected_calls: 0,
17947                failed_calls: 0,
17948                id: 0,
17949                fullname: 0 as *const libc::c_char as *mut libc::c_char,
17950                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
17951                key_specs: 0 as *const keySpec as *mut keySpec,
17952                legacy_range_key_spec: keySpec {
17953                    notes: 0 as *const libc::c_char,
17954                    flags: 0,
17955                    begin_search_type: KSPEC_BS_INVALID,
17956                    bs: C2RustUnnamed_3 {
17957                        index: C2RustUnnamed_5 { pos: 0 },
17958                    },
17959                    find_keys_type: KSPEC_FK_INVALID,
17960                    fk: C2RustUnnamed_0 {
17961                        range: C2RustUnnamed_2 {
17962                            lastkey: 0,
17963                            keystep: 0,
17964                            limit: 0,
17965                        },
17966                    },
17967                },
17968                num_args: 0,
17969                num_history: 0,
17970                num_tips: 0,
17971                key_specs_num: 0,
17972                key_specs_max: 0,
17973                subcommands_dict: 0 as *const dict as *mut dict,
17974                parent: 0 as *const redisCommand as *mut redisCommand,
17975                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
17976            };
17977            init
17978        },
17979        {
17980            let mut init = redisCommand {
17981                declared_name: b"numpat\0" as *const u8 as *const libc::c_char,
17982                summary: b"Get the count of unique patterns pattern subscriptions\0"
17983                    as *const u8 as *const libc::c_char,
17984                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
17985                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
17986                doc_flags: 0 as libc::c_int,
17987                replaced_by: 0 as *const libc::c_char,
17988                deprecated_since: 0 as *const libc::c_char,
17989                group: COMMAND_GROUP_PUBSUB,
17990                history: 0 as *const commandHistory as *mut commandHistory,
17991                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
17992                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
17993                arity: 2 as libc::c_int,
17994                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
17995                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
17996                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
17997                acl_categories: 0 as libc::c_int as uint64_t,
17998                key_specs_static: [keySpec {
17999                    notes: 0 as *const libc::c_char,
18000                    flags: 0,
18001                    begin_search_type: KSPEC_BS_INVALID,
18002                    bs: C2RustUnnamed_3 {
18003                        index: C2RustUnnamed_5 { pos: 0 },
18004                    },
18005                    find_keys_type: KSPEC_FK_INVALID,
18006                    fk: C2RustUnnamed_0 {
18007                        range: C2RustUnnamed_2 {
18008                            lastkey: 0,
18009                            keystep: 0,
18010                            limit: 0,
18011                        },
18012                    },
18013                }; 4],
18014                getkeys_proc: None,
18015                subcommands: 0 as *const redisCommand as *mut redisCommand,
18016                args: 0 as *const redisCommandArg as *mut redisCommandArg,
18017                microseconds: 0,
18018                calls: 0,
18019                rejected_calls: 0,
18020                failed_calls: 0,
18021                id: 0,
18022                fullname: 0 as *const libc::c_char as *mut libc::c_char,
18023                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
18024                key_specs: 0 as *const keySpec as *mut keySpec,
18025                legacy_range_key_spec: keySpec {
18026                    notes: 0 as *const libc::c_char,
18027                    flags: 0,
18028                    begin_search_type: KSPEC_BS_INVALID,
18029                    bs: C2RustUnnamed_3 {
18030                        index: C2RustUnnamed_5 { pos: 0 },
18031                    },
18032                    find_keys_type: KSPEC_FK_INVALID,
18033                    fk: C2RustUnnamed_0 {
18034                        range: C2RustUnnamed_2 {
18035                            lastkey: 0,
18036                            keystep: 0,
18037                            limit: 0,
18038                        },
18039                    },
18040                },
18041                num_args: 0,
18042                num_history: 0,
18043                num_tips: 0,
18044                key_specs_num: 0,
18045                key_specs_max: 0,
18046                subcommands_dict: 0 as *const dict as *mut dict,
18047                parent: 0 as *const redisCommand as *mut redisCommand,
18048                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
18049            };
18050            init
18051        },
18052        {
18053            let mut init = redisCommand {
18054                declared_name: b"numsub\0" as *const u8 as *const libc::c_char,
18055                summary: b"Get the count of subscribers for channels\0" as *const u8
18056                    as *const libc::c_char,
18057                complexity: b"O(N) for the NUMSUB subcommand, where N is the number of requested channels\0"
18058                    as *const u8 as *const libc::c_char,
18059                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
18060                doc_flags: 0 as libc::c_int,
18061                replaced_by: 0 as *const libc::c_char,
18062                deprecated_since: 0 as *const libc::c_char,
18063                group: COMMAND_GROUP_PUBSUB,
18064                history: 0 as *const commandHistory as *mut commandHistory,
18065                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
18066                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
18067                arity: -(2 as libc::c_int),
18068                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
18069                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
18070                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
18071                acl_categories: 0 as libc::c_int as uint64_t,
18072                key_specs_static: [keySpec {
18073                    notes: 0 as *const libc::c_char,
18074                    flags: 0,
18075                    begin_search_type: KSPEC_BS_INVALID,
18076                    bs: C2RustUnnamed_3 {
18077                        index: C2RustUnnamed_5 { pos: 0 },
18078                    },
18079                    find_keys_type: KSPEC_FK_INVALID,
18080                    fk: C2RustUnnamed_0 {
18081                        range: C2RustUnnamed_2 {
18082                            lastkey: 0,
18083                            keystep: 0,
18084                            limit: 0,
18085                        },
18086                    },
18087                }; 4],
18088                getkeys_proc: None,
18089                subcommands: 0 as *const redisCommand as *mut redisCommand,
18090                args: PUBSUB_NUMSUB_Args.as_ptr() as *mut _,
18091                microseconds: 0,
18092                calls: 0,
18093                rejected_calls: 0,
18094                failed_calls: 0,
18095                id: 0,
18096                fullname: 0 as *const libc::c_char as *mut libc::c_char,
18097                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
18098                key_specs: 0 as *const keySpec as *mut keySpec,
18099                legacy_range_key_spec: keySpec {
18100                    notes: 0 as *const libc::c_char,
18101                    flags: 0,
18102                    begin_search_type: KSPEC_BS_INVALID,
18103                    bs: C2RustUnnamed_3 {
18104                        index: C2RustUnnamed_5 { pos: 0 },
18105                    },
18106                    find_keys_type: KSPEC_FK_INVALID,
18107                    fk: C2RustUnnamed_0 {
18108                        range: C2RustUnnamed_2 {
18109                            lastkey: 0,
18110                            keystep: 0,
18111                            limit: 0,
18112                        },
18113                    },
18114                },
18115                num_args: 0,
18116                num_history: 0,
18117                num_tips: 0,
18118                key_specs_num: 0,
18119                key_specs_max: 0,
18120                subcommands_dict: 0 as *const dict as *mut dict,
18121                parent: 0 as *const redisCommand as *mut redisCommand,
18122                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
18123            };
18124            init
18125        },
18126        {
18127            let mut init = redisCommand {
18128                declared_name: b"shardchannels\0" as *const u8 as *const libc::c_char,
18129                summary: b"List active shard channels\0" as *const u8
18130                    as *const libc::c_char,
18131                complexity: b"O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).\0"
18132                    as *const u8 as *const libc::c_char,
18133                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
18134                doc_flags: 0 as libc::c_int,
18135                replaced_by: 0 as *const libc::c_char,
18136                deprecated_since: 0 as *const libc::c_char,
18137                group: COMMAND_GROUP_PUBSUB,
18138                history: 0 as *const commandHistory as *mut commandHistory,
18139                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
18140                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
18141                arity: -(2 as libc::c_int),
18142                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
18143                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
18144                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
18145                acl_categories: 0 as libc::c_int as uint64_t,
18146                key_specs_static: [keySpec {
18147                    notes: 0 as *const libc::c_char,
18148                    flags: 0,
18149                    begin_search_type: KSPEC_BS_INVALID,
18150                    bs: C2RustUnnamed_3 {
18151                        index: C2RustUnnamed_5 { pos: 0 },
18152                    },
18153                    find_keys_type: KSPEC_FK_INVALID,
18154                    fk: C2RustUnnamed_0 {
18155                        range: C2RustUnnamed_2 {
18156                            lastkey: 0,
18157                            keystep: 0,
18158                            limit: 0,
18159                        },
18160                    },
18161                }; 4],
18162                getkeys_proc: None,
18163                subcommands: 0 as *const redisCommand as *mut redisCommand,
18164                args: PUBSUB_SHARDCHANNELS_Args.as_ptr() as *mut _,
18165                microseconds: 0,
18166                calls: 0,
18167                rejected_calls: 0,
18168                failed_calls: 0,
18169                id: 0,
18170                fullname: 0 as *const libc::c_char as *mut libc::c_char,
18171                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
18172                key_specs: 0 as *const keySpec as *mut keySpec,
18173                legacy_range_key_spec: keySpec {
18174                    notes: 0 as *const libc::c_char,
18175                    flags: 0,
18176                    begin_search_type: KSPEC_BS_INVALID,
18177                    bs: C2RustUnnamed_3 {
18178                        index: C2RustUnnamed_5 { pos: 0 },
18179                    },
18180                    find_keys_type: KSPEC_FK_INVALID,
18181                    fk: C2RustUnnamed_0 {
18182                        range: C2RustUnnamed_2 {
18183                            lastkey: 0,
18184                            keystep: 0,
18185                            limit: 0,
18186                        },
18187                    },
18188                },
18189                num_args: 0,
18190                num_history: 0,
18191                num_tips: 0,
18192                key_specs_num: 0,
18193                key_specs_max: 0,
18194                subcommands_dict: 0 as *const dict as *mut dict,
18195                parent: 0 as *const redisCommand as *mut redisCommand,
18196                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
18197            };
18198            init
18199        },
18200        {
18201            let mut init = redisCommand {
18202                declared_name: b"shardnumsub\0" as *const u8 as *const libc::c_char,
18203                summary: b"Get the count of subscribers for shard channels\0"
18204                    as *const u8 as *const libc::c_char,
18205                complexity: b"O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels\0"
18206                    as *const u8 as *const libc::c_char,
18207                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
18208                doc_flags: 0 as libc::c_int,
18209                replaced_by: 0 as *const libc::c_char,
18210                deprecated_since: 0 as *const libc::c_char,
18211                group: COMMAND_GROUP_PUBSUB,
18212                history: 0 as *const commandHistory as *mut commandHistory,
18213                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
18214                proc_0: Some(pubsubCommand as unsafe extern "C" fn(*mut client) -> ()),
18215                arity: -(2 as libc::c_int),
18216                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
18217                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
18218                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
18219                acl_categories: 0 as libc::c_int as uint64_t,
18220                key_specs_static: [keySpec {
18221                    notes: 0 as *const libc::c_char,
18222                    flags: 0,
18223                    begin_search_type: KSPEC_BS_INVALID,
18224                    bs: C2RustUnnamed_3 {
18225                        index: C2RustUnnamed_5 { pos: 0 },
18226                    },
18227                    find_keys_type: KSPEC_FK_INVALID,
18228                    fk: C2RustUnnamed_0 {
18229                        range: C2RustUnnamed_2 {
18230                            lastkey: 0,
18231                            keystep: 0,
18232                            limit: 0,
18233                        },
18234                    },
18235                }; 4],
18236                getkeys_proc: None,
18237                subcommands: 0 as *const redisCommand as *mut redisCommand,
18238                args: PUBSUB_SHARDNUMSUB_Args.as_ptr() as *mut _,
18239                microseconds: 0,
18240                calls: 0,
18241                rejected_calls: 0,
18242                failed_calls: 0,
18243                id: 0,
18244                fullname: 0 as *const libc::c_char as *mut libc::c_char,
18245                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
18246                key_specs: 0 as *const keySpec as *mut keySpec,
18247                legacy_range_key_spec: keySpec {
18248                    notes: 0 as *const libc::c_char,
18249                    flags: 0,
18250                    begin_search_type: KSPEC_BS_INVALID,
18251                    bs: C2RustUnnamed_3 {
18252                        index: C2RustUnnamed_5 { pos: 0 },
18253                    },
18254                    find_keys_type: KSPEC_FK_INVALID,
18255                    fk: C2RustUnnamed_0 {
18256                        range: C2RustUnnamed_2 {
18257                            lastkey: 0,
18258                            keystep: 0,
18259                            limit: 0,
18260                        },
18261                    },
18262                },
18263                num_args: 0,
18264                num_history: 0,
18265                num_tips: 0,
18266                key_specs_num: 0,
18267                key_specs_max: 0,
18268                subcommands_dict: 0 as *const dict as *mut dict,
18269                parent: 0 as *const redisCommand as *mut redisCommand,
18270                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
18271            };
18272            init
18273        },
18274        {
18275            let mut init = redisCommand {
18276                declared_name: 0 as *const libc::c_char,
18277                summary: 0 as *const libc::c_char,
18278                complexity: 0 as *const libc::c_char,
18279                since: 0 as *const libc::c_char,
18280                doc_flags: 0,
18281                replaced_by: 0 as *const libc::c_char,
18282                deprecated_since: 0 as *const libc::c_char,
18283                group: COMMAND_GROUP_GENERIC,
18284                history: 0 as *const commandHistory as *mut commandHistory,
18285                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
18286                proc_0: None,
18287                arity: 0,
18288                flags: 0,
18289                acl_categories: 0,
18290                key_specs_static: [keySpec {
18291                    notes: 0 as *const libc::c_char,
18292                    flags: 0,
18293                    begin_search_type: KSPEC_BS_INVALID,
18294                    bs: C2RustUnnamed_3 {
18295                        index: C2RustUnnamed_5 { pos: 0 },
18296                    },
18297                    find_keys_type: KSPEC_FK_INVALID,
18298                    fk: C2RustUnnamed_0 {
18299                        range: C2RustUnnamed_2 {
18300                            lastkey: 0,
18301                            keystep: 0,
18302                            limit: 0,
18303                        },
18304                    },
18305                }; 4],
18306                getkeys_proc: None,
18307                subcommands: 0 as *const redisCommand as *mut redisCommand,
18308                args: 0 as *const redisCommandArg as *mut redisCommandArg,
18309                microseconds: 0,
18310                calls: 0,
18311                rejected_calls: 0,
18312                failed_calls: 0,
18313                id: 0,
18314                fullname: 0 as *const libc::c_char as *mut libc::c_char,
18315                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
18316                key_specs: 0 as *const keySpec as *mut keySpec,
18317                legacy_range_key_spec: keySpec {
18318                    notes: 0 as *const libc::c_char,
18319                    flags: 0,
18320                    begin_search_type: KSPEC_BS_INVALID,
18321                    bs: C2RustUnnamed_3 {
18322                        index: C2RustUnnamed_5 { pos: 0 },
18323                    },
18324                    find_keys_type: KSPEC_FK_INVALID,
18325                    fk: C2RustUnnamed_0 {
18326                        range: C2RustUnnamed_2 {
18327                            lastkey: 0,
18328                            keystep: 0,
18329                            limit: 0,
18330                        },
18331                    },
18332                },
18333                num_args: 0,
18334                num_history: 0,
18335                num_tips: 0,
18336                key_specs_num: 0,
18337                key_specs_max: 0,
18338                subcommands_dict: 0 as *const dict as *mut dict,
18339                parent: 0 as *const redisCommand as *mut redisCommand,
18340                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
18341            };
18342            init
18343        },
18344    ]
18345};
18346#[no_mangle]
18347pub static mut PUNSUBSCRIBE_Args: [redisCommandArg; 2] = [
18348    {
18349        let mut init = redisCommandArg {
18350            name: b"pattern\0" as *const u8 as *const libc::c_char,
18351            type_0: ARG_TYPE_PATTERN,
18352            key_spec_index: -(1 as libc::c_int),
18353            token: 0 as *const libc::c_char,
18354            summary: 0 as *const libc::c_char,
18355            since: 0 as *const libc::c_char,
18356            flags: (1 as libc::c_int) << 0 as libc::c_int
18357                | (1 as libc::c_int) << 1 as libc::c_int,
18358            deprecated_since: 0 as *const libc::c_char,
18359            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18360            num_args: 0,
18361        };
18362        init
18363    },
18364    {
18365        let mut init = redisCommandArg {
18366            name: 0 as *const libc::c_char,
18367            type_0: ARG_TYPE_STRING,
18368            key_spec_index: 0,
18369            token: 0 as *const libc::c_char,
18370            summary: 0 as *const libc::c_char,
18371            since: 0 as *const libc::c_char,
18372            flags: 0,
18373            deprecated_since: 0 as *const libc::c_char,
18374            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18375            num_args: 0,
18376        };
18377        init
18378    },
18379];
18380#[no_mangle]
18381pub static mut SPUBLISH_Args: [redisCommandArg; 3] = [
18382    {
18383        let mut init = redisCommandArg {
18384            name: b"shardchannel\0" as *const u8 as *const libc::c_char,
18385            type_0: ARG_TYPE_STRING,
18386            key_spec_index: -(1 as libc::c_int),
18387            token: 0 as *const libc::c_char,
18388            summary: 0 as *const libc::c_char,
18389            since: 0 as *const libc::c_char,
18390            flags: 0 as libc::c_int,
18391            deprecated_since: 0 as *const libc::c_char,
18392            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18393            num_args: 0,
18394        };
18395        init
18396    },
18397    {
18398        let mut init = redisCommandArg {
18399            name: b"message\0" as *const u8 as *const libc::c_char,
18400            type_0: ARG_TYPE_STRING,
18401            key_spec_index: -(1 as libc::c_int),
18402            token: 0 as *const libc::c_char,
18403            summary: 0 as *const libc::c_char,
18404            since: 0 as *const libc::c_char,
18405            flags: 0 as libc::c_int,
18406            deprecated_since: 0 as *const libc::c_char,
18407            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18408            num_args: 0,
18409        };
18410        init
18411    },
18412    {
18413        let mut init = redisCommandArg {
18414            name: 0 as *const libc::c_char,
18415            type_0: ARG_TYPE_STRING,
18416            key_spec_index: 0,
18417            token: 0 as *const libc::c_char,
18418            summary: 0 as *const libc::c_char,
18419            since: 0 as *const libc::c_char,
18420            flags: 0,
18421            deprecated_since: 0 as *const libc::c_char,
18422            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18423            num_args: 0,
18424        };
18425        init
18426    },
18427];
18428#[no_mangle]
18429pub static mut SSUBSCRIBE_Args: [redisCommandArg; 2] = [
18430    {
18431        let mut init = redisCommandArg {
18432            name: b"shardchannel\0" as *const u8 as *const libc::c_char,
18433            type_0: ARG_TYPE_STRING,
18434            key_spec_index: -(1 as libc::c_int),
18435            token: 0 as *const libc::c_char,
18436            summary: 0 as *const libc::c_char,
18437            since: 0 as *const libc::c_char,
18438            flags: (1 as libc::c_int) << 1 as libc::c_int,
18439            deprecated_since: 0 as *const libc::c_char,
18440            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18441            num_args: 0,
18442        };
18443        init
18444    },
18445    {
18446        let mut init = redisCommandArg {
18447            name: 0 as *const libc::c_char,
18448            type_0: ARG_TYPE_STRING,
18449            key_spec_index: 0,
18450            token: 0 as *const libc::c_char,
18451            summary: 0 as *const libc::c_char,
18452            since: 0 as *const libc::c_char,
18453            flags: 0,
18454            deprecated_since: 0 as *const libc::c_char,
18455            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18456            num_args: 0,
18457        };
18458        init
18459    },
18460];
18461#[no_mangle]
18462pub static mut SUBSCRIBE_Args: [redisCommandArg; 2] = [
18463    {
18464        let mut init = redisCommandArg {
18465            name: b"channel\0" as *const u8 as *const libc::c_char,
18466            type_0: ARG_TYPE_STRING,
18467            key_spec_index: -(1 as libc::c_int),
18468            token: 0 as *const libc::c_char,
18469            summary: 0 as *const libc::c_char,
18470            since: 0 as *const libc::c_char,
18471            flags: (1 as libc::c_int) << 1 as libc::c_int,
18472            deprecated_since: 0 as *const libc::c_char,
18473            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18474            num_args: 0,
18475        };
18476        init
18477    },
18478    {
18479        let mut init = redisCommandArg {
18480            name: 0 as *const libc::c_char,
18481            type_0: ARG_TYPE_STRING,
18482            key_spec_index: 0,
18483            token: 0 as *const libc::c_char,
18484            summary: 0 as *const libc::c_char,
18485            since: 0 as *const libc::c_char,
18486            flags: 0,
18487            deprecated_since: 0 as *const libc::c_char,
18488            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18489            num_args: 0,
18490        };
18491        init
18492    },
18493];
18494#[no_mangle]
18495pub static mut SUNSUBSCRIBE_Args: [redisCommandArg; 2] = [
18496    {
18497        let mut init = redisCommandArg {
18498            name: b"shardchannel\0" as *const u8 as *const libc::c_char,
18499            type_0: ARG_TYPE_STRING,
18500            key_spec_index: -(1 as libc::c_int),
18501            token: 0 as *const libc::c_char,
18502            summary: 0 as *const libc::c_char,
18503            since: 0 as *const libc::c_char,
18504            flags: (1 as libc::c_int) << 0 as libc::c_int
18505                | (1 as libc::c_int) << 1 as libc::c_int,
18506            deprecated_since: 0 as *const libc::c_char,
18507            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18508            num_args: 0,
18509        };
18510        init
18511    },
18512    {
18513        let mut init = redisCommandArg {
18514            name: 0 as *const libc::c_char,
18515            type_0: ARG_TYPE_STRING,
18516            key_spec_index: 0,
18517            token: 0 as *const libc::c_char,
18518            summary: 0 as *const libc::c_char,
18519            since: 0 as *const libc::c_char,
18520            flags: 0,
18521            deprecated_since: 0 as *const libc::c_char,
18522            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18523            num_args: 0,
18524        };
18525        init
18526    },
18527];
18528#[no_mangle]
18529pub static mut UNSUBSCRIBE_Args: [redisCommandArg; 2] = [
18530    {
18531        let mut init = redisCommandArg {
18532            name: b"channel\0" as *const u8 as *const libc::c_char,
18533            type_0: ARG_TYPE_STRING,
18534            key_spec_index: -(1 as libc::c_int),
18535            token: 0 as *const libc::c_char,
18536            summary: 0 as *const libc::c_char,
18537            since: 0 as *const libc::c_char,
18538            flags: (1 as libc::c_int) << 0 as libc::c_int
18539                | (1 as libc::c_int) << 1 as libc::c_int,
18540            deprecated_since: 0 as *const libc::c_char,
18541            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18542            num_args: 0,
18543        };
18544        init
18545    },
18546    {
18547        let mut init = redisCommandArg {
18548            name: 0 as *const libc::c_char,
18549            type_0: ARG_TYPE_STRING,
18550            key_spec_index: 0,
18551            token: 0 as *const libc::c_char,
18552            summary: 0 as *const libc::c_char,
18553            since: 0 as *const libc::c_char,
18554            flags: 0,
18555            deprecated_since: 0 as *const libc::c_char,
18556            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18557            num_args: 0,
18558        };
18559        init
18560    },
18561];
18562#[no_mangle]
18563pub static mut EVAL_Args: [redisCommandArg; 5] = [
18564    {
18565        let mut init = redisCommandArg {
18566            name: b"script\0" as *const u8 as *const libc::c_char,
18567            type_0: ARG_TYPE_STRING,
18568            key_spec_index: -(1 as libc::c_int),
18569            token: 0 as *const libc::c_char,
18570            summary: 0 as *const libc::c_char,
18571            since: 0 as *const libc::c_char,
18572            flags: 0 as libc::c_int,
18573            deprecated_since: 0 as *const libc::c_char,
18574            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18575            num_args: 0,
18576        };
18577        init
18578    },
18579    {
18580        let mut init = redisCommandArg {
18581            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18582            type_0: ARG_TYPE_INTEGER,
18583            key_spec_index: -(1 as libc::c_int),
18584            token: 0 as *const libc::c_char,
18585            summary: 0 as *const libc::c_char,
18586            since: 0 as *const libc::c_char,
18587            flags: 0 as libc::c_int,
18588            deprecated_since: 0 as *const libc::c_char,
18589            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18590            num_args: 0,
18591        };
18592        init
18593    },
18594    {
18595        let mut init = redisCommandArg {
18596            name: b"key\0" as *const u8 as *const libc::c_char,
18597            type_0: ARG_TYPE_KEY,
18598            key_spec_index: 0 as libc::c_int,
18599            token: 0 as *const libc::c_char,
18600            summary: 0 as *const libc::c_char,
18601            since: 0 as *const libc::c_char,
18602            flags: (1 as libc::c_int) << 0 as libc::c_int
18603                | (1 as libc::c_int) << 1 as libc::c_int,
18604            deprecated_since: 0 as *const libc::c_char,
18605            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18606            num_args: 0,
18607        };
18608        init
18609    },
18610    {
18611        let mut init = redisCommandArg {
18612            name: b"arg\0" as *const u8 as *const libc::c_char,
18613            type_0: ARG_TYPE_STRING,
18614            key_spec_index: -(1 as libc::c_int),
18615            token: 0 as *const libc::c_char,
18616            summary: 0 as *const libc::c_char,
18617            since: 0 as *const libc::c_char,
18618            flags: (1 as libc::c_int) << 0 as libc::c_int
18619                | (1 as libc::c_int) << 1 as libc::c_int,
18620            deprecated_since: 0 as *const libc::c_char,
18621            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18622            num_args: 0,
18623        };
18624        init
18625    },
18626    {
18627        let mut init = redisCommandArg {
18628            name: 0 as *const libc::c_char,
18629            type_0: ARG_TYPE_STRING,
18630            key_spec_index: 0,
18631            token: 0 as *const libc::c_char,
18632            summary: 0 as *const libc::c_char,
18633            since: 0 as *const libc::c_char,
18634            flags: 0,
18635            deprecated_since: 0 as *const libc::c_char,
18636            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18637            num_args: 0,
18638        };
18639        init
18640    },
18641];
18642#[no_mangle]
18643pub static mut EVALSHA_Args: [redisCommandArg; 5] = [
18644    {
18645        let mut init = redisCommandArg {
18646            name: b"sha1\0" as *const u8 as *const libc::c_char,
18647            type_0: ARG_TYPE_STRING,
18648            key_spec_index: -(1 as libc::c_int),
18649            token: 0 as *const libc::c_char,
18650            summary: 0 as *const libc::c_char,
18651            since: 0 as *const libc::c_char,
18652            flags: 0 as libc::c_int,
18653            deprecated_since: 0 as *const libc::c_char,
18654            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18655            num_args: 0,
18656        };
18657        init
18658    },
18659    {
18660        let mut init = redisCommandArg {
18661            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18662            type_0: ARG_TYPE_INTEGER,
18663            key_spec_index: -(1 as libc::c_int),
18664            token: 0 as *const libc::c_char,
18665            summary: 0 as *const libc::c_char,
18666            since: 0 as *const libc::c_char,
18667            flags: 0 as libc::c_int,
18668            deprecated_since: 0 as *const libc::c_char,
18669            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18670            num_args: 0,
18671        };
18672        init
18673    },
18674    {
18675        let mut init = redisCommandArg {
18676            name: b"key\0" as *const u8 as *const libc::c_char,
18677            type_0: ARG_TYPE_KEY,
18678            key_spec_index: 0 as libc::c_int,
18679            token: 0 as *const libc::c_char,
18680            summary: 0 as *const libc::c_char,
18681            since: 0 as *const libc::c_char,
18682            flags: (1 as libc::c_int) << 0 as libc::c_int
18683                | (1 as libc::c_int) << 1 as libc::c_int,
18684            deprecated_since: 0 as *const libc::c_char,
18685            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18686            num_args: 0,
18687        };
18688        init
18689    },
18690    {
18691        let mut init = redisCommandArg {
18692            name: b"arg\0" as *const u8 as *const libc::c_char,
18693            type_0: ARG_TYPE_STRING,
18694            key_spec_index: -(1 as libc::c_int),
18695            token: 0 as *const libc::c_char,
18696            summary: 0 as *const libc::c_char,
18697            since: 0 as *const libc::c_char,
18698            flags: (1 as libc::c_int) << 0 as libc::c_int
18699                | (1 as libc::c_int) << 1 as libc::c_int,
18700            deprecated_since: 0 as *const libc::c_char,
18701            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18702            num_args: 0,
18703        };
18704        init
18705    },
18706    {
18707        let mut init = redisCommandArg {
18708            name: 0 as *const libc::c_char,
18709            type_0: ARG_TYPE_STRING,
18710            key_spec_index: 0,
18711            token: 0 as *const libc::c_char,
18712            summary: 0 as *const libc::c_char,
18713            since: 0 as *const libc::c_char,
18714            flags: 0,
18715            deprecated_since: 0 as *const libc::c_char,
18716            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18717            num_args: 0,
18718        };
18719        init
18720    },
18721];
18722#[no_mangle]
18723pub static mut EVALSHA_RO_Args: [redisCommandArg; 5] = [
18724    {
18725        let mut init = redisCommandArg {
18726            name: b"sha1\0" as *const u8 as *const libc::c_char,
18727            type_0: ARG_TYPE_STRING,
18728            key_spec_index: -(1 as libc::c_int),
18729            token: 0 as *const libc::c_char,
18730            summary: 0 as *const libc::c_char,
18731            since: 0 as *const libc::c_char,
18732            flags: 0 as libc::c_int,
18733            deprecated_since: 0 as *const libc::c_char,
18734            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18735            num_args: 0,
18736        };
18737        init
18738    },
18739    {
18740        let mut init = redisCommandArg {
18741            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18742            type_0: ARG_TYPE_INTEGER,
18743            key_spec_index: -(1 as libc::c_int),
18744            token: 0 as *const libc::c_char,
18745            summary: 0 as *const libc::c_char,
18746            since: 0 as *const libc::c_char,
18747            flags: 0 as libc::c_int,
18748            deprecated_since: 0 as *const libc::c_char,
18749            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18750            num_args: 0,
18751        };
18752        init
18753    },
18754    {
18755        let mut init = redisCommandArg {
18756            name: b"key\0" as *const u8 as *const libc::c_char,
18757            type_0: ARG_TYPE_KEY,
18758            key_spec_index: 0 as libc::c_int,
18759            token: 0 as *const libc::c_char,
18760            summary: 0 as *const libc::c_char,
18761            since: 0 as *const libc::c_char,
18762            flags: (1 as libc::c_int) << 0 as libc::c_int
18763                | (1 as libc::c_int) << 1 as libc::c_int,
18764            deprecated_since: 0 as *const libc::c_char,
18765            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18766            num_args: 0,
18767        };
18768        init
18769    },
18770    {
18771        let mut init = redisCommandArg {
18772            name: b"arg\0" as *const u8 as *const libc::c_char,
18773            type_0: ARG_TYPE_STRING,
18774            key_spec_index: -(1 as libc::c_int),
18775            token: 0 as *const libc::c_char,
18776            summary: 0 as *const libc::c_char,
18777            since: 0 as *const libc::c_char,
18778            flags: (1 as libc::c_int) << 0 as libc::c_int
18779                | (1 as libc::c_int) << 1 as libc::c_int,
18780            deprecated_since: 0 as *const libc::c_char,
18781            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18782            num_args: 0,
18783        };
18784        init
18785    },
18786    {
18787        let mut init = redisCommandArg {
18788            name: 0 as *const libc::c_char,
18789            type_0: ARG_TYPE_STRING,
18790            key_spec_index: 0,
18791            token: 0 as *const libc::c_char,
18792            summary: 0 as *const libc::c_char,
18793            since: 0 as *const libc::c_char,
18794            flags: 0,
18795            deprecated_since: 0 as *const libc::c_char,
18796            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18797            num_args: 0,
18798        };
18799        init
18800    },
18801];
18802#[no_mangle]
18803pub static mut EVAL_RO_Args: [redisCommandArg; 5] = [
18804    {
18805        let mut init = redisCommandArg {
18806            name: b"script\0" as *const u8 as *const libc::c_char,
18807            type_0: ARG_TYPE_STRING,
18808            key_spec_index: -(1 as libc::c_int),
18809            token: 0 as *const libc::c_char,
18810            summary: 0 as *const libc::c_char,
18811            since: 0 as *const libc::c_char,
18812            flags: 0 as libc::c_int,
18813            deprecated_since: 0 as *const libc::c_char,
18814            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18815            num_args: 0,
18816        };
18817        init
18818    },
18819    {
18820        let mut init = redisCommandArg {
18821            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18822            type_0: ARG_TYPE_INTEGER,
18823            key_spec_index: -(1 as libc::c_int),
18824            token: 0 as *const libc::c_char,
18825            summary: 0 as *const libc::c_char,
18826            since: 0 as *const libc::c_char,
18827            flags: 0 as libc::c_int,
18828            deprecated_since: 0 as *const libc::c_char,
18829            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18830            num_args: 0,
18831        };
18832        init
18833    },
18834    {
18835        let mut init = redisCommandArg {
18836            name: b"key\0" as *const u8 as *const libc::c_char,
18837            type_0: ARG_TYPE_KEY,
18838            key_spec_index: 0 as libc::c_int,
18839            token: 0 as *const libc::c_char,
18840            summary: 0 as *const libc::c_char,
18841            since: 0 as *const libc::c_char,
18842            flags: (1 as libc::c_int) << 0 as libc::c_int
18843                | (1 as libc::c_int) << 1 as libc::c_int,
18844            deprecated_since: 0 as *const libc::c_char,
18845            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18846            num_args: 0,
18847        };
18848        init
18849    },
18850    {
18851        let mut init = redisCommandArg {
18852            name: b"arg\0" as *const u8 as *const libc::c_char,
18853            type_0: ARG_TYPE_STRING,
18854            key_spec_index: -(1 as libc::c_int),
18855            token: 0 as *const libc::c_char,
18856            summary: 0 as *const libc::c_char,
18857            since: 0 as *const libc::c_char,
18858            flags: (1 as libc::c_int) << 0 as libc::c_int
18859                | (1 as libc::c_int) << 1 as libc::c_int,
18860            deprecated_since: 0 as *const libc::c_char,
18861            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18862            num_args: 0,
18863        };
18864        init
18865    },
18866    {
18867        let mut init = redisCommandArg {
18868            name: 0 as *const libc::c_char,
18869            type_0: ARG_TYPE_STRING,
18870            key_spec_index: 0,
18871            token: 0 as *const libc::c_char,
18872            summary: 0 as *const libc::c_char,
18873            since: 0 as *const libc::c_char,
18874            flags: 0,
18875            deprecated_since: 0 as *const libc::c_char,
18876            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18877            num_args: 0,
18878        };
18879        init
18880    },
18881];
18882#[no_mangle]
18883pub static mut FCALL_Args: [redisCommandArg; 5] = [
18884    {
18885        let mut init = redisCommandArg {
18886            name: b"function\0" as *const u8 as *const libc::c_char,
18887            type_0: ARG_TYPE_STRING,
18888            key_spec_index: -(1 as libc::c_int),
18889            token: 0 as *const libc::c_char,
18890            summary: 0 as *const libc::c_char,
18891            since: 0 as *const libc::c_char,
18892            flags: 0 as libc::c_int,
18893            deprecated_since: 0 as *const libc::c_char,
18894            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18895            num_args: 0,
18896        };
18897        init
18898    },
18899    {
18900        let mut init = redisCommandArg {
18901            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18902            type_0: ARG_TYPE_INTEGER,
18903            key_spec_index: -(1 as libc::c_int),
18904            token: 0 as *const libc::c_char,
18905            summary: 0 as *const libc::c_char,
18906            since: 0 as *const libc::c_char,
18907            flags: 0 as libc::c_int,
18908            deprecated_since: 0 as *const libc::c_char,
18909            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18910            num_args: 0,
18911        };
18912        init
18913    },
18914    {
18915        let mut init = redisCommandArg {
18916            name: b"key\0" as *const u8 as *const libc::c_char,
18917            type_0: ARG_TYPE_KEY,
18918            key_spec_index: 0 as libc::c_int,
18919            token: 0 as *const libc::c_char,
18920            summary: 0 as *const libc::c_char,
18921            since: 0 as *const libc::c_char,
18922            flags: (1 as libc::c_int) << 0 as libc::c_int
18923                | (1 as libc::c_int) << 1 as libc::c_int,
18924            deprecated_since: 0 as *const libc::c_char,
18925            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18926            num_args: 0,
18927        };
18928        init
18929    },
18930    {
18931        let mut init = redisCommandArg {
18932            name: b"arg\0" as *const u8 as *const libc::c_char,
18933            type_0: ARG_TYPE_STRING,
18934            key_spec_index: -(1 as libc::c_int),
18935            token: 0 as *const libc::c_char,
18936            summary: 0 as *const libc::c_char,
18937            since: 0 as *const libc::c_char,
18938            flags: (1 as libc::c_int) << 0 as libc::c_int
18939                | (1 as libc::c_int) << 1 as libc::c_int,
18940            deprecated_since: 0 as *const libc::c_char,
18941            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18942            num_args: 0,
18943        };
18944        init
18945    },
18946    {
18947        let mut init = redisCommandArg {
18948            name: 0 as *const libc::c_char,
18949            type_0: ARG_TYPE_STRING,
18950            key_spec_index: 0,
18951            token: 0 as *const libc::c_char,
18952            summary: 0 as *const libc::c_char,
18953            since: 0 as *const libc::c_char,
18954            flags: 0,
18955            deprecated_since: 0 as *const libc::c_char,
18956            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18957            num_args: 0,
18958        };
18959        init
18960    },
18961];
18962#[no_mangle]
18963pub static mut FCALL_RO_Args: [redisCommandArg; 5] = [
18964    {
18965        let mut init = redisCommandArg {
18966            name: b"function\0" as *const u8 as *const libc::c_char,
18967            type_0: ARG_TYPE_STRING,
18968            key_spec_index: -(1 as libc::c_int),
18969            token: 0 as *const libc::c_char,
18970            summary: 0 as *const libc::c_char,
18971            since: 0 as *const libc::c_char,
18972            flags: 0 as libc::c_int,
18973            deprecated_since: 0 as *const libc::c_char,
18974            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18975            num_args: 0,
18976        };
18977        init
18978    },
18979    {
18980        let mut init = redisCommandArg {
18981            name: b"numkeys\0" as *const u8 as *const libc::c_char,
18982            type_0: ARG_TYPE_INTEGER,
18983            key_spec_index: -(1 as libc::c_int),
18984            token: 0 as *const libc::c_char,
18985            summary: 0 as *const libc::c_char,
18986            since: 0 as *const libc::c_char,
18987            flags: 0 as libc::c_int,
18988            deprecated_since: 0 as *const libc::c_char,
18989            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
18990            num_args: 0,
18991        };
18992        init
18993    },
18994    {
18995        let mut init = redisCommandArg {
18996            name: b"key\0" as *const u8 as *const libc::c_char,
18997            type_0: ARG_TYPE_KEY,
18998            key_spec_index: 0 as libc::c_int,
18999            token: 0 as *const libc::c_char,
19000            summary: 0 as *const libc::c_char,
19001            since: 0 as *const libc::c_char,
19002            flags: (1 as libc::c_int) << 0 as libc::c_int
19003                | (1 as libc::c_int) << 1 as libc::c_int,
19004            deprecated_since: 0 as *const libc::c_char,
19005            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19006            num_args: 0,
19007        };
19008        init
19009    },
19010    {
19011        let mut init = redisCommandArg {
19012            name: b"arg\0" as *const u8 as *const libc::c_char,
19013            type_0: ARG_TYPE_STRING,
19014            key_spec_index: -(1 as libc::c_int),
19015            token: 0 as *const libc::c_char,
19016            summary: 0 as *const libc::c_char,
19017            since: 0 as *const libc::c_char,
19018            flags: (1 as libc::c_int) << 0 as libc::c_int
19019                | (1 as libc::c_int) << 1 as libc::c_int,
19020            deprecated_since: 0 as *const libc::c_char,
19021            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19022            num_args: 0,
19023        };
19024        init
19025    },
19026    {
19027        let mut init = redisCommandArg {
19028            name: 0 as *const libc::c_char,
19029            type_0: ARG_TYPE_STRING,
19030            key_spec_index: 0,
19031            token: 0 as *const libc::c_char,
19032            summary: 0 as *const libc::c_char,
19033            since: 0 as *const libc::c_char,
19034            flags: 0,
19035            deprecated_since: 0 as *const libc::c_char,
19036            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19037            num_args: 0,
19038        };
19039        init
19040    },
19041];
19042#[no_mangle]
19043pub static mut FUNCTION_DELETE_tips: [*const libc::c_char; 3] = [
19044    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19045    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
19046    0 as *const libc::c_char,
19047];
19048#[no_mangle]
19049pub static mut FUNCTION_DELETE_Args: [redisCommandArg; 2] = [
19050    {
19051        let mut init = redisCommandArg {
19052            name: b"library-name\0" as *const u8 as *const libc::c_char,
19053            type_0: ARG_TYPE_STRING,
19054            key_spec_index: -(1 as libc::c_int),
19055            token: 0 as *const libc::c_char,
19056            summary: 0 as *const libc::c_char,
19057            since: 0 as *const libc::c_char,
19058            flags: 0 as libc::c_int,
19059            deprecated_since: 0 as *const libc::c_char,
19060            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19061            num_args: 0,
19062        };
19063        init
19064    },
19065    {
19066        let mut init = redisCommandArg {
19067            name: 0 as *const libc::c_char,
19068            type_0: ARG_TYPE_STRING,
19069            key_spec_index: 0,
19070            token: 0 as *const libc::c_char,
19071            summary: 0 as *const libc::c_char,
19072            since: 0 as *const libc::c_char,
19073            flags: 0,
19074            deprecated_since: 0 as *const libc::c_char,
19075            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19076            num_args: 0,
19077        };
19078        init
19079    },
19080];
19081#[no_mangle]
19082pub static mut FUNCTION_FLUSH_tips: [*const libc::c_char; 3] = [
19083    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19084    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
19085    0 as *const libc::c_char,
19086];
19087#[no_mangle]
19088pub static mut FUNCTION_FLUSH_async_Subargs: [redisCommandArg; 3] = [
19089    {
19090        let mut init = redisCommandArg {
19091            name: b"async\0" as *const u8 as *const libc::c_char,
19092            type_0: ARG_TYPE_PURE_TOKEN,
19093            key_spec_index: -(1 as libc::c_int),
19094            token: b"ASYNC\0" as *const u8 as *const libc::c_char,
19095            summary: 0 as *const libc::c_char,
19096            since: 0 as *const libc::c_char,
19097            flags: 0 as libc::c_int,
19098            deprecated_since: 0 as *const libc::c_char,
19099            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19100            num_args: 0,
19101        };
19102        init
19103    },
19104    {
19105        let mut init = redisCommandArg {
19106            name: b"sync\0" as *const u8 as *const libc::c_char,
19107            type_0: ARG_TYPE_PURE_TOKEN,
19108            key_spec_index: -(1 as libc::c_int),
19109            token: b"SYNC\0" as *const u8 as *const libc::c_char,
19110            summary: 0 as *const libc::c_char,
19111            since: 0 as *const libc::c_char,
19112            flags: 0 as libc::c_int,
19113            deprecated_since: 0 as *const libc::c_char,
19114            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19115            num_args: 0,
19116        };
19117        init
19118    },
19119    {
19120        let mut init = redisCommandArg {
19121            name: 0 as *const libc::c_char,
19122            type_0: ARG_TYPE_STRING,
19123            key_spec_index: 0,
19124            token: 0 as *const libc::c_char,
19125            summary: 0 as *const libc::c_char,
19126            since: 0 as *const libc::c_char,
19127            flags: 0,
19128            deprecated_since: 0 as *const libc::c_char,
19129            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19130            num_args: 0,
19131        };
19132        init
19133    },
19134];
19135#[no_mangle]
19136pub static mut FUNCTION_FLUSH_Args: [redisCommandArg; 2] = unsafe {
19137    [
19138        {
19139            let mut init = redisCommandArg {
19140                name: b"async\0" as *const u8 as *const libc::c_char,
19141                type_0: ARG_TYPE_ONEOF,
19142                key_spec_index: -(1 as libc::c_int),
19143                token: 0 as *const libc::c_char,
19144                summary: 0 as *const libc::c_char,
19145                since: 0 as *const libc::c_char,
19146                flags: (1 as libc::c_int) << 0 as libc::c_int,
19147                deprecated_since: 0 as *const libc::c_char,
19148                subargs: FUNCTION_FLUSH_async_Subargs.as_ptr() as *mut _,
19149                num_args: 0,
19150            };
19151            init
19152        },
19153        {
19154            let mut init = redisCommandArg {
19155                name: 0 as *const libc::c_char,
19156                type_0: ARG_TYPE_STRING,
19157                key_spec_index: 0,
19158                token: 0 as *const libc::c_char,
19159                summary: 0 as *const libc::c_char,
19160                since: 0 as *const libc::c_char,
19161                flags: 0,
19162                deprecated_since: 0 as *const libc::c_char,
19163                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19164                num_args: 0,
19165            };
19166            init
19167        },
19168    ]
19169};
19170#[no_mangle]
19171pub static mut FUNCTION_KILL_tips: [*const libc::c_char; 3] = [
19172    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19173    b"response_policy:one_succeeded\0" as *const u8 as *const libc::c_char,
19174    0 as *const libc::c_char,
19175];
19176#[no_mangle]
19177pub static mut FUNCTION_LIST_tips: [*const libc::c_char; 2] = [
19178    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
19179    0 as *const libc::c_char,
19180];
19181#[no_mangle]
19182pub static mut FUNCTION_LIST_Args: [redisCommandArg; 3] = [
19183    {
19184        let mut init = redisCommandArg {
19185            name: b"library-name-pattern\0" as *const u8 as *const libc::c_char,
19186            type_0: ARG_TYPE_STRING,
19187            key_spec_index: -(1 as libc::c_int),
19188            token: b"LIBRARYNAME\0" as *const u8 as *const libc::c_char,
19189            summary: 0 as *const libc::c_char,
19190            since: 0 as *const libc::c_char,
19191            flags: (1 as libc::c_int) << 0 as libc::c_int,
19192            deprecated_since: 0 as *const libc::c_char,
19193            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19194            num_args: 0,
19195        };
19196        init
19197    },
19198    {
19199        let mut init = redisCommandArg {
19200            name: b"withcode\0" as *const u8 as *const libc::c_char,
19201            type_0: ARG_TYPE_PURE_TOKEN,
19202            key_spec_index: -(1 as libc::c_int),
19203            token: b"WITHCODE\0" as *const u8 as *const libc::c_char,
19204            summary: 0 as *const libc::c_char,
19205            since: 0 as *const libc::c_char,
19206            flags: (1 as libc::c_int) << 0 as libc::c_int,
19207            deprecated_since: 0 as *const libc::c_char,
19208            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19209            num_args: 0,
19210        };
19211        init
19212    },
19213    {
19214        let mut init = redisCommandArg {
19215            name: 0 as *const libc::c_char,
19216            type_0: ARG_TYPE_STRING,
19217            key_spec_index: 0,
19218            token: 0 as *const libc::c_char,
19219            summary: 0 as *const libc::c_char,
19220            since: 0 as *const libc::c_char,
19221            flags: 0,
19222            deprecated_since: 0 as *const libc::c_char,
19223            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19224            num_args: 0,
19225        };
19226        init
19227    },
19228];
19229#[no_mangle]
19230pub static mut FUNCTION_LOAD_tips: [*const libc::c_char; 3] = [
19231    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19232    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
19233    0 as *const libc::c_char,
19234];
19235#[no_mangle]
19236pub static mut FUNCTION_LOAD_Args: [redisCommandArg; 3] = [
19237    {
19238        let mut init = redisCommandArg {
19239            name: b"replace\0" as *const u8 as *const libc::c_char,
19240            type_0: ARG_TYPE_PURE_TOKEN,
19241            key_spec_index: -(1 as libc::c_int),
19242            token: b"REPLACE\0" as *const u8 as *const libc::c_char,
19243            summary: 0 as *const libc::c_char,
19244            since: 0 as *const libc::c_char,
19245            flags: (1 as libc::c_int) << 0 as libc::c_int,
19246            deprecated_since: 0 as *const libc::c_char,
19247            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19248            num_args: 0,
19249        };
19250        init
19251    },
19252    {
19253        let mut init = redisCommandArg {
19254            name: b"function-code\0" as *const u8 as *const libc::c_char,
19255            type_0: ARG_TYPE_STRING,
19256            key_spec_index: -(1 as libc::c_int),
19257            token: 0 as *const libc::c_char,
19258            summary: 0 as *const libc::c_char,
19259            since: 0 as *const libc::c_char,
19260            flags: 0 as libc::c_int,
19261            deprecated_since: 0 as *const libc::c_char,
19262            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19263            num_args: 0,
19264        };
19265        init
19266    },
19267    {
19268        let mut init = redisCommandArg {
19269            name: 0 as *const libc::c_char,
19270            type_0: ARG_TYPE_STRING,
19271            key_spec_index: 0,
19272            token: 0 as *const libc::c_char,
19273            summary: 0 as *const libc::c_char,
19274            since: 0 as *const libc::c_char,
19275            flags: 0,
19276            deprecated_since: 0 as *const libc::c_char,
19277            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19278            num_args: 0,
19279        };
19280        init
19281    },
19282];
19283#[no_mangle]
19284pub static mut FUNCTION_RESTORE_tips: [*const libc::c_char; 3] = [
19285    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19286    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
19287    0 as *const libc::c_char,
19288];
19289#[no_mangle]
19290pub static mut FUNCTION_RESTORE_policy_Subargs: [redisCommandArg; 4] = [
19291    {
19292        let mut init = redisCommandArg {
19293            name: b"flush\0" as *const u8 as *const libc::c_char,
19294            type_0: ARG_TYPE_PURE_TOKEN,
19295            key_spec_index: -(1 as libc::c_int),
19296            token: b"FLUSH\0" as *const u8 as *const libc::c_char,
19297            summary: 0 as *const libc::c_char,
19298            since: 0 as *const libc::c_char,
19299            flags: 0 as libc::c_int,
19300            deprecated_since: 0 as *const libc::c_char,
19301            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19302            num_args: 0,
19303        };
19304        init
19305    },
19306    {
19307        let mut init = redisCommandArg {
19308            name: b"append\0" as *const u8 as *const libc::c_char,
19309            type_0: ARG_TYPE_PURE_TOKEN,
19310            key_spec_index: -(1 as libc::c_int),
19311            token: b"APPEND\0" as *const u8 as *const libc::c_char,
19312            summary: 0 as *const libc::c_char,
19313            since: 0 as *const libc::c_char,
19314            flags: 0 as libc::c_int,
19315            deprecated_since: 0 as *const libc::c_char,
19316            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19317            num_args: 0,
19318        };
19319        init
19320    },
19321    {
19322        let mut init = redisCommandArg {
19323            name: b"replace\0" as *const u8 as *const libc::c_char,
19324            type_0: ARG_TYPE_PURE_TOKEN,
19325            key_spec_index: -(1 as libc::c_int),
19326            token: b"REPLACE\0" as *const u8 as *const libc::c_char,
19327            summary: 0 as *const libc::c_char,
19328            since: 0 as *const libc::c_char,
19329            flags: 0 as libc::c_int,
19330            deprecated_since: 0 as *const libc::c_char,
19331            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19332            num_args: 0,
19333        };
19334        init
19335    },
19336    {
19337        let mut init = redisCommandArg {
19338            name: 0 as *const libc::c_char,
19339            type_0: ARG_TYPE_STRING,
19340            key_spec_index: 0,
19341            token: 0 as *const libc::c_char,
19342            summary: 0 as *const libc::c_char,
19343            since: 0 as *const libc::c_char,
19344            flags: 0,
19345            deprecated_since: 0 as *const libc::c_char,
19346            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19347            num_args: 0,
19348        };
19349        init
19350    },
19351];
19352#[no_mangle]
19353pub static mut FUNCTION_RESTORE_Args: [redisCommandArg; 3] = unsafe {
19354    [
19355        {
19356            let mut init = redisCommandArg {
19357                name: b"serialized-value\0" as *const u8 as *const libc::c_char,
19358                type_0: ARG_TYPE_STRING,
19359                key_spec_index: -(1 as libc::c_int),
19360                token: 0 as *const libc::c_char,
19361                summary: 0 as *const libc::c_char,
19362                since: 0 as *const libc::c_char,
19363                flags: 0 as libc::c_int,
19364                deprecated_since: 0 as *const libc::c_char,
19365                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19366                num_args: 0,
19367            };
19368            init
19369        },
19370        {
19371            let mut init = redisCommandArg {
19372                name: b"policy\0" as *const u8 as *const libc::c_char,
19373                type_0: ARG_TYPE_ONEOF,
19374                key_spec_index: -(1 as libc::c_int),
19375                token: 0 as *const libc::c_char,
19376                summary: 0 as *const libc::c_char,
19377                since: 0 as *const libc::c_char,
19378                flags: (1 as libc::c_int) << 0 as libc::c_int,
19379                deprecated_since: 0 as *const libc::c_char,
19380                subargs: FUNCTION_RESTORE_policy_Subargs.as_ptr() as *mut _,
19381                num_args: 0,
19382            };
19383            init
19384        },
19385        {
19386            let mut init = redisCommandArg {
19387                name: 0 as *const libc::c_char,
19388                type_0: ARG_TYPE_STRING,
19389                key_spec_index: 0,
19390                token: 0 as *const libc::c_char,
19391                summary: 0 as *const libc::c_char,
19392                since: 0 as *const libc::c_char,
19393                flags: 0,
19394                deprecated_since: 0 as *const libc::c_char,
19395                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
19396                num_args: 0,
19397            };
19398            init
19399        },
19400    ]
19401};
19402#[no_mangle]
19403pub static mut FUNCTION_STATS_tips: [*const libc::c_char; 4] = [
19404    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
19405    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
19406    b"response_policy:special\0" as *const u8 as *const libc::c_char,
19407    0 as *const libc::c_char,
19408];
19409#[no_mangle]
19410pub static mut FUNCTION_Subcommands: [redisCommand; 10] = unsafe {
19411    [
19412        {
19413            let mut init = redisCommand {
19414                declared_name: b"delete\0" as *const u8 as *const libc::c_char,
19415                summary: b"Delete a function by name\0" as *const u8
19416                    as *const libc::c_char,
19417                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
19418                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19419                doc_flags: 0 as libc::c_int,
19420                replaced_by: 0 as *const libc::c_char,
19421                deprecated_since: 0 as *const libc::c_char,
19422                group: COMMAND_GROUP_SCRIPTING,
19423                history: 0 as *const commandHistory as *mut commandHistory,
19424                tips: FUNCTION_DELETE_tips.as_ptr() as *mut _,
19425                proc_0: Some(
19426                    functionDeleteCommand as unsafe extern "C" fn(*mut client) -> (),
19427                ),
19428                arity: 3 as libc::c_int,
19429                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
19430                    | (1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
19431                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19432                    as uint64_t,
19433                key_specs_static: [keySpec {
19434                    notes: 0 as *const libc::c_char,
19435                    flags: 0,
19436                    begin_search_type: KSPEC_BS_INVALID,
19437                    bs: C2RustUnnamed_3 {
19438                        index: C2RustUnnamed_5 { pos: 0 },
19439                    },
19440                    find_keys_type: KSPEC_FK_INVALID,
19441                    fk: C2RustUnnamed_0 {
19442                        range: C2RustUnnamed_2 {
19443                            lastkey: 0,
19444                            keystep: 0,
19445                            limit: 0,
19446                        },
19447                    },
19448                }; 4],
19449                getkeys_proc: None,
19450                subcommands: 0 as *const redisCommand as *mut redisCommand,
19451                args: FUNCTION_DELETE_Args.as_ptr() as *mut _,
19452                microseconds: 0,
19453                calls: 0,
19454                rejected_calls: 0,
19455                failed_calls: 0,
19456                id: 0,
19457                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19458                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19459                key_specs: 0 as *const keySpec as *mut keySpec,
19460                legacy_range_key_spec: keySpec {
19461                    notes: 0 as *const libc::c_char,
19462                    flags: 0,
19463                    begin_search_type: KSPEC_BS_INVALID,
19464                    bs: C2RustUnnamed_3 {
19465                        index: C2RustUnnamed_5 { pos: 0 },
19466                    },
19467                    find_keys_type: KSPEC_FK_INVALID,
19468                    fk: C2RustUnnamed_0 {
19469                        range: C2RustUnnamed_2 {
19470                            lastkey: 0,
19471                            keystep: 0,
19472                            limit: 0,
19473                        },
19474                    },
19475                },
19476                num_args: 0,
19477                num_history: 0,
19478                num_tips: 0,
19479                key_specs_num: 0,
19480                key_specs_max: 0,
19481                subcommands_dict: 0 as *const dict as *mut dict,
19482                parent: 0 as *const redisCommand as *mut redisCommand,
19483                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19484            };
19485            init
19486        },
19487        {
19488            let mut init = redisCommand {
19489                declared_name: b"dump\0" as *const u8 as *const libc::c_char,
19490                summary: b"Dump all functions into a serialized binary payload\0"
19491                    as *const u8 as *const libc::c_char,
19492                complexity: b"O(N) where N is the number of functions\0" as *const u8
19493                    as *const libc::c_char,
19494                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19495                doc_flags: 0 as libc::c_int,
19496                replaced_by: 0 as *const libc::c_char,
19497                deprecated_since: 0 as *const libc::c_char,
19498                group: COMMAND_GROUP_SCRIPTING,
19499                history: 0 as *const commandHistory as *mut commandHistory,
19500                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
19501                proc_0: Some(
19502                    functionDumpCommand as unsafe extern "C" fn(*mut client) -> (),
19503                ),
19504                arity: 2 as libc::c_int,
19505                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
19506                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19507                    as uint64_t,
19508                key_specs_static: [keySpec {
19509                    notes: 0 as *const libc::c_char,
19510                    flags: 0,
19511                    begin_search_type: KSPEC_BS_INVALID,
19512                    bs: C2RustUnnamed_3 {
19513                        index: C2RustUnnamed_5 { pos: 0 },
19514                    },
19515                    find_keys_type: KSPEC_FK_INVALID,
19516                    fk: C2RustUnnamed_0 {
19517                        range: C2RustUnnamed_2 {
19518                            lastkey: 0,
19519                            keystep: 0,
19520                            limit: 0,
19521                        },
19522                    },
19523                }; 4],
19524                getkeys_proc: None,
19525                subcommands: 0 as *const redisCommand as *mut redisCommand,
19526                args: 0 as *const redisCommandArg as *mut redisCommandArg,
19527                microseconds: 0,
19528                calls: 0,
19529                rejected_calls: 0,
19530                failed_calls: 0,
19531                id: 0,
19532                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19533                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19534                key_specs: 0 as *const keySpec as *mut keySpec,
19535                legacy_range_key_spec: keySpec {
19536                    notes: 0 as *const libc::c_char,
19537                    flags: 0,
19538                    begin_search_type: KSPEC_BS_INVALID,
19539                    bs: C2RustUnnamed_3 {
19540                        index: C2RustUnnamed_5 { pos: 0 },
19541                    },
19542                    find_keys_type: KSPEC_FK_INVALID,
19543                    fk: C2RustUnnamed_0 {
19544                        range: C2RustUnnamed_2 {
19545                            lastkey: 0,
19546                            keystep: 0,
19547                            limit: 0,
19548                        },
19549                    },
19550                },
19551                num_args: 0,
19552                num_history: 0,
19553                num_tips: 0,
19554                key_specs_num: 0,
19555                key_specs_max: 0,
19556                subcommands_dict: 0 as *const dict as *mut dict,
19557                parent: 0 as *const redisCommand as *mut redisCommand,
19558                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19559            };
19560            init
19561        },
19562        {
19563            let mut init = redisCommand {
19564                declared_name: b"flush\0" as *const u8 as *const libc::c_char,
19565                summary: b"Deleting all functions\0" as *const u8 as *const libc::c_char,
19566                complexity: b"O(N) where N is the number of functions deleted\0"
19567                    as *const u8 as *const libc::c_char,
19568                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19569                doc_flags: 0 as libc::c_int,
19570                replaced_by: 0 as *const libc::c_char,
19571                deprecated_since: 0 as *const libc::c_char,
19572                group: COMMAND_GROUP_SCRIPTING,
19573                history: 0 as *const commandHistory as *mut commandHistory,
19574                tips: FUNCTION_FLUSH_tips.as_ptr() as *mut _,
19575                proc_0: Some(
19576                    functionFlushCommand as unsafe extern "C" fn(*mut client) -> (),
19577                ),
19578                arity: -(2 as libc::c_int),
19579                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
19580                    | (1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
19581                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19582                    as uint64_t,
19583                key_specs_static: [keySpec {
19584                    notes: 0 as *const libc::c_char,
19585                    flags: 0,
19586                    begin_search_type: KSPEC_BS_INVALID,
19587                    bs: C2RustUnnamed_3 {
19588                        index: C2RustUnnamed_5 { pos: 0 },
19589                    },
19590                    find_keys_type: KSPEC_FK_INVALID,
19591                    fk: C2RustUnnamed_0 {
19592                        range: C2RustUnnamed_2 {
19593                            lastkey: 0,
19594                            keystep: 0,
19595                            limit: 0,
19596                        },
19597                    },
19598                }; 4],
19599                getkeys_proc: None,
19600                subcommands: 0 as *const redisCommand as *mut redisCommand,
19601                args: FUNCTION_FLUSH_Args.as_ptr() as *mut _,
19602                microseconds: 0,
19603                calls: 0,
19604                rejected_calls: 0,
19605                failed_calls: 0,
19606                id: 0,
19607                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19608                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19609                key_specs: 0 as *const keySpec as *mut keySpec,
19610                legacy_range_key_spec: keySpec {
19611                    notes: 0 as *const libc::c_char,
19612                    flags: 0,
19613                    begin_search_type: KSPEC_BS_INVALID,
19614                    bs: C2RustUnnamed_3 {
19615                        index: C2RustUnnamed_5 { pos: 0 },
19616                    },
19617                    find_keys_type: KSPEC_FK_INVALID,
19618                    fk: C2RustUnnamed_0 {
19619                        range: C2RustUnnamed_2 {
19620                            lastkey: 0,
19621                            keystep: 0,
19622                            limit: 0,
19623                        },
19624                    },
19625                },
19626                num_args: 0,
19627                num_history: 0,
19628                num_tips: 0,
19629                key_specs_num: 0,
19630                key_specs_max: 0,
19631                subcommands_dict: 0 as *const dict as *mut dict,
19632                parent: 0 as *const redisCommand as *mut redisCommand,
19633                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19634            };
19635            init
19636        },
19637        {
19638            let mut init = redisCommand {
19639                declared_name: b"help\0" as *const u8 as *const libc::c_char,
19640                summary: b"Show helpful text about the different subcommands\0"
19641                    as *const u8 as *const libc::c_char,
19642                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
19643                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19644                doc_flags: 0 as libc::c_int,
19645                replaced_by: 0 as *const libc::c_char,
19646                deprecated_since: 0 as *const libc::c_char,
19647                group: COMMAND_GROUP_SCRIPTING,
19648                history: 0 as *const commandHistory as *mut commandHistory,
19649                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
19650                proc_0: Some(
19651                    functionHelpCommand as unsafe extern "C" fn(*mut client) -> (),
19652                ),
19653                arity: 2 as libc::c_int,
19654                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
19655                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
19656                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19657                    as uint64_t,
19658                key_specs_static: [keySpec {
19659                    notes: 0 as *const libc::c_char,
19660                    flags: 0,
19661                    begin_search_type: KSPEC_BS_INVALID,
19662                    bs: C2RustUnnamed_3 {
19663                        index: C2RustUnnamed_5 { pos: 0 },
19664                    },
19665                    find_keys_type: KSPEC_FK_INVALID,
19666                    fk: C2RustUnnamed_0 {
19667                        range: C2RustUnnamed_2 {
19668                            lastkey: 0,
19669                            keystep: 0,
19670                            limit: 0,
19671                        },
19672                    },
19673                }; 4],
19674                getkeys_proc: None,
19675                subcommands: 0 as *const redisCommand as *mut redisCommand,
19676                args: 0 as *const redisCommandArg as *mut redisCommandArg,
19677                microseconds: 0,
19678                calls: 0,
19679                rejected_calls: 0,
19680                failed_calls: 0,
19681                id: 0,
19682                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19683                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19684                key_specs: 0 as *const keySpec as *mut keySpec,
19685                legacy_range_key_spec: keySpec {
19686                    notes: 0 as *const libc::c_char,
19687                    flags: 0,
19688                    begin_search_type: KSPEC_BS_INVALID,
19689                    bs: C2RustUnnamed_3 {
19690                        index: C2RustUnnamed_5 { pos: 0 },
19691                    },
19692                    find_keys_type: KSPEC_FK_INVALID,
19693                    fk: C2RustUnnamed_0 {
19694                        range: C2RustUnnamed_2 {
19695                            lastkey: 0,
19696                            keystep: 0,
19697                            limit: 0,
19698                        },
19699                    },
19700                },
19701                num_args: 0,
19702                num_history: 0,
19703                num_tips: 0,
19704                key_specs_num: 0,
19705                key_specs_max: 0,
19706                subcommands_dict: 0 as *const dict as *mut dict,
19707                parent: 0 as *const redisCommand as *mut redisCommand,
19708                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19709            };
19710            init
19711        },
19712        {
19713            let mut init = redisCommand {
19714                declared_name: b"kill\0" as *const u8 as *const libc::c_char,
19715                summary: b"Kill the function currently in execution.\0" as *const u8
19716                    as *const libc::c_char,
19717                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
19718                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19719                doc_flags: 0 as libc::c_int,
19720                replaced_by: 0 as *const libc::c_char,
19721                deprecated_since: 0 as *const libc::c_char,
19722                group: COMMAND_GROUP_SCRIPTING,
19723                history: 0 as *const commandHistory as *mut commandHistory,
19724                tips: FUNCTION_KILL_tips.as_ptr() as *mut _,
19725                proc_0: Some(
19726                    functionKillCommand as unsafe extern "C" fn(*mut client) -> (),
19727                ),
19728                arity: 2 as libc::c_int,
19729                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
19730                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
19731                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19732                    as uint64_t,
19733                key_specs_static: [keySpec {
19734                    notes: 0 as *const libc::c_char,
19735                    flags: 0,
19736                    begin_search_type: KSPEC_BS_INVALID,
19737                    bs: C2RustUnnamed_3 {
19738                        index: C2RustUnnamed_5 { pos: 0 },
19739                    },
19740                    find_keys_type: KSPEC_FK_INVALID,
19741                    fk: C2RustUnnamed_0 {
19742                        range: C2RustUnnamed_2 {
19743                            lastkey: 0,
19744                            keystep: 0,
19745                            limit: 0,
19746                        },
19747                    },
19748                }; 4],
19749                getkeys_proc: None,
19750                subcommands: 0 as *const redisCommand as *mut redisCommand,
19751                args: 0 as *const redisCommandArg as *mut redisCommandArg,
19752                microseconds: 0,
19753                calls: 0,
19754                rejected_calls: 0,
19755                failed_calls: 0,
19756                id: 0,
19757                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19758                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19759                key_specs: 0 as *const keySpec as *mut keySpec,
19760                legacy_range_key_spec: keySpec {
19761                    notes: 0 as *const libc::c_char,
19762                    flags: 0,
19763                    begin_search_type: KSPEC_BS_INVALID,
19764                    bs: C2RustUnnamed_3 {
19765                        index: C2RustUnnamed_5 { pos: 0 },
19766                    },
19767                    find_keys_type: KSPEC_FK_INVALID,
19768                    fk: C2RustUnnamed_0 {
19769                        range: C2RustUnnamed_2 {
19770                            lastkey: 0,
19771                            keystep: 0,
19772                            limit: 0,
19773                        },
19774                    },
19775                },
19776                num_args: 0,
19777                num_history: 0,
19778                num_tips: 0,
19779                key_specs_num: 0,
19780                key_specs_max: 0,
19781                subcommands_dict: 0 as *const dict as *mut dict,
19782                parent: 0 as *const redisCommand as *mut redisCommand,
19783                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19784            };
19785            init
19786        },
19787        {
19788            let mut init = redisCommand {
19789                declared_name: b"list\0" as *const u8 as *const libc::c_char,
19790                summary: b"List information about all the functions\0" as *const u8
19791                    as *const libc::c_char,
19792                complexity: b"O(N) where N is the number of functions\0" as *const u8
19793                    as *const libc::c_char,
19794                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19795                doc_flags: 0 as libc::c_int,
19796                replaced_by: 0 as *const libc::c_char,
19797                deprecated_since: 0 as *const libc::c_char,
19798                group: COMMAND_GROUP_SCRIPTING,
19799                history: 0 as *const commandHistory as *mut commandHistory,
19800                tips: FUNCTION_LIST_tips.as_ptr() as *mut _,
19801                proc_0: Some(
19802                    functionListCommand as unsafe extern "C" fn(*mut client) -> (),
19803                ),
19804                arity: -(2 as libc::c_int),
19805                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
19806                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19807                    as uint64_t,
19808                key_specs_static: [keySpec {
19809                    notes: 0 as *const libc::c_char,
19810                    flags: 0,
19811                    begin_search_type: KSPEC_BS_INVALID,
19812                    bs: C2RustUnnamed_3 {
19813                        index: C2RustUnnamed_5 { pos: 0 },
19814                    },
19815                    find_keys_type: KSPEC_FK_INVALID,
19816                    fk: C2RustUnnamed_0 {
19817                        range: C2RustUnnamed_2 {
19818                            lastkey: 0,
19819                            keystep: 0,
19820                            limit: 0,
19821                        },
19822                    },
19823                }; 4],
19824                getkeys_proc: None,
19825                subcommands: 0 as *const redisCommand as *mut redisCommand,
19826                args: FUNCTION_LIST_Args.as_ptr() as *mut _,
19827                microseconds: 0,
19828                calls: 0,
19829                rejected_calls: 0,
19830                failed_calls: 0,
19831                id: 0,
19832                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19833                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19834                key_specs: 0 as *const keySpec as *mut keySpec,
19835                legacy_range_key_spec: keySpec {
19836                    notes: 0 as *const libc::c_char,
19837                    flags: 0,
19838                    begin_search_type: KSPEC_BS_INVALID,
19839                    bs: C2RustUnnamed_3 {
19840                        index: C2RustUnnamed_5 { pos: 0 },
19841                    },
19842                    find_keys_type: KSPEC_FK_INVALID,
19843                    fk: C2RustUnnamed_0 {
19844                        range: C2RustUnnamed_2 {
19845                            lastkey: 0,
19846                            keystep: 0,
19847                            limit: 0,
19848                        },
19849                    },
19850                },
19851                num_args: 0,
19852                num_history: 0,
19853                num_tips: 0,
19854                key_specs_num: 0,
19855                key_specs_max: 0,
19856                subcommands_dict: 0 as *const dict as *mut dict,
19857                parent: 0 as *const redisCommand as *mut redisCommand,
19858                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19859            };
19860            init
19861        },
19862        {
19863            let mut init = redisCommand {
19864                declared_name: b"load\0" as *const u8 as *const libc::c_char,
19865                summary: b"Create a function with the given arguments (name, code, description)\0"
19866                    as *const u8 as *const libc::c_char,
19867                complexity: b"O(1) (considering compilation time is redundant)\0"
19868                    as *const u8 as *const libc::c_char,
19869                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19870                doc_flags: 0 as libc::c_int,
19871                replaced_by: 0 as *const libc::c_char,
19872                deprecated_since: 0 as *const libc::c_char,
19873                group: COMMAND_GROUP_SCRIPTING,
19874                history: 0 as *const commandHistory as *mut commandHistory,
19875                tips: FUNCTION_LOAD_tips.as_ptr() as *mut _,
19876                proc_0: Some(
19877                    functionLoadCommand as unsafe extern "C" fn(*mut client) -> (),
19878                ),
19879                arity: -(3 as libc::c_int),
19880                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
19881                    | (1 as libc::c_ulonglong) << 0 as libc::c_int
19882                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
19883                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19884                    as uint64_t,
19885                key_specs_static: [keySpec {
19886                    notes: 0 as *const libc::c_char,
19887                    flags: 0,
19888                    begin_search_type: KSPEC_BS_INVALID,
19889                    bs: C2RustUnnamed_3 {
19890                        index: C2RustUnnamed_5 { pos: 0 },
19891                    },
19892                    find_keys_type: KSPEC_FK_INVALID,
19893                    fk: C2RustUnnamed_0 {
19894                        range: C2RustUnnamed_2 {
19895                            lastkey: 0,
19896                            keystep: 0,
19897                            limit: 0,
19898                        },
19899                    },
19900                }; 4],
19901                getkeys_proc: None,
19902                subcommands: 0 as *const redisCommand as *mut redisCommand,
19903                args: FUNCTION_LOAD_Args.as_ptr() as *mut _,
19904                microseconds: 0,
19905                calls: 0,
19906                rejected_calls: 0,
19907                failed_calls: 0,
19908                id: 0,
19909                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19910                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19911                key_specs: 0 as *const keySpec as *mut keySpec,
19912                legacy_range_key_spec: keySpec {
19913                    notes: 0 as *const libc::c_char,
19914                    flags: 0,
19915                    begin_search_type: KSPEC_BS_INVALID,
19916                    bs: C2RustUnnamed_3 {
19917                        index: C2RustUnnamed_5 { pos: 0 },
19918                    },
19919                    find_keys_type: KSPEC_FK_INVALID,
19920                    fk: C2RustUnnamed_0 {
19921                        range: C2RustUnnamed_2 {
19922                            lastkey: 0,
19923                            keystep: 0,
19924                            limit: 0,
19925                        },
19926                    },
19927                },
19928                num_args: 0,
19929                num_history: 0,
19930                num_tips: 0,
19931                key_specs_num: 0,
19932                key_specs_max: 0,
19933                subcommands_dict: 0 as *const dict as *mut dict,
19934                parent: 0 as *const redisCommand as *mut redisCommand,
19935                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
19936            };
19937            init
19938        },
19939        {
19940            let mut init = redisCommand {
19941                declared_name: b"restore\0" as *const u8 as *const libc::c_char,
19942                summary: b"Restore all the functions on the given payload\0" as *const u8
19943                    as *const libc::c_char,
19944                complexity: b"O(N) where N is the number of functions on the payload\0"
19945                    as *const u8 as *const libc::c_char,
19946                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
19947                doc_flags: 0 as libc::c_int,
19948                replaced_by: 0 as *const libc::c_char,
19949                deprecated_since: 0 as *const libc::c_char,
19950                group: COMMAND_GROUP_SCRIPTING,
19951                history: 0 as *const commandHistory as *mut commandHistory,
19952                tips: FUNCTION_RESTORE_tips.as_ptr() as *mut _,
19953                proc_0: Some(
19954                    functionRestoreCommand as unsafe extern "C" fn(*mut client) -> (),
19955                ),
19956                arity: -(3 as libc::c_int),
19957                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
19958                    | (1 as libc::c_ulonglong) << 0 as libc::c_int
19959                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
19960                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
19961                    as uint64_t,
19962                key_specs_static: [keySpec {
19963                    notes: 0 as *const libc::c_char,
19964                    flags: 0,
19965                    begin_search_type: KSPEC_BS_INVALID,
19966                    bs: C2RustUnnamed_3 {
19967                        index: C2RustUnnamed_5 { pos: 0 },
19968                    },
19969                    find_keys_type: KSPEC_FK_INVALID,
19970                    fk: C2RustUnnamed_0 {
19971                        range: C2RustUnnamed_2 {
19972                            lastkey: 0,
19973                            keystep: 0,
19974                            limit: 0,
19975                        },
19976                    },
19977                }; 4],
19978                getkeys_proc: None,
19979                subcommands: 0 as *const redisCommand as *mut redisCommand,
19980                args: FUNCTION_RESTORE_Args.as_ptr() as *mut _,
19981                microseconds: 0,
19982                calls: 0,
19983                rejected_calls: 0,
19984                failed_calls: 0,
19985                id: 0,
19986                fullname: 0 as *const libc::c_char as *mut libc::c_char,
19987                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
19988                key_specs: 0 as *const keySpec as *mut keySpec,
19989                legacy_range_key_spec: keySpec {
19990                    notes: 0 as *const libc::c_char,
19991                    flags: 0,
19992                    begin_search_type: KSPEC_BS_INVALID,
19993                    bs: C2RustUnnamed_3 {
19994                        index: C2RustUnnamed_5 { pos: 0 },
19995                    },
19996                    find_keys_type: KSPEC_FK_INVALID,
19997                    fk: C2RustUnnamed_0 {
19998                        range: C2RustUnnamed_2 {
19999                            lastkey: 0,
20000                            keystep: 0,
20001                            limit: 0,
20002                        },
20003                    },
20004                },
20005                num_args: 0,
20006                num_history: 0,
20007                num_tips: 0,
20008                key_specs_num: 0,
20009                key_specs_max: 0,
20010                subcommands_dict: 0 as *const dict as *mut dict,
20011                parent: 0 as *const redisCommand as *mut redisCommand,
20012                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20013            };
20014            init
20015        },
20016        {
20017            let mut init = redisCommand {
20018                declared_name: b"stats\0" as *const u8 as *const libc::c_char,
20019                summary: b"Return information about the function currently running (name, description, duration)\0"
20020                    as *const u8 as *const libc::c_char,
20021                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
20022                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
20023                doc_flags: 0 as libc::c_int,
20024                replaced_by: 0 as *const libc::c_char,
20025                deprecated_since: 0 as *const libc::c_char,
20026                group: COMMAND_GROUP_SCRIPTING,
20027                history: 0 as *const commandHistory as *mut commandHistory,
20028                tips: FUNCTION_STATS_tips.as_ptr() as *mut _,
20029                proc_0: Some(
20030                    functionStatsCommand as unsafe extern "C" fn(*mut client) -> (),
20031                ),
20032                arity: 2 as libc::c_int,
20033                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
20034                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
20035                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20036                    as uint64_t,
20037                key_specs_static: [keySpec {
20038                    notes: 0 as *const libc::c_char,
20039                    flags: 0,
20040                    begin_search_type: KSPEC_BS_INVALID,
20041                    bs: C2RustUnnamed_3 {
20042                        index: C2RustUnnamed_5 { pos: 0 },
20043                    },
20044                    find_keys_type: KSPEC_FK_INVALID,
20045                    fk: C2RustUnnamed_0 {
20046                        range: C2RustUnnamed_2 {
20047                            lastkey: 0,
20048                            keystep: 0,
20049                            limit: 0,
20050                        },
20051                    },
20052                }; 4],
20053                getkeys_proc: None,
20054                subcommands: 0 as *const redisCommand as *mut redisCommand,
20055                args: 0 as *const redisCommandArg as *mut redisCommandArg,
20056                microseconds: 0,
20057                calls: 0,
20058                rejected_calls: 0,
20059                failed_calls: 0,
20060                id: 0,
20061                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20062                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20063                key_specs: 0 as *const keySpec as *mut keySpec,
20064                legacy_range_key_spec: keySpec {
20065                    notes: 0 as *const libc::c_char,
20066                    flags: 0,
20067                    begin_search_type: KSPEC_BS_INVALID,
20068                    bs: C2RustUnnamed_3 {
20069                        index: C2RustUnnamed_5 { pos: 0 },
20070                    },
20071                    find_keys_type: KSPEC_FK_INVALID,
20072                    fk: C2RustUnnamed_0 {
20073                        range: C2RustUnnamed_2 {
20074                            lastkey: 0,
20075                            keystep: 0,
20076                            limit: 0,
20077                        },
20078                    },
20079                },
20080                num_args: 0,
20081                num_history: 0,
20082                num_tips: 0,
20083                key_specs_num: 0,
20084                key_specs_max: 0,
20085                subcommands_dict: 0 as *const dict as *mut dict,
20086                parent: 0 as *const redisCommand as *mut redisCommand,
20087                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20088            };
20089            init
20090        },
20091        {
20092            let mut init = redisCommand {
20093                declared_name: 0 as *const libc::c_char,
20094                summary: 0 as *const libc::c_char,
20095                complexity: 0 as *const libc::c_char,
20096                since: 0 as *const libc::c_char,
20097                doc_flags: 0,
20098                replaced_by: 0 as *const libc::c_char,
20099                deprecated_since: 0 as *const libc::c_char,
20100                group: COMMAND_GROUP_GENERIC,
20101                history: 0 as *const commandHistory as *mut commandHistory,
20102                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
20103                proc_0: None,
20104                arity: 0,
20105                flags: 0,
20106                acl_categories: 0,
20107                key_specs_static: [keySpec {
20108                    notes: 0 as *const libc::c_char,
20109                    flags: 0,
20110                    begin_search_type: KSPEC_BS_INVALID,
20111                    bs: C2RustUnnamed_3 {
20112                        index: C2RustUnnamed_5 { pos: 0 },
20113                    },
20114                    find_keys_type: KSPEC_FK_INVALID,
20115                    fk: C2RustUnnamed_0 {
20116                        range: C2RustUnnamed_2 {
20117                            lastkey: 0,
20118                            keystep: 0,
20119                            limit: 0,
20120                        },
20121                    },
20122                }; 4],
20123                getkeys_proc: None,
20124                subcommands: 0 as *const redisCommand as *mut redisCommand,
20125                args: 0 as *const redisCommandArg as *mut redisCommandArg,
20126                microseconds: 0,
20127                calls: 0,
20128                rejected_calls: 0,
20129                failed_calls: 0,
20130                id: 0,
20131                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20132                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20133                key_specs: 0 as *const keySpec as *mut keySpec,
20134                legacy_range_key_spec: keySpec {
20135                    notes: 0 as *const libc::c_char,
20136                    flags: 0,
20137                    begin_search_type: KSPEC_BS_INVALID,
20138                    bs: C2RustUnnamed_3 {
20139                        index: C2RustUnnamed_5 { pos: 0 },
20140                    },
20141                    find_keys_type: KSPEC_FK_INVALID,
20142                    fk: C2RustUnnamed_0 {
20143                        range: C2RustUnnamed_2 {
20144                            lastkey: 0,
20145                            keystep: 0,
20146                            limit: 0,
20147                        },
20148                    },
20149                },
20150                num_args: 0,
20151                num_history: 0,
20152                num_tips: 0,
20153                key_specs_num: 0,
20154                key_specs_max: 0,
20155                subcommands_dict: 0 as *const dict as *mut dict,
20156                parent: 0 as *const redisCommand as *mut redisCommand,
20157                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20158            };
20159            init
20160        },
20161    ]
20162};
20163#[no_mangle]
20164pub static mut SCRIPT_DEBUG_mode_Subargs: [redisCommandArg; 4] = [
20165    {
20166        let mut init = redisCommandArg {
20167            name: b"yes\0" as *const u8 as *const libc::c_char,
20168            type_0: ARG_TYPE_PURE_TOKEN,
20169            key_spec_index: -(1 as libc::c_int),
20170            token: b"YES\0" as *const u8 as *const libc::c_char,
20171            summary: 0 as *const libc::c_char,
20172            since: 0 as *const libc::c_char,
20173            flags: 0 as libc::c_int,
20174            deprecated_since: 0 as *const libc::c_char,
20175            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20176            num_args: 0,
20177        };
20178        init
20179    },
20180    {
20181        let mut init = redisCommandArg {
20182            name: b"sync\0" as *const u8 as *const libc::c_char,
20183            type_0: ARG_TYPE_PURE_TOKEN,
20184            key_spec_index: -(1 as libc::c_int),
20185            token: b"SYNC\0" as *const u8 as *const libc::c_char,
20186            summary: 0 as *const libc::c_char,
20187            since: 0 as *const libc::c_char,
20188            flags: 0 as libc::c_int,
20189            deprecated_since: 0 as *const libc::c_char,
20190            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20191            num_args: 0,
20192        };
20193        init
20194    },
20195    {
20196        let mut init = redisCommandArg {
20197            name: b"no\0" as *const u8 as *const libc::c_char,
20198            type_0: ARG_TYPE_PURE_TOKEN,
20199            key_spec_index: -(1 as libc::c_int),
20200            token: b"NO\0" as *const u8 as *const libc::c_char,
20201            summary: 0 as *const libc::c_char,
20202            since: 0 as *const libc::c_char,
20203            flags: 0 as libc::c_int,
20204            deprecated_since: 0 as *const libc::c_char,
20205            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20206            num_args: 0,
20207        };
20208        init
20209    },
20210    {
20211        let mut init = redisCommandArg {
20212            name: 0 as *const libc::c_char,
20213            type_0: ARG_TYPE_STRING,
20214            key_spec_index: 0,
20215            token: 0 as *const libc::c_char,
20216            summary: 0 as *const libc::c_char,
20217            since: 0 as *const libc::c_char,
20218            flags: 0,
20219            deprecated_since: 0 as *const libc::c_char,
20220            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20221            num_args: 0,
20222        };
20223        init
20224    },
20225];
20226#[no_mangle]
20227pub static mut SCRIPT_DEBUG_Args: [redisCommandArg; 2] = unsafe {
20228    [
20229        {
20230            let mut init = redisCommandArg {
20231                name: b"mode\0" as *const u8 as *const libc::c_char,
20232                type_0: ARG_TYPE_ONEOF,
20233                key_spec_index: -(1 as libc::c_int),
20234                token: 0 as *const libc::c_char,
20235                summary: 0 as *const libc::c_char,
20236                since: 0 as *const libc::c_char,
20237                flags: 0 as libc::c_int,
20238                deprecated_since: 0 as *const libc::c_char,
20239                subargs: SCRIPT_DEBUG_mode_Subargs.as_ptr() as *mut _,
20240                num_args: 0,
20241            };
20242            init
20243        },
20244        {
20245            let mut init = redisCommandArg {
20246                name: 0 as *const libc::c_char,
20247                type_0: ARG_TYPE_STRING,
20248                key_spec_index: 0,
20249                token: 0 as *const libc::c_char,
20250                summary: 0 as *const libc::c_char,
20251                since: 0 as *const libc::c_char,
20252                flags: 0,
20253                deprecated_since: 0 as *const libc::c_char,
20254                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20255                num_args: 0,
20256            };
20257            init
20258        },
20259    ]
20260};
20261#[no_mangle]
20262pub static mut SCRIPT_EXISTS_tips: [*const libc::c_char; 3] = [
20263    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
20264    b"response_policy:agg_logical_and\0" as *const u8 as *const libc::c_char,
20265    0 as *const libc::c_char,
20266];
20267#[no_mangle]
20268pub static mut SCRIPT_EXISTS_Args: [redisCommandArg; 2] = [
20269    {
20270        let mut init = redisCommandArg {
20271            name: b"sha1\0" as *const u8 as *const libc::c_char,
20272            type_0: ARG_TYPE_STRING,
20273            key_spec_index: -(1 as libc::c_int),
20274            token: 0 as *const libc::c_char,
20275            summary: 0 as *const libc::c_char,
20276            since: 0 as *const libc::c_char,
20277            flags: (1 as libc::c_int) << 1 as libc::c_int,
20278            deprecated_since: 0 as *const libc::c_char,
20279            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20280            num_args: 0,
20281        };
20282        init
20283    },
20284    {
20285        let mut init = redisCommandArg {
20286            name: 0 as *const libc::c_char,
20287            type_0: ARG_TYPE_STRING,
20288            key_spec_index: 0,
20289            token: 0 as *const libc::c_char,
20290            summary: 0 as *const libc::c_char,
20291            since: 0 as *const libc::c_char,
20292            flags: 0,
20293            deprecated_since: 0 as *const libc::c_char,
20294            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20295            num_args: 0,
20296        };
20297        init
20298    },
20299];
20300#[no_mangle]
20301pub static mut SCRIPT_FLUSH_History: [commandHistory; 2] = [
20302    {
20303        let mut init = commandHistory {
20304            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
20305            changes: b"Added the `ASYNC` and `SYNC` flushing mode modifiers.\0"
20306                as *const u8 as *const libc::c_char,
20307        };
20308        init
20309    },
20310    {
20311        let mut init = commandHistory {
20312            since: 0 as *const libc::c_char,
20313            changes: 0 as *const libc::c_char,
20314        };
20315        init
20316    },
20317];
20318#[no_mangle]
20319pub static mut SCRIPT_FLUSH_tips: [*const libc::c_char; 3] = [
20320    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
20321    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
20322    0 as *const libc::c_char,
20323];
20324#[no_mangle]
20325pub static mut SCRIPT_FLUSH_async_Subargs: [redisCommandArg; 3] = [
20326    {
20327        let mut init = redisCommandArg {
20328            name: b"async\0" as *const u8 as *const libc::c_char,
20329            type_0: ARG_TYPE_PURE_TOKEN,
20330            key_spec_index: -(1 as libc::c_int),
20331            token: b"ASYNC\0" as *const u8 as *const libc::c_char,
20332            summary: 0 as *const libc::c_char,
20333            since: 0 as *const libc::c_char,
20334            flags: 0 as libc::c_int,
20335            deprecated_since: 0 as *const libc::c_char,
20336            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20337            num_args: 0,
20338        };
20339        init
20340    },
20341    {
20342        let mut init = redisCommandArg {
20343            name: b"sync\0" as *const u8 as *const libc::c_char,
20344            type_0: ARG_TYPE_PURE_TOKEN,
20345            key_spec_index: -(1 as libc::c_int),
20346            token: b"SYNC\0" as *const u8 as *const libc::c_char,
20347            summary: 0 as *const libc::c_char,
20348            since: 0 as *const libc::c_char,
20349            flags: 0 as libc::c_int,
20350            deprecated_since: 0 as *const libc::c_char,
20351            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20352            num_args: 0,
20353        };
20354        init
20355    },
20356    {
20357        let mut init = redisCommandArg {
20358            name: 0 as *const libc::c_char,
20359            type_0: ARG_TYPE_STRING,
20360            key_spec_index: 0,
20361            token: 0 as *const libc::c_char,
20362            summary: 0 as *const libc::c_char,
20363            since: 0 as *const libc::c_char,
20364            flags: 0,
20365            deprecated_since: 0 as *const libc::c_char,
20366            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20367            num_args: 0,
20368        };
20369        init
20370    },
20371];
20372#[no_mangle]
20373pub static mut SCRIPT_FLUSH_Args: [redisCommandArg; 2] = unsafe {
20374    [
20375        {
20376            let mut init = redisCommandArg {
20377                name: b"async\0" as *const u8 as *const libc::c_char,
20378                type_0: ARG_TYPE_ONEOF,
20379                key_spec_index: -(1 as libc::c_int),
20380                token: 0 as *const libc::c_char,
20381                summary: 0 as *const libc::c_char,
20382                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
20383                flags: (1 as libc::c_int) << 0 as libc::c_int,
20384                deprecated_since: 0 as *const libc::c_char,
20385                subargs: SCRIPT_FLUSH_async_Subargs.as_ptr() as *mut _,
20386                num_args: 0,
20387            };
20388            init
20389        },
20390        {
20391            let mut init = redisCommandArg {
20392                name: 0 as *const libc::c_char,
20393                type_0: ARG_TYPE_STRING,
20394                key_spec_index: 0,
20395                token: 0 as *const libc::c_char,
20396                summary: 0 as *const libc::c_char,
20397                since: 0 as *const libc::c_char,
20398                flags: 0,
20399                deprecated_since: 0 as *const libc::c_char,
20400                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20401                num_args: 0,
20402            };
20403            init
20404        },
20405    ]
20406};
20407#[no_mangle]
20408pub static mut SCRIPT_KILL_tips: [*const libc::c_char; 3] = [
20409    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
20410    b"response_policy:one_succeeded\0" as *const u8 as *const libc::c_char,
20411    0 as *const libc::c_char,
20412];
20413#[no_mangle]
20414pub static mut SCRIPT_LOAD_tips: [*const libc::c_char; 3] = [
20415    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
20416    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
20417    0 as *const libc::c_char,
20418];
20419#[no_mangle]
20420pub static mut SCRIPT_LOAD_Args: [redisCommandArg; 2] = [
20421    {
20422        let mut init = redisCommandArg {
20423            name: b"script\0" as *const u8 as *const libc::c_char,
20424            type_0: ARG_TYPE_STRING,
20425            key_spec_index: -(1 as libc::c_int),
20426            token: 0 as *const libc::c_char,
20427            summary: 0 as *const libc::c_char,
20428            since: 0 as *const libc::c_char,
20429            flags: 0 as libc::c_int,
20430            deprecated_since: 0 as *const libc::c_char,
20431            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20432            num_args: 0,
20433        };
20434        init
20435    },
20436    {
20437        let mut init = redisCommandArg {
20438            name: 0 as *const libc::c_char,
20439            type_0: ARG_TYPE_STRING,
20440            key_spec_index: 0,
20441            token: 0 as *const libc::c_char,
20442            summary: 0 as *const libc::c_char,
20443            since: 0 as *const libc::c_char,
20444            flags: 0,
20445            deprecated_since: 0 as *const libc::c_char,
20446            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20447            num_args: 0,
20448        };
20449        init
20450    },
20451];
20452#[no_mangle]
20453pub static mut SCRIPT_Subcommands: [redisCommand; 7] = unsafe {
20454    [
20455        {
20456            let mut init = redisCommand {
20457                declared_name: b"debug\0" as *const u8 as *const libc::c_char,
20458                summary: b"Set the debug mode for executed scripts.\0" as *const u8
20459                    as *const libc::c_char,
20460                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
20461                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
20462                doc_flags: 0 as libc::c_int,
20463                replaced_by: 0 as *const libc::c_char,
20464                deprecated_since: 0 as *const libc::c_char,
20465                group: COMMAND_GROUP_SCRIPTING,
20466                history: 0 as *const commandHistory as *mut commandHistory,
20467                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
20468                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20469                arity: 3 as libc::c_int,
20470                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
20471                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20472                    as uint64_t,
20473                key_specs_static: [keySpec {
20474                    notes: 0 as *const libc::c_char,
20475                    flags: 0,
20476                    begin_search_type: KSPEC_BS_INVALID,
20477                    bs: C2RustUnnamed_3 {
20478                        index: C2RustUnnamed_5 { pos: 0 },
20479                    },
20480                    find_keys_type: KSPEC_FK_INVALID,
20481                    fk: C2RustUnnamed_0 {
20482                        range: C2RustUnnamed_2 {
20483                            lastkey: 0,
20484                            keystep: 0,
20485                            limit: 0,
20486                        },
20487                    },
20488                }; 4],
20489                getkeys_proc: None,
20490                subcommands: 0 as *const redisCommand as *mut redisCommand,
20491                args: SCRIPT_DEBUG_Args.as_ptr() as *mut _,
20492                microseconds: 0,
20493                calls: 0,
20494                rejected_calls: 0,
20495                failed_calls: 0,
20496                id: 0,
20497                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20498                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20499                key_specs: 0 as *const keySpec as *mut keySpec,
20500                legacy_range_key_spec: keySpec {
20501                    notes: 0 as *const libc::c_char,
20502                    flags: 0,
20503                    begin_search_type: KSPEC_BS_INVALID,
20504                    bs: C2RustUnnamed_3 {
20505                        index: C2RustUnnamed_5 { pos: 0 },
20506                    },
20507                    find_keys_type: KSPEC_FK_INVALID,
20508                    fk: C2RustUnnamed_0 {
20509                        range: C2RustUnnamed_2 {
20510                            lastkey: 0,
20511                            keystep: 0,
20512                            limit: 0,
20513                        },
20514                    },
20515                },
20516                num_args: 0,
20517                num_history: 0,
20518                num_tips: 0,
20519                key_specs_num: 0,
20520                key_specs_max: 0,
20521                subcommands_dict: 0 as *const dict as *mut dict,
20522                parent: 0 as *const redisCommand as *mut redisCommand,
20523                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20524            };
20525            init
20526        },
20527        {
20528            let mut init = redisCommand {
20529                declared_name: b"exists\0" as *const u8 as *const libc::c_char,
20530                summary: b"Check existence of scripts in the script cache.\0"
20531                    as *const u8 as *const libc::c_char,
20532                complexity: b"O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).\0"
20533                    as *const u8 as *const libc::c_char,
20534                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
20535                doc_flags: 0 as libc::c_int,
20536                replaced_by: 0 as *const libc::c_char,
20537                deprecated_since: 0 as *const libc::c_char,
20538                group: COMMAND_GROUP_SCRIPTING,
20539                history: 0 as *const commandHistory as *mut commandHistory,
20540                tips: SCRIPT_EXISTS_tips.as_ptr() as *mut _,
20541                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20542                arity: -(3 as libc::c_int),
20543                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
20544                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20545                    as uint64_t,
20546                key_specs_static: [keySpec {
20547                    notes: 0 as *const libc::c_char,
20548                    flags: 0,
20549                    begin_search_type: KSPEC_BS_INVALID,
20550                    bs: C2RustUnnamed_3 {
20551                        index: C2RustUnnamed_5 { pos: 0 },
20552                    },
20553                    find_keys_type: KSPEC_FK_INVALID,
20554                    fk: C2RustUnnamed_0 {
20555                        range: C2RustUnnamed_2 {
20556                            lastkey: 0,
20557                            keystep: 0,
20558                            limit: 0,
20559                        },
20560                    },
20561                }; 4],
20562                getkeys_proc: None,
20563                subcommands: 0 as *const redisCommand as *mut redisCommand,
20564                args: SCRIPT_EXISTS_Args.as_ptr() as *mut _,
20565                microseconds: 0,
20566                calls: 0,
20567                rejected_calls: 0,
20568                failed_calls: 0,
20569                id: 0,
20570                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20571                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20572                key_specs: 0 as *const keySpec as *mut keySpec,
20573                legacy_range_key_spec: keySpec {
20574                    notes: 0 as *const libc::c_char,
20575                    flags: 0,
20576                    begin_search_type: KSPEC_BS_INVALID,
20577                    bs: C2RustUnnamed_3 {
20578                        index: C2RustUnnamed_5 { pos: 0 },
20579                    },
20580                    find_keys_type: KSPEC_FK_INVALID,
20581                    fk: C2RustUnnamed_0 {
20582                        range: C2RustUnnamed_2 {
20583                            lastkey: 0,
20584                            keystep: 0,
20585                            limit: 0,
20586                        },
20587                    },
20588                },
20589                num_args: 0,
20590                num_history: 0,
20591                num_tips: 0,
20592                key_specs_num: 0,
20593                key_specs_max: 0,
20594                subcommands_dict: 0 as *const dict as *mut dict,
20595                parent: 0 as *const redisCommand as *mut redisCommand,
20596                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20597            };
20598            init
20599        },
20600        {
20601            let mut init = redisCommand {
20602                declared_name: b"flush\0" as *const u8 as *const libc::c_char,
20603                summary: b"Remove all the scripts from the script cache.\0" as *const u8
20604                    as *const libc::c_char,
20605                complexity: b"O(N) with N being the number of scripts in cache\0"
20606                    as *const u8 as *const libc::c_char,
20607                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
20608                doc_flags: 0 as libc::c_int,
20609                replaced_by: 0 as *const libc::c_char,
20610                deprecated_since: 0 as *const libc::c_char,
20611                group: COMMAND_GROUP_SCRIPTING,
20612                history: SCRIPT_FLUSH_History.as_ptr() as *mut _,
20613                tips: SCRIPT_FLUSH_tips.as_ptr() as *mut _,
20614                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20615                arity: -(2 as libc::c_int),
20616                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
20617                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20618                    as uint64_t,
20619                key_specs_static: [keySpec {
20620                    notes: 0 as *const libc::c_char,
20621                    flags: 0,
20622                    begin_search_type: KSPEC_BS_INVALID,
20623                    bs: C2RustUnnamed_3 {
20624                        index: C2RustUnnamed_5 { pos: 0 },
20625                    },
20626                    find_keys_type: KSPEC_FK_INVALID,
20627                    fk: C2RustUnnamed_0 {
20628                        range: C2RustUnnamed_2 {
20629                            lastkey: 0,
20630                            keystep: 0,
20631                            limit: 0,
20632                        },
20633                    },
20634                }; 4],
20635                getkeys_proc: None,
20636                subcommands: 0 as *const redisCommand as *mut redisCommand,
20637                args: SCRIPT_FLUSH_Args.as_ptr() as *mut _,
20638                microseconds: 0,
20639                calls: 0,
20640                rejected_calls: 0,
20641                failed_calls: 0,
20642                id: 0,
20643                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20644                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20645                key_specs: 0 as *const keySpec as *mut keySpec,
20646                legacy_range_key_spec: keySpec {
20647                    notes: 0 as *const libc::c_char,
20648                    flags: 0,
20649                    begin_search_type: KSPEC_BS_INVALID,
20650                    bs: C2RustUnnamed_3 {
20651                        index: C2RustUnnamed_5 { pos: 0 },
20652                    },
20653                    find_keys_type: KSPEC_FK_INVALID,
20654                    fk: C2RustUnnamed_0 {
20655                        range: C2RustUnnamed_2 {
20656                            lastkey: 0,
20657                            keystep: 0,
20658                            limit: 0,
20659                        },
20660                    },
20661                },
20662                num_args: 0,
20663                num_history: 0,
20664                num_tips: 0,
20665                key_specs_num: 0,
20666                key_specs_max: 0,
20667                subcommands_dict: 0 as *const dict as *mut dict,
20668                parent: 0 as *const redisCommand as *mut redisCommand,
20669                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20670            };
20671            init
20672        },
20673        {
20674            let mut init = redisCommand {
20675                declared_name: b"help\0" as *const u8 as *const libc::c_char,
20676                summary: b"Show helpful text about the different subcommands\0"
20677                    as *const u8 as *const libc::c_char,
20678                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
20679                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
20680                doc_flags: 0 as libc::c_int,
20681                replaced_by: 0 as *const libc::c_char,
20682                deprecated_since: 0 as *const libc::c_char,
20683                group: COMMAND_GROUP_SCRIPTING,
20684                history: 0 as *const commandHistory as *mut commandHistory,
20685                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
20686                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20687                arity: 2 as libc::c_int,
20688                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
20689                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
20690                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20691                    as uint64_t,
20692                key_specs_static: [keySpec {
20693                    notes: 0 as *const libc::c_char,
20694                    flags: 0,
20695                    begin_search_type: KSPEC_BS_INVALID,
20696                    bs: C2RustUnnamed_3 {
20697                        index: C2RustUnnamed_5 { pos: 0 },
20698                    },
20699                    find_keys_type: KSPEC_FK_INVALID,
20700                    fk: C2RustUnnamed_0 {
20701                        range: C2RustUnnamed_2 {
20702                            lastkey: 0,
20703                            keystep: 0,
20704                            limit: 0,
20705                        },
20706                    },
20707                }; 4],
20708                getkeys_proc: None,
20709                subcommands: 0 as *const redisCommand as *mut redisCommand,
20710                args: 0 as *const redisCommandArg as *mut redisCommandArg,
20711                microseconds: 0,
20712                calls: 0,
20713                rejected_calls: 0,
20714                failed_calls: 0,
20715                id: 0,
20716                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20717                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20718                key_specs: 0 as *const keySpec as *mut keySpec,
20719                legacy_range_key_spec: keySpec {
20720                    notes: 0 as *const libc::c_char,
20721                    flags: 0,
20722                    begin_search_type: KSPEC_BS_INVALID,
20723                    bs: C2RustUnnamed_3 {
20724                        index: C2RustUnnamed_5 { pos: 0 },
20725                    },
20726                    find_keys_type: KSPEC_FK_INVALID,
20727                    fk: C2RustUnnamed_0 {
20728                        range: C2RustUnnamed_2 {
20729                            lastkey: 0,
20730                            keystep: 0,
20731                            limit: 0,
20732                        },
20733                    },
20734                },
20735                num_args: 0,
20736                num_history: 0,
20737                num_tips: 0,
20738                key_specs_num: 0,
20739                key_specs_max: 0,
20740                subcommands_dict: 0 as *const dict as *mut dict,
20741                parent: 0 as *const redisCommand as *mut redisCommand,
20742                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20743            };
20744            init
20745        },
20746        {
20747            let mut init = redisCommand {
20748                declared_name: b"kill\0" as *const u8 as *const libc::c_char,
20749                summary: b"Kill the script currently in execution.\0" as *const u8
20750                    as *const libc::c_char,
20751                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
20752                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
20753                doc_flags: 0 as libc::c_int,
20754                replaced_by: 0 as *const libc::c_char,
20755                deprecated_since: 0 as *const libc::c_char,
20756                group: COMMAND_GROUP_SCRIPTING,
20757                history: 0 as *const commandHistory as *mut commandHistory,
20758                tips: SCRIPT_KILL_tips.as_ptr() as *mut _,
20759                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20760                arity: 2 as libc::c_int,
20761                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
20762                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
20763                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20764                    as uint64_t,
20765                key_specs_static: [keySpec {
20766                    notes: 0 as *const libc::c_char,
20767                    flags: 0,
20768                    begin_search_type: KSPEC_BS_INVALID,
20769                    bs: C2RustUnnamed_3 {
20770                        index: C2RustUnnamed_5 { pos: 0 },
20771                    },
20772                    find_keys_type: KSPEC_FK_INVALID,
20773                    fk: C2RustUnnamed_0 {
20774                        range: C2RustUnnamed_2 {
20775                            lastkey: 0,
20776                            keystep: 0,
20777                            limit: 0,
20778                        },
20779                    },
20780                }; 4],
20781                getkeys_proc: None,
20782                subcommands: 0 as *const redisCommand as *mut redisCommand,
20783                args: 0 as *const redisCommandArg as *mut redisCommandArg,
20784                microseconds: 0,
20785                calls: 0,
20786                rejected_calls: 0,
20787                failed_calls: 0,
20788                id: 0,
20789                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20790                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20791                key_specs: 0 as *const keySpec as *mut keySpec,
20792                legacy_range_key_spec: keySpec {
20793                    notes: 0 as *const libc::c_char,
20794                    flags: 0,
20795                    begin_search_type: KSPEC_BS_INVALID,
20796                    bs: C2RustUnnamed_3 {
20797                        index: C2RustUnnamed_5 { pos: 0 },
20798                    },
20799                    find_keys_type: KSPEC_FK_INVALID,
20800                    fk: C2RustUnnamed_0 {
20801                        range: C2RustUnnamed_2 {
20802                            lastkey: 0,
20803                            keystep: 0,
20804                            limit: 0,
20805                        },
20806                    },
20807                },
20808                num_args: 0,
20809                num_history: 0,
20810                num_tips: 0,
20811                key_specs_num: 0,
20812                key_specs_max: 0,
20813                subcommands_dict: 0 as *const dict as *mut dict,
20814                parent: 0 as *const redisCommand as *mut redisCommand,
20815                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20816            };
20817            init
20818        },
20819        {
20820            let mut init = redisCommand {
20821                declared_name: b"load\0" as *const u8 as *const libc::c_char,
20822                summary: b"Load the specified Lua script into the script cache.\0"
20823                    as *const u8 as *const libc::c_char,
20824                complexity: b"O(N) with N being the length in bytes of the script body.\0"
20825                    as *const u8 as *const libc::c_char,
20826                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
20827                doc_flags: 0 as libc::c_int,
20828                replaced_by: 0 as *const libc::c_char,
20829                deprecated_since: 0 as *const libc::c_char,
20830                group: COMMAND_GROUP_SCRIPTING,
20831                history: 0 as *const commandHistory as *mut commandHistory,
20832                tips: SCRIPT_LOAD_tips.as_ptr() as *mut _,
20833                proc_0: Some(scriptCommand as unsafe extern "C" fn(*mut client) -> ()),
20834                arity: 3 as libc::c_int,
20835                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
20836                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
20837                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
20838                    as uint64_t,
20839                key_specs_static: [keySpec {
20840                    notes: 0 as *const libc::c_char,
20841                    flags: 0,
20842                    begin_search_type: KSPEC_BS_INVALID,
20843                    bs: C2RustUnnamed_3 {
20844                        index: C2RustUnnamed_5 { pos: 0 },
20845                    },
20846                    find_keys_type: KSPEC_FK_INVALID,
20847                    fk: C2RustUnnamed_0 {
20848                        range: C2RustUnnamed_2 {
20849                            lastkey: 0,
20850                            keystep: 0,
20851                            limit: 0,
20852                        },
20853                    },
20854                }; 4],
20855                getkeys_proc: None,
20856                subcommands: 0 as *const redisCommand as *mut redisCommand,
20857                args: SCRIPT_LOAD_Args.as_ptr() as *mut _,
20858                microseconds: 0,
20859                calls: 0,
20860                rejected_calls: 0,
20861                failed_calls: 0,
20862                id: 0,
20863                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20864                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20865                key_specs: 0 as *const keySpec as *mut keySpec,
20866                legacy_range_key_spec: keySpec {
20867                    notes: 0 as *const libc::c_char,
20868                    flags: 0,
20869                    begin_search_type: KSPEC_BS_INVALID,
20870                    bs: C2RustUnnamed_3 {
20871                        index: C2RustUnnamed_5 { pos: 0 },
20872                    },
20873                    find_keys_type: KSPEC_FK_INVALID,
20874                    fk: C2RustUnnamed_0 {
20875                        range: C2RustUnnamed_2 {
20876                            lastkey: 0,
20877                            keystep: 0,
20878                            limit: 0,
20879                        },
20880                    },
20881                },
20882                num_args: 0,
20883                num_history: 0,
20884                num_tips: 0,
20885                key_specs_num: 0,
20886                key_specs_max: 0,
20887                subcommands_dict: 0 as *const dict as *mut dict,
20888                parent: 0 as *const redisCommand as *mut redisCommand,
20889                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20890            };
20891            init
20892        },
20893        {
20894            let mut init = redisCommand {
20895                declared_name: 0 as *const libc::c_char,
20896                summary: 0 as *const libc::c_char,
20897                complexity: 0 as *const libc::c_char,
20898                since: 0 as *const libc::c_char,
20899                doc_flags: 0,
20900                replaced_by: 0 as *const libc::c_char,
20901                deprecated_since: 0 as *const libc::c_char,
20902                group: COMMAND_GROUP_GENERIC,
20903                history: 0 as *const commandHistory as *mut commandHistory,
20904                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
20905                proc_0: None,
20906                arity: 0,
20907                flags: 0,
20908                acl_categories: 0,
20909                key_specs_static: [keySpec {
20910                    notes: 0 as *const libc::c_char,
20911                    flags: 0,
20912                    begin_search_type: KSPEC_BS_INVALID,
20913                    bs: C2RustUnnamed_3 {
20914                        index: C2RustUnnamed_5 { pos: 0 },
20915                    },
20916                    find_keys_type: KSPEC_FK_INVALID,
20917                    fk: C2RustUnnamed_0 {
20918                        range: C2RustUnnamed_2 {
20919                            lastkey: 0,
20920                            keystep: 0,
20921                            limit: 0,
20922                        },
20923                    },
20924                }; 4],
20925                getkeys_proc: None,
20926                subcommands: 0 as *const redisCommand as *mut redisCommand,
20927                args: 0 as *const redisCommandArg as *mut redisCommandArg,
20928                microseconds: 0,
20929                calls: 0,
20930                rejected_calls: 0,
20931                failed_calls: 0,
20932                id: 0,
20933                fullname: 0 as *const libc::c_char as *mut libc::c_char,
20934                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
20935                key_specs: 0 as *const keySpec as *mut keySpec,
20936                legacy_range_key_spec: keySpec {
20937                    notes: 0 as *const libc::c_char,
20938                    flags: 0,
20939                    begin_search_type: KSPEC_BS_INVALID,
20940                    bs: C2RustUnnamed_3 {
20941                        index: C2RustUnnamed_5 { pos: 0 },
20942                    },
20943                    find_keys_type: KSPEC_FK_INVALID,
20944                    fk: C2RustUnnamed_0 {
20945                        range: C2RustUnnamed_2 {
20946                            lastkey: 0,
20947                            keystep: 0,
20948                            limit: 0,
20949                        },
20950                    },
20951                },
20952                num_args: 0,
20953                num_history: 0,
20954                num_tips: 0,
20955                key_specs_num: 0,
20956                key_specs_max: 0,
20957                subcommands_dict: 0 as *const dict as *mut dict,
20958                parent: 0 as *const redisCommand as *mut redisCommand,
20959                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
20960            };
20961            init
20962        },
20963    ]
20964};
20965#[no_mangle]
20966pub static mut SENTINEL_CKQUORUM_Args: [redisCommandArg; 2] = [
20967    {
20968        let mut init = redisCommandArg {
20969            name: b"master-name\0" as *const u8 as *const libc::c_char,
20970            type_0: ARG_TYPE_STRING,
20971            key_spec_index: -(1 as libc::c_int),
20972            token: 0 as *const libc::c_char,
20973            summary: 0 as *const libc::c_char,
20974            since: 0 as *const libc::c_char,
20975            flags: 0 as libc::c_int,
20976            deprecated_since: 0 as *const libc::c_char,
20977            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20978            num_args: 0,
20979        };
20980        init
20981    },
20982    {
20983        let mut init = redisCommandArg {
20984            name: 0 as *const libc::c_char,
20985            type_0: ARG_TYPE_STRING,
20986            key_spec_index: 0,
20987            token: 0 as *const libc::c_char,
20988            summary: 0 as *const libc::c_char,
20989            since: 0 as *const libc::c_char,
20990            flags: 0,
20991            deprecated_since: 0 as *const libc::c_char,
20992            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
20993            num_args: 0,
20994        };
20995        init
20996    },
20997];
20998#[no_mangle]
20999pub static mut SENTINEL_CONFIG_set_or_get_set_param_value_Subargs: [redisCommandArg; 3] = [
21000    {
21001        let mut init = redisCommandArg {
21002            name: b"parameter\0" as *const u8 as *const libc::c_char,
21003            type_0: ARG_TYPE_STRING,
21004            key_spec_index: -(1 as libc::c_int),
21005            token: 0 as *const libc::c_char,
21006            summary: 0 as *const libc::c_char,
21007            since: 0 as *const libc::c_char,
21008            flags: 0 as libc::c_int,
21009            deprecated_since: 0 as *const libc::c_char,
21010            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21011            num_args: 0,
21012        };
21013        init
21014    },
21015    {
21016        let mut init = redisCommandArg {
21017            name: b"value\0" as *const u8 as *const libc::c_char,
21018            type_0: ARG_TYPE_STRING,
21019            key_spec_index: -(1 as libc::c_int),
21020            token: 0 as *const libc::c_char,
21021            summary: 0 as *const libc::c_char,
21022            since: 0 as *const libc::c_char,
21023            flags: 0 as libc::c_int,
21024            deprecated_since: 0 as *const libc::c_char,
21025            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21026            num_args: 0,
21027        };
21028        init
21029    },
21030    {
21031        let mut init = redisCommandArg {
21032            name: 0 as *const libc::c_char,
21033            type_0: ARG_TYPE_STRING,
21034            key_spec_index: 0,
21035            token: 0 as *const libc::c_char,
21036            summary: 0 as *const libc::c_char,
21037            since: 0 as *const libc::c_char,
21038            flags: 0,
21039            deprecated_since: 0 as *const libc::c_char,
21040            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21041            num_args: 0,
21042        };
21043        init
21044    },
21045];
21046#[no_mangle]
21047pub static mut SENTINEL_CONFIG_set_or_get_Subargs: [redisCommandArg; 3] = unsafe {
21048    [
21049        {
21050            let mut init = redisCommandArg {
21051                name: b"set_param_value\0" as *const u8 as *const libc::c_char,
21052                type_0: ARG_TYPE_BLOCK,
21053                key_spec_index: -(1 as libc::c_int),
21054                token: b"SET\0" as *const u8 as *const libc::c_char,
21055                summary: 0 as *const libc::c_char,
21056                since: 0 as *const libc::c_char,
21057                flags: (1 as libc::c_int) << 1 as libc::c_int,
21058                deprecated_since: 0 as *const libc::c_char,
21059                subargs: SENTINEL_CONFIG_set_or_get_set_param_value_Subargs.as_ptr()
21060                    as *mut _,
21061                num_args: 0,
21062            };
21063            init
21064        },
21065        {
21066            let mut init = redisCommandArg {
21067                name: b"parameter\0" as *const u8 as *const libc::c_char,
21068                type_0: ARG_TYPE_STRING,
21069                key_spec_index: -(1 as libc::c_int),
21070                token: b"GET\0" as *const u8 as *const libc::c_char,
21071                summary: 0 as *const libc::c_char,
21072                since: 0 as *const libc::c_char,
21073                flags: (1 as libc::c_int) << 1 as libc::c_int,
21074                deprecated_since: 0 as *const libc::c_char,
21075                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21076                num_args: 0,
21077            };
21078            init
21079        },
21080        {
21081            let mut init = redisCommandArg {
21082                name: 0 as *const libc::c_char,
21083                type_0: ARG_TYPE_STRING,
21084                key_spec_index: 0,
21085                token: 0 as *const libc::c_char,
21086                summary: 0 as *const libc::c_char,
21087                since: 0 as *const libc::c_char,
21088                flags: 0,
21089                deprecated_since: 0 as *const libc::c_char,
21090                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21091                num_args: 0,
21092            };
21093            init
21094        },
21095    ]
21096};
21097#[no_mangle]
21098pub static mut SENTINEL_CONFIG_Args: [redisCommandArg; 2] = unsafe {
21099    [
21100        {
21101            let mut init = redisCommandArg {
21102                name: b"set_or_get\0" as *const u8 as *const libc::c_char,
21103                type_0: ARG_TYPE_ONEOF,
21104                key_spec_index: -(1 as libc::c_int),
21105                token: 0 as *const libc::c_char,
21106                summary: 0 as *const libc::c_char,
21107                since: 0 as *const libc::c_char,
21108                flags: 0 as libc::c_int,
21109                deprecated_since: 0 as *const libc::c_char,
21110                subargs: SENTINEL_CONFIG_set_or_get_Subargs.as_ptr() as *mut _,
21111                num_args: 0,
21112            };
21113            init
21114        },
21115        {
21116            let mut init = redisCommandArg {
21117                name: 0 as *const libc::c_char,
21118                type_0: ARG_TYPE_STRING,
21119                key_spec_index: 0,
21120                token: 0 as *const libc::c_char,
21121                summary: 0 as *const libc::c_char,
21122                since: 0 as *const libc::c_char,
21123                flags: 0,
21124                deprecated_since: 0 as *const libc::c_char,
21125                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21126                num_args: 0,
21127            };
21128            init
21129        },
21130    ]
21131};
21132#[no_mangle]
21133pub static mut SENTINEL_DEBUG_parameter_value_Subargs: [redisCommandArg; 3] = [
21134    {
21135        let mut init = redisCommandArg {
21136            name: b"parameter\0" as *const u8 as *const libc::c_char,
21137            type_0: ARG_TYPE_STRING,
21138            key_spec_index: -(1 as libc::c_int),
21139            token: 0 as *const libc::c_char,
21140            summary: 0 as *const libc::c_char,
21141            since: 0 as *const libc::c_char,
21142            flags: 0 as libc::c_int,
21143            deprecated_since: 0 as *const libc::c_char,
21144            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21145            num_args: 0,
21146        };
21147        init
21148    },
21149    {
21150        let mut init = redisCommandArg {
21151            name: b"value\0" as *const u8 as *const libc::c_char,
21152            type_0: ARG_TYPE_STRING,
21153            key_spec_index: -(1 as libc::c_int),
21154            token: 0 as *const libc::c_char,
21155            summary: 0 as *const libc::c_char,
21156            since: 0 as *const libc::c_char,
21157            flags: 0 as libc::c_int,
21158            deprecated_since: 0 as *const libc::c_char,
21159            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21160            num_args: 0,
21161        };
21162        init
21163    },
21164    {
21165        let mut init = redisCommandArg {
21166            name: 0 as *const libc::c_char,
21167            type_0: ARG_TYPE_STRING,
21168            key_spec_index: 0,
21169            token: 0 as *const libc::c_char,
21170            summary: 0 as *const libc::c_char,
21171            since: 0 as *const libc::c_char,
21172            flags: 0,
21173            deprecated_since: 0 as *const libc::c_char,
21174            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21175            num_args: 0,
21176        };
21177        init
21178    },
21179];
21180#[no_mangle]
21181pub static mut SENTINEL_DEBUG_Args: [redisCommandArg; 2] = unsafe {
21182    [
21183        {
21184            let mut init = redisCommandArg {
21185                name: b"parameter_value\0" as *const u8 as *const libc::c_char,
21186                type_0: ARG_TYPE_BLOCK,
21187                key_spec_index: -(1 as libc::c_int),
21188                token: 0 as *const libc::c_char,
21189                summary: 0 as *const libc::c_char,
21190                since: 0 as *const libc::c_char,
21191                flags: (1 as libc::c_int) << 1 as libc::c_int,
21192                deprecated_since: 0 as *const libc::c_char,
21193                subargs: SENTINEL_DEBUG_parameter_value_Subargs.as_ptr() as *mut _,
21194                num_args: 0,
21195            };
21196            init
21197        },
21198        {
21199            let mut init = redisCommandArg {
21200                name: 0 as *const libc::c_char,
21201                type_0: ARG_TYPE_STRING,
21202                key_spec_index: 0,
21203                token: 0 as *const libc::c_char,
21204                summary: 0 as *const libc::c_char,
21205                since: 0 as *const libc::c_char,
21206                flags: 0,
21207                deprecated_since: 0 as *const libc::c_char,
21208                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21209                num_args: 0,
21210            };
21211            init
21212        },
21213    ]
21214};
21215#[no_mangle]
21216pub static mut SENTINEL_FAILOVER_Args: [redisCommandArg; 2] = [
21217    {
21218        let mut init = redisCommandArg {
21219            name: b"master-name\0" as *const u8 as *const libc::c_char,
21220            type_0: ARG_TYPE_STRING,
21221            key_spec_index: -(1 as libc::c_int),
21222            token: 0 as *const libc::c_char,
21223            summary: 0 as *const libc::c_char,
21224            since: 0 as *const libc::c_char,
21225            flags: 0 as libc::c_int,
21226            deprecated_since: 0 as *const libc::c_char,
21227            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21228            num_args: 0,
21229        };
21230        init
21231    },
21232    {
21233        let mut init = redisCommandArg {
21234            name: 0 as *const libc::c_char,
21235            type_0: ARG_TYPE_STRING,
21236            key_spec_index: 0,
21237            token: 0 as *const libc::c_char,
21238            summary: 0 as *const libc::c_char,
21239            since: 0 as *const libc::c_char,
21240            flags: 0,
21241            deprecated_since: 0 as *const libc::c_char,
21242            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21243            num_args: 0,
21244        };
21245        init
21246    },
21247];
21248#[no_mangle]
21249pub static mut SENTINEL_GET_MASTER_ADDR_BY_NAME_Args: [redisCommandArg; 2] = [
21250    {
21251        let mut init = redisCommandArg {
21252            name: b"master-name\0" as *const u8 as *const libc::c_char,
21253            type_0: ARG_TYPE_STRING,
21254            key_spec_index: -(1 as libc::c_int),
21255            token: 0 as *const libc::c_char,
21256            summary: 0 as *const libc::c_char,
21257            since: 0 as *const libc::c_char,
21258            flags: 0 as libc::c_int,
21259            deprecated_since: 0 as *const libc::c_char,
21260            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21261            num_args: 0,
21262        };
21263        init
21264    },
21265    {
21266        let mut init = redisCommandArg {
21267            name: 0 as *const libc::c_char,
21268            type_0: ARG_TYPE_STRING,
21269            key_spec_index: 0,
21270            token: 0 as *const libc::c_char,
21271            summary: 0 as *const libc::c_char,
21272            since: 0 as *const libc::c_char,
21273            flags: 0,
21274            deprecated_since: 0 as *const libc::c_char,
21275            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21276            num_args: 0,
21277        };
21278        init
21279    },
21280];
21281#[no_mangle]
21282pub static mut SENTINEL_INFO_CACHE_Args: [redisCommandArg; 2] = [
21283    {
21284        let mut init = redisCommandArg {
21285            name: b"nodename\0" as *const u8 as *const libc::c_char,
21286            type_0: ARG_TYPE_STRING,
21287            key_spec_index: -(1 as libc::c_int),
21288            token: 0 as *const libc::c_char,
21289            summary: 0 as *const libc::c_char,
21290            since: 0 as *const libc::c_char,
21291            flags: (1 as libc::c_int) << 1 as libc::c_int,
21292            deprecated_since: 0 as *const libc::c_char,
21293            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21294            num_args: 0,
21295        };
21296        init
21297    },
21298    {
21299        let mut init = redisCommandArg {
21300            name: 0 as *const libc::c_char,
21301            type_0: ARG_TYPE_STRING,
21302            key_spec_index: 0,
21303            token: 0 as *const libc::c_char,
21304            summary: 0 as *const libc::c_char,
21305            since: 0 as *const libc::c_char,
21306            flags: 0,
21307            deprecated_since: 0 as *const libc::c_char,
21308            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21309            num_args: 0,
21310        };
21311        init
21312    },
21313];
21314#[no_mangle]
21315pub static mut SENTINEL_IS_MASTER_DOWN_BY_ADDR_Args: [redisCommandArg; 5] = [
21316    {
21317        let mut init = redisCommandArg {
21318            name: b"ip\0" as *const u8 as *const libc::c_char,
21319            type_0: ARG_TYPE_STRING,
21320            key_spec_index: -(1 as libc::c_int),
21321            token: 0 as *const libc::c_char,
21322            summary: 0 as *const libc::c_char,
21323            since: 0 as *const libc::c_char,
21324            flags: 0 as libc::c_int,
21325            deprecated_since: 0 as *const libc::c_char,
21326            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21327            num_args: 0,
21328        };
21329        init
21330    },
21331    {
21332        let mut init = redisCommandArg {
21333            name: b"port\0" as *const u8 as *const libc::c_char,
21334            type_0: ARG_TYPE_INTEGER,
21335            key_spec_index: -(1 as libc::c_int),
21336            token: 0 as *const libc::c_char,
21337            summary: 0 as *const libc::c_char,
21338            since: 0 as *const libc::c_char,
21339            flags: 0 as libc::c_int,
21340            deprecated_since: 0 as *const libc::c_char,
21341            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21342            num_args: 0,
21343        };
21344        init
21345    },
21346    {
21347        let mut init = redisCommandArg {
21348            name: b"current-epoch\0" as *const u8 as *const libc::c_char,
21349            type_0: ARG_TYPE_INTEGER,
21350            key_spec_index: -(1 as libc::c_int),
21351            token: 0 as *const libc::c_char,
21352            summary: 0 as *const libc::c_char,
21353            since: 0 as *const libc::c_char,
21354            flags: 0 as libc::c_int,
21355            deprecated_since: 0 as *const libc::c_char,
21356            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21357            num_args: 0,
21358        };
21359        init
21360    },
21361    {
21362        let mut init = redisCommandArg {
21363            name: b"runid\0" as *const u8 as *const libc::c_char,
21364            type_0: ARG_TYPE_STRING,
21365            key_spec_index: -(1 as libc::c_int),
21366            token: 0 as *const libc::c_char,
21367            summary: 0 as *const libc::c_char,
21368            since: 0 as *const libc::c_char,
21369            flags: 0 as libc::c_int,
21370            deprecated_since: 0 as *const libc::c_char,
21371            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21372            num_args: 0,
21373        };
21374        init
21375    },
21376    {
21377        let mut init = redisCommandArg {
21378            name: 0 as *const libc::c_char,
21379            type_0: ARG_TYPE_STRING,
21380            key_spec_index: 0,
21381            token: 0 as *const libc::c_char,
21382            summary: 0 as *const libc::c_char,
21383            since: 0 as *const libc::c_char,
21384            flags: 0,
21385            deprecated_since: 0 as *const libc::c_char,
21386            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21387            num_args: 0,
21388        };
21389        init
21390    },
21391];
21392#[no_mangle]
21393pub static mut SENTINEL_MASTER_Args: [redisCommandArg; 2] = [
21394    {
21395        let mut init = redisCommandArg {
21396            name: b"master-name\0" as *const u8 as *const libc::c_char,
21397            type_0: ARG_TYPE_STRING,
21398            key_spec_index: -(1 as libc::c_int),
21399            token: 0 as *const libc::c_char,
21400            summary: 0 as *const libc::c_char,
21401            since: 0 as *const libc::c_char,
21402            flags: 0 as libc::c_int,
21403            deprecated_since: 0 as *const libc::c_char,
21404            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21405            num_args: 0,
21406        };
21407        init
21408    },
21409    {
21410        let mut init = redisCommandArg {
21411            name: 0 as *const libc::c_char,
21412            type_0: ARG_TYPE_STRING,
21413            key_spec_index: 0,
21414            token: 0 as *const libc::c_char,
21415            summary: 0 as *const libc::c_char,
21416            since: 0 as *const libc::c_char,
21417            flags: 0,
21418            deprecated_since: 0 as *const libc::c_char,
21419            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21420            num_args: 0,
21421        };
21422        init
21423    },
21424];
21425#[no_mangle]
21426pub static mut SENTINEL_MONITOR_Args: [redisCommandArg; 5] = [
21427    {
21428        let mut init = redisCommandArg {
21429            name: b"name\0" as *const u8 as *const libc::c_char,
21430            type_0: ARG_TYPE_STRING,
21431            key_spec_index: -(1 as libc::c_int),
21432            token: 0 as *const libc::c_char,
21433            summary: 0 as *const libc::c_char,
21434            since: 0 as *const libc::c_char,
21435            flags: 0 as libc::c_int,
21436            deprecated_since: 0 as *const libc::c_char,
21437            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21438            num_args: 0,
21439        };
21440        init
21441    },
21442    {
21443        let mut init = redisCommandArg {
21444            name: b"ip\0" as *const u8 as *const libc::c_char,
21445            type_0: ARG_TYPE_STRING,
21446            key_spec_index: -(1 as libc::c_int),
21447            token: 0 as *const libc::c_char,
21448            summary: 0 as *const libc::c_char,
21449            since: 0 as *const libc::c_char,
21450            flags: 0 as libc::c_int,
21451            deprecated_since: 0 as *const libc::c_char,
21452            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21453            num_args: 0,
21454        };
21455        init
21456    },
21457    {
21458        let mut init = redisCommandArg {
21459            name: b"port\0" as *const u8 as *const libc::c_char,
21460            type_0: ARG_TYPE_INTEGER,
21461            key_spec_index: -(1 as libc::c_int),
21462            token: 0 as *const libc::c_char,
21463            summary: 0 as *const libc::c_char,
21464            since: 0 as *const libc::c_char,
21465            flags: 0 as libc::c_int,
21466            deprecated_since: 0 as *const libc::c_char,
21467            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21468            num_args: 0,
21469        };
21470        init
21471    },
21472    {
21473        let mut init = redisCommandArg {
21474            name: b"quorum\0" as *const u8 as *const libc::c_char,
21475            type_0: ARG_TYPE_INTEGER,
21476            key_spec_index: -(1 as libc::c_int),
21477            token: 0 as *const libc::c_char,
21478            summary: 0 as *const libc::c_char,
21479            since: 0 as *const libc::c_char,
21480            flags: 0 as libc::c_int,
21481            deprecated_since: 0 as *const libc::c_char,
21482            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21483            num_args: 0,
21484        };
21485        init
21486    },
21487    {
21488        let mut init = redisCommandArg {
21489            name: 0 as *const libc::c_char,
21490            type_0: ARG_TYPE_STRING,
21491            key_spec_index: 0,
21492            token: 0 as *const libc::c_char,
21493            summary: 0 as *const libc::c_char,
21494            since: 0 as *const libc::c_char,
21495            flags: 0,
21496            deprecated_since: 0 as *const libc::c_char,
21497            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21498            num_args: 0,
21499        };
21500        init
21501    },
21502];
21503#[no_mangle]
21504pub static mut SENTINEL_REMOVE_Args: [redisCommandArg; 2] = [
21505    {
21506        let mut init = redisCommandArg {
21507            name: b"master-name\0" as *const u8 as *const libc::c_char,
21508            type_0: ARG_TYPE_STRING,
21509            key_spec_index: -(1 as libc::c_int),
21510            token: 0 as *const libc::c_char,
21511            summary: 0 as *const libc::c_char,
21512            since: 0 as *const libc::c_char,
21513            flags: 0 as libc::c_int,
21514            deprecated_since: 0 as *const libc::c_char,
21515            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21516            num_args: 0,
21517        };
21518        init
21519    },
21520    {
21521        let mut init = redisCommandArg {
21522            name: 0 as *const libc::c_char,
21523            type_0: ARG_TYPE_STRING,
21524            key_spec_index: 0,
21525            token: 0 as *const libc::c_char,
21526            summary: 0 as *const libc::c_char,
21527            since: 0 as *const libc::c_char,
21528            flags: 0,
21529            deprecated_since: 0 as *const libc::c_char,
21530            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21531            num_args: 0,
21532        };
21533        init
21534    },
21535];
21536#[no_mangle]
21537pub static mut SENTINEL_REPLICAS_Args: [redisCommandArg; 2] = [
21538    {
21539        let mut init = redisCommandArg {
21540            name: b"master-name\0" as *const u8 as *const libc::c_char,
21541            type_0: ARG_TYPE_STRING,
21542            key_spec_index: -(1 as libc::c_int),
21543            token: 0 as *const libc::c_char,
21544            summary: 0 as *const libc::c_char,
21545            since: 0 as *const libc::c_char,
21546            flags: 0 as libc::c_int,
21547            deprecated_since: 0 as *const libc::c_char,
21548            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21549            num_args: 0,
21550        };
21551        init
21552    },
21553    {
21554        let mut init = redisCommandArg {
21555            name: 0 as *const libc::c_char,
21556            type_0: ARG_TYPE_STRING,
21557            key_spec_index: 0,
21558            token: 0 as *const libc::c_char,
21559            summary: 0 as *const libc::c_char,
21560            since: 0 as *const libc::c_char,
21561            flags: 0,
21562            deprecated_since: 0 as *const libc::c_char,
21563            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21564            num_args: 0,
21565        };
21566        init
21567    },
21568];
21569#[no_mangle]
21570pub static mut SENTINEL_RESET_Args: [redisCommandArg; 2] = [
21571    {
21572        let mut init = redisCommandArg {
21573            name: b"pattern\0" as *const u8 as *const libc::c_char,
21574            type_0: ARG_TYPE_PATTERN,
21575            key_spec_index: -(1 as libc::c_int),
21576            token: 0 as *const libc::c_char,
21577            summary: 0 as *const libc::c_char,
21578            since: 0 as *const libc::c_char,
21579            flags: 0 as libc::c_int,
21580            deprecated_since: 0 as *const libc::c_char,
21581            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21582            num_args: 0,
21583        };
21584        init
21585    },
21586    {
21587        let mut init = redisCommandArg {
21588            name: 0 as *const libc::c_char,
21589            type_0: ARG_TYPE_STRING,
21590            key_spec_index: 0,
21591            token: 0 as *const libc::c_char,
21592            summary: 0 as *const libc::c_char,
21593            since: 0 as *const libc::c_char,
21594            flags: 0,
21595            deprecated_since: 0 as *const libc::c_char,
21596            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21597            num_args: 0,
21598        };
21599        init
21600    },
21601];
21602#[no_mangle]
21603pub static mut SENTINEL_SENTINELS_Args: [redisCommandArg; 2] = [
21604    {
21605        let mut init = redisCommandArg {
21606            name: b"master-name\0" as *const u8 as *const libc::c_char,
21607            type_0: ARG_TYPE_STRING,
21608            key_spec_index: -(1 as libc::c_int),
21609            token: 0 as *const libc::c_char,
21610            summary: 0 as *const libc::c_char,
21611            since: 0 as *const libc::c_char,
21612            flags: 0 as libc::c_int,
21613            deprecated_since: 0 as *const libc::c_char,
21614            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21615            num_args: 0,
21616        };
21617        init
21618    },
21619    {
21620        let mut init = redisCommandArg {
21621            name: 0 as *const libc::c_char,
21622            type_0: ARG_TYPE_STRING,
21623            key_spec_index: 0,
21624            token: 0 as *const libc::c_char,
21625            summary: 0 as *const libc::c_char,
21626            since: 0 as *const libc::c_char,
21627            flags: 0,
21628            deprecated_since: 0 as *const libc::c_char,
21629            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21630            num_args: 0,
21631        };
21632        init
21633    },
21634];
21635#[no_mangle]
21636pub static mut SENTINEL_SET_option_value_Subargs: [redisCommandArg; 3] = [
21637    {
21638        let mut init = redisCommandArg {
21639            name: b"option\0" as *const u8 as *const libc::c_char,
21640            type_0: ARG_TYPE_STRING,
21641            key_spec_index: -(1 as libc::c_int),
21642            token: 0 as *const libc::c_char,
21643            summary: 0 as *const libc::c_char,
21644            since: 0 as *const libc::c_char,
21645            flags: 0 as libc::c_int,
21646            deprecated_since: 0 as *const libc::c_char,
21647            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21648            num_args: 0,
21649        };
21650        init
21651    },
21652    {
21653        let mut init = redisCommandArg {
21654            name: b"value\0" as *const u8 as *const libc::c_char,
21655            type_0: ARG_TYPE_STRING,
21656            key_spec_index: -(1 as libc::c_int),
21657            token: 0 as *const libc::c_char,
21658            summary: 0 as *const libc::c_char,
21659            since: 0 as *const libc::c_char,
21660            flags: 0 as libc::c_int,
21661            deprecated_since: 0 as *const libc::c_char,
21662            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21663            num_args: 0,
21664        };
21665        init
21666    },
21667    {
21668        let mut init = redisCommandArg {
21669            name: 0 as *const libc::c_char,
21670            type_0: ARG_TYPE_STRING,
21671            key_spec_index: 0,
21672            token: 0 as *const libc::c_char,
21673            summary: 0 as *const libc::c_char,
21674            since: 0 as *const libc::c_char,
21675            flags: 0,
21676            deprecated_since: 0 as *const libc::c_char,
21677            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21678            num_args: 0,
21679        };
21680        init
21681    },
21682];
21683#[no_mangle]
21684pub static mut SENTINEL_SET_Args: [redisCommandArg; 3] = unsafe {
21685    [
21686        {
21687            let mut init = redisCommandArg {
21688                name: b"master-name\0" as *const u8 as *const libc::c_char,
21689                type_0: ARG_TYPE_STRING,
21690                key_spec_index: -(1 as libc::c_int),
21691                token: 0 as *const libc::c_char,
21692                summary: 0 as *const libc::c_char,
21693                since: 0 as *const libc::c_char,
21694                flags: 0 as libc::c_int,
21695                deprecated_since: 0 as *const libc::c_char,
21696                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21697                num_args: 0,
21698            };
21699            init
21700        },
21701        {
21702            let mut init = redisCommandArg {
21703                name: b"option_value\0" as *const u8 as *const libc::c_char,
21704                type_0: ARG_TYPE_BLOCK,
21705                key_spec_index: -(1 as libc::c_int),
21706                token: 0 as *const libc::c_char,
21707                summary: 0 as *const libc::c_char,
21708                since: 0 as *const libc::c_char,
21709                flags: (1 as libc::c_int) << 1 as libc::c_int,
21710                deprecated_since: 0 as *const libc::c_char,
21711                subargs: SENTINEL_SET_option_value_Subargs.as_ptr() as *mut _,
21712                num_args: 0,
21713            };
21714            init
21715        },
21716        {
21717            let mut init = redisCommandArg {
21718                name: 0 as *const libc::c_char,
21719                type_0: ARG_TYPE_STRING,
21720                key_spec_index: 0,
21721                token: 0 as *const libc::c_char,
21722                summary: 0 as *const libc::c_char,
21723                since: 0 as *const libc::c_char,
21724                flags: 0,
21725                deprecated_since: 0 as *const libc::c_char,
21726                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21727                num_args: 0,
21728            };
21729            init
21730        },
21731    ]
21732};
21733#[no_mangle]
21734pub static mut SENTINEL_SIMULATE_FAILURE_mode_Subargs: [redisCommandArg; 4] = [
21735    {
21736        let mut init = redisCommandArg {
21737            name: b"crash-after-election\0" as *const u8 as *const libc::c_char,
21738            type_0: ARG_TYPE_PURE_TOKEN,
21739            key_spec_index: -(1 as libc::c_int),
21740            token: 0 as *const libc::c_char,
21741            summary: 0 as *const libc::c_char,
21742            since: 0 as *const libc::c_char,
21743            flags: 0 as libc::c_int,
21744            deprecated_since: 0 as *const libc::c_char,
21745            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21746            num_args: 0,
21747        };
21748        init
21749    },
21750    {
21751        let mut init = redisCommandArg {
21752            name: b"crash-after-promotion\0" as *const u8 as *const libc::c_char,
21753            type_0: ARG_TYPE_PURE_TOKEN,
21754            key_spec_index: -(1 as libc::c_int),
21755            token: 0 as *const libc::c_char,
21756            summary: 0 as *const libc::c_char,
21757            since: 0 as *const libc::c_char,
21758            flags: 0 as libc::c_int,
21759            deprecated_since: 0 as *const libc::c_char,
21760            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21761            num_args: 0,
21762        };
21763        init
21764    },
21765    {
21766        let mut init = redisCommandArg {
21767            name: b"help\0" as *const u8 as *const libc::c_char,
21768            type_0: ARG_TYPE_PURE_TOKEN,
21769            key_spec_index: -(1 as libc::c_int),
21770            token: 0 as *const libc::c_char,
21771            summary: 0 as *const libc::c_char,
21772            since: 0 as *const libc::c_char,
21773            flags: 0 as libc::c_int,
21774            deprecated_since: 0 as *const libc::c_char,
21775            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21776            num_args: 0,
21777        };
21778        init
21779    },
21780    {
21781        let mut init = redisCommandArg {
21782            name: 0 as *const libc::c_char,
21783            type_0: ARG_TYPE_STRING,
21784            key_spec_index: 0,
21785            token: 0 as *const libc::c_char,
21786            summary: 0 as *const libc::c_char,
21787            since: 0 as *const libc::c_char,
21788            flags: 0,
21789            deprecated_since: 0 as *const libc::c_char,
21790            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21791            num_args: 0,
21792        };
21793        init
21794    },
21795];
21796#[no_mangle]
21797pub static mut SENTINEL_SIMULATE_FAILURE_Args: [redisCommandArg; 2] = unsafe {
21798    [
21799        {
21800            let mut init = redisCommandArg {
21801                name: b"mode\0" as *const u8 as *const libc::c_char,
21802                type_0: ARG_TYPE_ONEOF,
21803                key_spec_index: -(1 as libc::c_int),
21804                token: 0 as *const libc::c_char,
21805                summary: 0 as *const libc::c_char,
21806                since: 0 as *const libc::c_char,
21807                flags: (1 as libc::c_int) << 0 as libc::c_int
21808                    | (1 as libc::c_int) << 1 as libc::c_int,
21809                deprecated_since: 0 as *const libc::c_char,
21810                subargs: SENTINEL_SIMULATE_FAILURE_mode_Subargs.as_ptr() as *mut _,
21811                num_args: 0,
21812            };
21813            init
21814        },
21815        {
21816            let mut init = redisCommandArg {
21817                name: 0 as *const libc::c_char,
21818                type_0: ARG_TYPE_STRING,
21819                key_spec_index: 0,
21820                token: 0 as *const libc::c_char,
21821                summary: 0 as *const libc::c_char,
21822                since: 0 as *const libc::c_char,
21823                flags: 0,
21824                deprecated_since: 0 as *const libc::c_char,
21825                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21826                num_args: 0,
21827            };
21828            init
21829        },
21830    ]
21831};
21832#[no_mangle]
21833pub static mut SENTINEL_SLAVES_Args: [redisCommandArg; 2] = [
21834    {
21835        let mut init = redisCommandArg {
21836            name: b"master-name\0" as *const u8 as *const libc::c_char,
21837            type_0: ARG_TYPE_STRING,
21838            key_spec_index: -(1 as libc::c_int),
21839            token: 0 as *const libc::c_char,
21840            summary: 0 as *const libc::c_char,
21841            since: 0 as *const libc::c_char,
21842            flags: 0 as libc::c_int,
21843            deprecated_since: 0 as *const libc::c_char,
21844            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21845            num_args: 0,
21846        };
21847        init
21848    },
21849    {
21850        let mut init = redisCommandArg {
21851            name: 0 as *const libc::c_char,
21852            type_0: ARG_TYPE_STRING,
21853            key_spec_index: 0,
21854            token: 0 as *const libc::c_char,
21855            summary: 0 as *const libc::c_char,
21856            since: 0 as *const libc::c_char,
21857            flags: 0,
21858            deprecated_since: 0 as *const libc::c_char,
21859            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
21860            num_args: 0,
21861        };
21862        init
21863    },
21864];
21865#[no_mangle]
21866pub static mut SENTINEL_Subcommands: [redisCommand; 22] = unsafe {
21867    [
21868        {
21869            let mut init = redisCommand {
21870                declared_name: b"ckquorum\0" as *const u8 as *const libc::c_char,
21871                summary: b"Check for a Sentinel quorum\0" as *const u8
21872                    as *const libc::c_char,
21873                complexity: 0 as *const libc::c_char,
21874                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
21875                doc_flags: 0 as libc::c_int,
21876                replaced_by: 0 as *const libc::c_char,
21877                deprecated_since: 0 as *const libc::c_char,
21878                group: COMMAND_GROUP_SENTINEL,
21879                history: 0 as *const commandHistory as *mut commandHistory,
21880                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
21881                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
21882                arity: 3 as libc::c_int,
21883                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
21884                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
21885                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
21886                acl_categories: 0 as libc::c_int as uint64_t,
21887                key_specs_static: [keySpec {
21888                    notes: 0 as *const libc::c_char,
21889                    flags: 0,
21890                    begin_search_type: KSPEC_BS_INVALID,
21891                    bs: C2RustUnnamed_3 {
21892                        index: C2RustUnnamed_5 { pos: 0 },
21893                    },
21894                    find_keys_type: KSPEC_FK_INVALID,
21895                    fk: C2RustUnnamed_0 {
21896                        range: C2RustUnnamed_2 {
21897                            lastkey: 0,
21898                            keystep: 0,
21899                            limit: 0,
21900                        },
21901                    },
21902                }; 4],
21903                getkeys_proc: None,
21904                subcommands: 0 as *const redisCommand as *mut redisCommand,
21905                args: SENTINEL_CKQUORUM_Args.as_ptr() as *mut _,
21906                microseconds: 0,
21907                calls: 0,
21908                rejected_calls: 0,
21909                failed_calls: 0,
21910                id: 0,
21911                fullname: 0 as *const libc::c_char as *mut libc::c_char,
21912                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
21913                key_specs: 0 as *const keySpec as *mut keySpec,
21914                legacy_range_key_spec: keySpec {
21915                    notes: 0 as *const libc::c_char,
21916                    flags: 0,
21917                    begin_search_type: KSPEC_BS_INVALID,
21918                    bs: C2RustUnnamed_3 {
21919                        index: C2RustUnnamed_5 { pos: 0 },
21920                    },
21921                    find_keys_type: KSPEC_FK_INVALID,
21922                    fk: C2RustUnnamed_0 {
21923                        range: C2RustUnnamed_2 {
21924                            lastkey: 0,
21925                            keystep: 0,
21926                            limit: 0,
21927                        },
21928                    },
21929                },
21930                num_args: 0,
21931                num_history: 0,
21932                num_tips: 0,
21933                key_specs_num: 0,
21934                key_specs_max: 0,
21935                subcommands_dict: 0 as *const dict as *mut dict,
21936                parent: 0 as *const redisCommand as *mut redisCommand,
21937                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
21938            };
21939            init
21940        },
21941        {
21942            let mut init = redisCommand {
21943                declared_name: b"config\0" as *const u8 as *const libc::c_char,
21944                summary: b"Configure Sentinel\0" as *const u8 as *const libc::c_char,
21945                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
21946                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
21947                doc_flags: 0 as libc::c_int,
21948                replaced_by: 0 as *const libc::c_char,
21949                deprecated_since: 0 as *const libc::c_char,
21950                group: COMMAND_GROUP_SENTINEL,
21951                history: 0 as *const commandHistory as *mut commandHistory,
21952                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
21953                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
21954                arity: -(3 as libc::c_int),
21955                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
21956                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
21957                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
21958                acl_categories: 0 as libc::c_int as uint64_t,
21959                key_specs_static: [keySpec {
21960                    notes: 0 as *const libc::c_char,
21961                    flags: 0,
21962                    begin_search_type: KSPEC_BS_INVALID,
21963                    bs: C2RustUnnamed_3 {
21964                        index: C2RustUnnamed_5 { pos: 0 },
21965                    },
21966                    find_keys_type: KSPEC_FK_INVALID,
21967                    fk: C2RustUnnamed_0 {
21968                        range: C2RustUnnamed_2 {
21969                            lastkey: 0,
21970                            keystep: 0,
21971                            limit: 0,
21972                        },
21973                    },
21974                }; 4],
21975                getkeys_proc: None,
21976                subcommands: 0 as *const redisCommand as *mut redisCommand,
21977                args: SENTINEL_CONFIG_Args.as_ptr() as *mut _,
21978                microseconds: 0,
21979                calls: 0,
21980                rejected_calls: 0,
21981                failed_calls: 0,
21982                id: 0,
21983                fullname: 0 as *const libc::c_char as *mut libc::c_char,
21984                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
21985                key_specs: 0 as *const keySpec as *mut keySpec,
21986                legacy_range_key_spec: keySpec {
21987                    notes: 0 as *const libc::c_char,
21988                    flags: 0,
21989                    begin_search_type: KSPEC_BS_INVALID,
21990                    bs: C2RustUnnamed_3 {
21991                        index: C2RustUnnamed_5 { pos: 0 },
21992                    },
21993                    find_keys_type: KSPEC_FK_INVALID,
21994                    fk: C2RustUnnamed_0 {
21995                        range: C2RustUnnamed_2 {
21996                            lastkey: 0,
21997                            keystep: 0,
21998                            limit: 0,
21999                        },
22000                    },
22001                },
22002                num_args: 0,
22003                num_history: 0,
22004                num_tips: 0,
22005                key_specs_num: 0,
22006                key_specs_max: 0,
22007                subcommands_dict: 0 as *const dict as *mut dict,
22008                parent: 0 as *const redisCommand as *mut redisCommand,
22009                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22010            };
22011            init
22012        },
22013        {
22014            let mut init = redisCommand {
22015                declared_name: b"debug\0" as *const u8 as *const libc::c_char,
22016                summary: b"List or update the current configurable parameters\0"
22017                    as *const u8 as *const libc::c_char,
22018                complexity: b"O(N) where N is the number of configurable parameters\0"
22019                    as *const u8 as *const libc::c_char,
22020                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
22021                doc_flags: 0 as libc::c_int,
22022                replaced_by: 0 as *const libc::c_char,
22023                deprecated_since: 0 as *const libc::c_char,
22024                group: COMMAND_GROUP_SENTINEL,
22025                history: 0 as *const commandHistory as *mut commandHistory,
22026                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22027                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22028                arity: -(2 as libc::c_int),
22029                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22030                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22031                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22032                acl_categories: 0 as libc::c_int as uint64_t,
22033                key_specs_static: [keySpec {
22034                    notes: 0 as *const libc::c_char,
22035                    flags: 0,
22036                    begin_search_type: KSPEC_BS_INVALID,
22037                    bs: C2RustUnnamed_3 {
22038                        index: C2RustUnnamed_5 { pos: 0 },
22039                    },
22040                    find_keys_type: KSPEC_FK_INVALID,
22041                    fk: C2RustUnnamed_0 {
22042                        range: C2RustUnnamed_2 {
22043                            lastkey: 0,
22044                            keystep: 0,
22045                            limit: 0,
22046                        },
22047                    },
22048                }; 4],
22049                getkeys_proc: None,
22050                subcommands: 0 as *const redisCommand as *mut redisCommand,
22051                args: SENTINEL_DEBUG_Args.as_ptr() as *mut _,
22052                microseconds: 0,
22053                calls: 0,
22054                rejected_calls: 0,
22055                failed_calls: 0,
22056                id: 0,
22057                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22058                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22059                key_specs: 0 as *const keySpec as *mut keySpec,
22060                legacy_range_key_spec: keySpec {
22061                    notes: 0 as *const libc::c_char,
22062                    flags: 0,
22063                    begin_search_type: KSPEC_BS_INVALID,
22064                    bs: C2RustUnnamed_3 {
22065                        index: C2RustUnnamed_5 { pos: 0 },
22066                    },
22067                    find_keys_type: KSPEC_FK_INVALID,
22068                    fk: C2RustUnnamed_0 {
22069                        range: C2RustUnnamed_2 {
22070                            lastkey: 0,
22071                            keystep: 0,
22072                            limit: 0,
22073                        },
22074                    },
22075                },
22076                num_args: 0,
22077                num_history: 0,
22078                num_tips: 0,
22079                key_specs_num: 0,
22080                key_specs_max: 0,
22081                subcommands_dict: 0 as *const dict as *mut dict,
22082                parent: 0 as *const redisCommand as *mut redisCommand,
22083                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22084            };
22085            init
22086        },
22087        {
22088            let mut init = redisCommand {
22089                declared_name: b"failover\0" as *const u8 as *const libc::c_char,
22090                summary: b"Force a failover\0" as *const u8 as *const libc::c_char,
22091                complexity: 0 as *const libc::c_char,
22092                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22093                doc_flags: 0 as libc::c_int,
22094                replaced_by: 0 as *const libc::c_char,
22095                deprecated_since: 0 as *const libc::c_char,
22096                group: COMMAND_GROUP_SENTINEL,
22097                history: 0 as *const commandHistory as *mut commandHistory,
22098                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22099                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22100                arity: 3 as libc::c_int,
22101                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22102                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22103                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22104                acl_categories: 0 as libc::c_int as uint64_t,
22105                key_specs_static: [keySpec {
22106                    notes: 0 as *const libc::c_char,
22107                    flags: 0,
22108                    begin_search_type: KSPEC_BS_INVALID,
22109                    bs: C2RustUnnamed_3 {
22110                        index: C2RustUnnamed_5 { pos: 0 },
22111                    },
22112                    find_keys_type: KSPEC_FK_INVALID,
22113                    fk: C2RustUnnamed_0 {
22114                        range: C2RustUnnamed_2 {
22115                            lastkey: 0,
22116                            keystep: 0,
22117                            limit: 0,
22118                        },
22119                    },
22120                }; 4],
22121                getkeys_proc: None,
22122                subcommands: 0 as *const redisCommand as *mut redisCommand,
22123                args: SENTINEL_FAILOVER_Args.as_ptr() as *mut _,
22124                microseconds: 0,
22125                calls: 0,
22126                rejected_calls: 0,
22127                failed_calls: 0,
22128                id: 0,
22129                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22130                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22131                key_specs: 0 as *const keySpec as *mut keySpec,
22132                legacy_range_key_spec: keySpec {
22133                    notes: 0 as *const libc::c_char,
22134                    flags: 0,
22135                    begin_search_type: KSPEC_BS_INVALID,
22136                    bs: C2RustUnnamed_3 {
22137                        index: C2RustUnnamed_5 { pos: 0 },
22138                    },
22139                    find_keys_type: KSPEC_FK_INVALID,
22140                    fk: C2RustUnnamed_0 {
22141                        range: C2RustUnnamed_2 {
22142                            lastkey: 0,
22143                            keystep: 0,
22144                            limit: 0,
22145                        },
22146                    },
22147                },
22148                num_args: 0,
22149                num_history: 0,
22150                num_tips: 0,
22151                key_specs_num: 0,
22152                key_specs_max: 0,
22153                subcommands_dict: 0 as *const dict as *mut dict,
22154                parent: 0 as *const redisCommand as *mut redisCommand,
22155                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22156            };
22157            init
22158        },
22159        {
22160            let mut init = redisCommand {
22161                declared_name: b"flushconfig\0" as *const u8 as *const libc::c_char,
22162                summary: b"Rewrite configuration file\0" as *const u8
22163                    as *const libc::c_char,
22164                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22165                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22166                doc_flags: 0 as libc::c_int,
22167                replaced_by: 0 as *const libc::c_char,
22168                deprecated_since: 0 as *const libc::c_char,
22169                group: COMMAND_GROUP_SENTINEL,
22170                history: 0 as *const commandHistory as *mut commandHistory,
22171                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22172                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22173                arity: 2 as libc::c_int,
22174                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22175                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22176                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22177                acl_categories: 0 as libc::c_int as uint64_t,
22178                key_specs_static: [keySpec {
22179                    notes: 0 as *const libc::c_char,
22180                    flags: 0,
22181                    begin_search_type: KSPEC_BS_INVALID,
22182                    bs: C2RustUnnamed_3 {
22183                        index: C2RustUnnamed_5 { pos: 0 },
22184                    },
22185                    find_keys_type: KSPEC_FK_INVALID,
22186                    fk: C2RustUnnamed_0 {
22187                        range: C2RustUnnamed_2 {
22188                            lastkey: 0,
22189                            keystep: 0,
22190                            limit: 0,
22191                        },
22192                    },
22193                }; 4],
22194                getkeys_proc: None,
22195                subcommands: 0 as *const redisCommand as *mut redisCommand,
22196                args: 0 as *const redisCommandArg as *mut redisCommandArg,
22197                microseconds: 0,
22198                calls: 0,
22199                rejected_calls: 0,
22200                failed_calls: 0,
22201                id: 0,
22202                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22203                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22204                key_specs: 0 as *const keySpec as *mut keySpec,
22205                legacy_range_key_spec: keySpec {
22206                    notes: 0 as *const libc::c_char,
22207                    flags: 0,
22208                    begin_search_type: KSPEC_BS_INVALID,
22209                    bs: C2RustUnnamed_3 {
22210                        index: C2RustUnnamed_5 { pos: 0 },
22211                    },
22212                    find_keys_type: KSPEC_FK_INVALID,
22213                    fk: C2RustUnnamed_0 {
22214                        range: C2RustUnnamed_2 {
22215                            lastkey: 0,
22216                            keystep: 0,
22217                            limit: 0,
22218                        },
22219                    },
22220                },
22221                num_args: 0,
22222                num_history: 0,
22223                num_tips: 0,
22224                key_specs_num: 0,
22225                key_specs_max: 0,
22226                subcommands_dict: 0 as *const dict as *mut dict,
22227                parent: 0 as *const redisCommand as *mut redisCommand,
22228                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22229            };
22230            init
22231        },
22232        {
22233            let mut init = redisCommand {
22234                declared_name: b"get-master-addr-by-name\0" as *const u8
22235                    as *const libc::c_char,
22236                summary: b"Get port and address of a master\0" as *const u8
22237                    as *const libc::c_char,
22238                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22239                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22240                doc_flags: 0 as libc::c_int,
22241                replaced_by: 0 as *const libc::c_char,
22242                deprecated_since: 0 as *const libc::c_char,
22243                group: COMMAND_GROUP_SENTINEL,
22244                history: 0 as *const commandHistory as *mut commandHistory,
22245                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22246                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22247                arity: 3 as libc::c_int,
22248                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22249                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22250                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22251                acl_categories: 0 as libc::c_int as uint64_t,
22252                key_specs_static: [keySpec {
22253                    notes: 0 as *const libc::c_char,
22254                    flags: 0,
22255                    begin_search_type: KSPEC_BS_INVALID,
22256                    bs: C2RustUnnamed_3 {
22257                        index: C2RustUnnamed_5 { pos: 0 },
22258                    },
22259                    find_keys_type: KSPEC_FK_INVALID,
22260                    fk: C2RustUnnamed_0 {
22261                        range: C2RustUnnamed_2 {
22262                            lastkey: 0,
22263                            keystep: 0,
22264                            limit: 0,
22265                        },
22266                    },
22267                }; 4],
22268                getkeys_proc: None,
22269                subcommands: 0 as *const redisCommand as *mut redisCommand,
22270                args: SENTINEL_GET_MASTER_ADDR_BY_NAME_Args.as_ptr() as *mut _,
22271                microseconds: 0,
22272                calls: 0,
22273                rejected_calls: 0,
22274                failed_calls: 0,
22275                id: 0,
22276                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22277                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22278                key_specs: 0 as *const keySpec as *mut keySpec,
22279                legacy_range_key_spec: keySpec {
22280                    notes: 0 as *const libc::c_char,
22281                    flags: 0,
22282                    begin_search_type: KSPEC_BS_INVALID,
22283                    bs: C2RustUnnamed_3 {
22284                        index: C2RustUnnamed_5 { pos: 0 },
22285                    },
22286                    find_keys_type: KSPEC_FK_INVALID,
22287                    fk: C2RustUnnamed_0 {
22288                        range: C2RustUnnamed_2 {
22289                            lastkey: 0,
22290                            keystep: 0,
22291                            limit: 0,
22292                        },
22293                    },
22294                },
22295                num_args: 0,
22296                num_history: 0,
22297                num_tips: 0,
22298                key_specs_num: 0,
22299                key_specs_max: 0,
22300                subcommands_dict: 0 as *const dict as *mut dict,
22301                parent: 0 as *const redisCommand as *mut redisCommand,
22302                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22303            };
22304            init
22305        },
22306        {
22307            let mut init = redisCommand {
22308                declared_name: b"help\0" as *const u8 as *const libc::c_char,
22309                summary: b"Show helpful text about the different subcommands\0"
22310                    as *const u8 as *const libc::c_char,
22311                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22312                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
22313                doc_flags: 0 as libc::c_int,
22314                replaced_by: 0 as *const libc::c_char,
22315                deprecated_since: 0 as *const libc::c_char,
22316                group: COMMAND_GROUP_SENTINEL,
22317                history: 0 as *const commandHistory as *mut commandHistory,
22318                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22319                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22320                arity: 2 as libc::c_int,
22321                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
22322                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
22323                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22324                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22325                acl_categories: 0 as libc::c_int as uint64_t,
22326                key_specs_static: [keySpec {
22327                    notes: 0 as *const libc::c_char,
22328                    flags: 0,
22329                    begin_search_type: KSPEC_BS_INVALID,
22330                    bs: C2RustUnnamed_3 {
22331                        index: C2RustUnnamed_5 { pos: 0 },
22332                    },
22333                    find_keys_type: KSPEC_FK_INVALID,
22334                    fk: C2RustUnnamed_0 {
22335                        range: C2RustUnnamed_2 {
22336                            lastkey: 0,
22337                            keystep: 0,
22338                            limit: 0,
22339                        },
22340                    },
22341                }; 4],
22342                getkeys_proc: None,
22343                subcommands: 0 as *const redisCommand as *mut redisCommand,
22344                args: 0 as *const redisCommandArg as *mut redisCommandArg,
22345                microseconds: 0,
22346                calls: 0,
22347                rejected_calls: 0,
22348                failed_calls: 0,
22349                id: 0,
22350                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22351                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22352                key_specs: 0 as *const keySpec as *mut keySpec,
22353                legacy_range_key_spec: keySpec {
22354                    notes: 0 as *const libc::c_char,
22355                    flags: 0,
22356                    begin_search_type: KSPEC_BS_INVALID,
22357                    bs: C2RustUnnamed_3 {
22358                        index: C2RustUnnamed_5 { pos: 0 },
22359                    },
22360                    find_keys_type: KSPEC_FK_INVALID,
22361                    fk: C2RustUnnamed_0 {
22362                        range: C2RustUnnamed_2 {
22363                            lastkey: 0,
22364                            keystep: 0,
22365                            limit: 0,
22366                        },
22367                    },
22368                },
22369                num_args: 0,
22370                num_history: 0,
22371                num_tips: 0,
22372                key_specs_num: 0,
22373                key_specs_max: 0,
22374                subcommands_dict: 0 as *const dict as *mut dict,
22375                parent: 0 as *const redisCommand as *mut redisCommand,
22376                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22377            };
22378            init
22379        },
22380        {
22381            let mut init = redisCommand {
22382                declared_name: b"info-cache\0" as *const u8 as *const libc::c_char,
22383                summary: b"Get cached INFO from the instances in the deployment\0"
22384                    as *const u8 as *const libc::c_char,
22385                complexity: b"O(N) where N is the number of instances\0" as *const u8
22386                    as *const libc::c_char,
22387                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
22388                doc_flags: 0 as libc::c_int,
22389                replaced_by: 0 as *const libc::c_char,
22390                deprecated_since: 0 as *const libc::c_char,
22391                group: COMMAND_GROUP_SENTINEL,
22392                history: 0 as *const commandHistory as *mut commandHistory,
22393                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22394                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22395                arity: -(3 as libc::c_int),
22396                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22397                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22398                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22399                acl_categories: 0 as libc::c_int as uint64_t,
22400                key_specs_static: [keySpec {
22401                    notes: 0 as *const libc::c_char,
22402                    flags: 0,
22403                    begin_search_type: KSPEC_BS_INVALID,
22404                    bs: C2RustUnnamed_3 {
22405                        index: C2RustUnnamed_5 { pos: 0 },
22406                    },
22407                    find_keys_type: KSPEC_FK_INVALID,
22408                    fk: C2RustUnnamed_0 {
22409                        range: C2RustUnnamed_2 {
22410                            lastkey: 0,
22411                            keystep: 0,
22412                            limit: 0,
22413                        },
22414                    },
22415                }; 4],
22416                getkeys_proc: None,
22417                subcommands: 0 as *const redisCommand as *mut redisCommand,
22418                args: SENTINEL_INFO_CACHE_Args.as_ptr() as *mut _,
22419                microseconds: 0,
22420                calls: 0,
22421                rejected_calls: 0,
22422                failed_calls: 0,
22423                id: 0,
22424                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22425                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22426                key_specs: 0 as *const keySpec as *mut keySpec,
22427                legacy_range_key_spec: keySpec {
22428                    notes: 0 as *const libc::c_char,
22429                    flags: 0,
22430                    begin_search_type: KSPEC_BS_INVALID,
22431                    bs: C2RustUnnamed_3 {
22432                        index: C2RustUnnamed_5 { pos: 0 },
22433                    },
22434                    find_keys_type: KSPEC_FK_INVALID,
22435                    fk: C2RustUnnamed_0 {
22436                        range: C2RustUnnamed_2 {
22437                            lastkey: 0,
22438                            keystep: 0,
22439                            limit: 0,
22440                        },
22441                    },
22442                },
22443                num_args: 0,
22444                num_history: 0,
22445                num_tips: 0,
22446                key_specs_num: 0,
22447                key_specs_max: 0,
22448                subcommands_dict: 0 as *const dict as *mut dict,
22449                parent: 0 as *const redisCommand as *mut redisCommand,
22450                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22451            };
22452            init
22453        },
22454        {
22455            let mut init = redisCommand {
22456                declared_name: b"is-master-down-by-addr\0" as *const u8
22457                    as *const libc::c_char,
22458                summary: b"Check if a master is down\0" as *const u8
22459                    as *const libc::c_char,
22460                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22461                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22462                doc_flags: 0 as libc::c_int,
22463                replaced_by: 0 as *const libc::c_char,
22464                deprecated_since: 0 as *const libc::c_char,
22465                group: COMMAND_GROUP_SENTINEL,
22466                history: 0 as *const commandHistory as *mut commandHistory,
22467                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22468                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22469                arity: 6 as libc::c_int,
22470                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22471                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22472                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22473                acl_categories: 0 as libc::c_int as uint64_t,
22474                key_specs_static: [keySpec {
22475                    notes: 0 as *const libc::c_char,
22476                    flags: 0,
22477                    begin_search_type: KSPEC_BS_INVALID,
22478                    bs: C2RustUnnamed_3 {
22479                        index: C2RustUnnamed_5 { pos: 0 },
22480                    },
22481                    find_keys_type: KSPEC_FK_INVALID,
22482                    fk: C2RustUnnamed_0 {
22483                        range: C2RustUnnamed_2 {
22484                            lastkey: 0,
22485                            keystep: 0,
22486                            limit: 0,
22487                        },
22488                    },
22489                }; 4],
22490                getkeys_proc: None,
22491                subcommands: 0 as *const redisCommand as *mut redisCommand,
22492                args: SENTINEL_IS_MASTER_DOWN_BY_ADDR_Args.as_ptr() as *mut _,
22493                microseconds: 0,
22494                calls: 0,
22495                rejected_calls: 0,
22496                failed_calls: 0,
22497                id: 0,
22498                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22499                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22500                key_specs: 0 as *const keySpec as *mut keySpec,
22501                legacy_range_key_spec: keySpec {
22502                    notes: 0 as *const libc::c_char,
22503                    flags: 0,
22504                    begin_search_type: KSPEC_BS_INVALID,
22505                    bs: C2RustUnnamed_3 {
22506                        index: C2RustUnnamed_5 { pos: 0 },
22507                    },
22508                    find_keys_type: KSPEC_FK_INVALID,
22509                    fk: C2RustUnnamed_0 {
22510                        range: C2RustUnnamed_2 {
22511                            lastkey: 0,
22512                            keystep: 0,
22513                            limit: 0,
22514                        },
22515                    },
22516                },
22517                num_args: 0,
22518                num_history: 0,
22519                num_tips: 0,
22520                key_specs_num: 0,
22521                key_specs_max: 0,
22522                subcommands_dict: 0 as *const dict as *mut dict,
22523                parent: 0 as *const redisCommand as *mut redisCommand,
22524                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22525            };
22526            init
22527        },
22528        {
22529            let mut init = redisCommand {
22530                declared_name: b"master\0" as *const u8 as *const libc::c_char,
22531                summary: b"Shows the state of a master\0" as *const u8
22532                    as *const libc::c_char,
22533                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22534                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22535                doc_flags: 0 as libc::c_int,
22536                replaced_by: 0 as *const libc::c_char,
22537                deprecated_since: 0 as *const libc::c_char,
22538                group: COMMAND_GROUP_SENTINEL,
22539                history: 0 as *const commandHistory as *mut commandHistory,
22540                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22541                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22542                arity: 3 as libc::c_int,
22543                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22544                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22545                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22546                acl_categories: 0 as libc::c_int as uint64_t,
22547                key_specs_static: [keySpec {
22548                    notes: 0 as *const libc::c_char,
22549                    flags: 0,
22550                    begin_search_type: KSPEC_BS_INVALID,
22551                    bs: C2RustUnnamed_3 {
22552                        index: C2RustUnnamed_5 { pos: 0 },
22553                    },
22554                    find_keys_type: KSPEC_FK_INVALID,
22555                    fk: C2RustUnnamed_0 {
22556                        range: C2RustUnnamed_2 {
22557                            lastkey: 0,
22558                            keystep: 0,
22559                            limit: 0,
22560                        },
22561                    },
22562                }; 4],
22563                getkeys_proc: None,
22564                subcommands: 0 as *const redisCommand as *mut redisCommand,
22565                args: SENTINEL_MASTER_Args.as_ptr() as *mut _,
22566                microseconds: 0,
22567                calls: 0,
22568                rejected_calls: 0,
22569                failed_calls: 0,
22570                id: 0,
22571                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22572                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22573                key_specs: 0 as *const keySpec as *mut keySpec,
22574                legacy_range_key_spec: keySpec {
22575                    notes: 0 as *const libc::c_char,
22576                    flags: 0,
22577                    begin_search_type: KSPEC_BS_INVALID,
22578                    bs: C2RustUnnamed_3 {
22579                        index: C2RustUnnamed_5 { pos: 0 },
22580                    },
22581                    find_keys_type: KSPEC_FK_INVALID,
22582                    fk: C2RustUnnamed_0 {
22583                        range: C2RustUnnamed_2 {
22584                            lastkey: 0,
22585                            keystep: 0,
22586                            limit: 0,
22587                        },
22588                    },
22589                },
22590                num_args: 0,
22591                num_history: 0,
22592                num_tips: 0,
22593                key_specs_num: 0,
22594                key_specs_max: 0,
22595                subcommands_dict: 0 as *const dict as *mut dict,
22596                parent: 0 as *const redisCommand as *mut redisCommand,
22597                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22598            };
22599            init
22600        },
22601        {
22602            let mut init = redisCommand {
22603                declared_name: b"masters\0" as *const u8 as *const libc::c_char,
22604                summary: b"List the monitored masters\0" as *const u8
22605                    as *const libc::c_char,
22606                complexity: b"O(N) where N is the number of masters\0" as *const u8
22607                    as *const libc::c_char,
22608                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22609                doc_flags: 0 as libc::c_int,
22610                replaced_by: 0 as *const libc::c_char,
22611                deprecated_since: 0 as *const libc::c_char,
22612                group: COMMAND_GROUP_SENTINEL,
22613                history: 0 as *const commandHistory as *mut commandHistory,
22614                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22615                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22616                arity: 2 as libc::c_int,
22617                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22618                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22619                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22620                acl_categories: 0 as libc::c_int as uint64_t,
22621                key_specs_static: [keySpec {
22622                    notes: 0 as *const libc::c_char,
22623                    flags: 0,
22624                    begin_search_type: KSPEC_BS_INVALID,
22625                    bs: C2RustUnnamed_3 {
22626                        index: C2RustUnnamed_5 { pos: 0 },
22627                    },
22628                    find_keys_type: KSPEC_FK_INVALID,
22629                    fk: C2RustUnnamed_0 {
22630                        range: C2RustUnnamed_2 {
22631                            lastkey: 0,
22632                            keystep: 0,
22633                            limit: 0,
22634                        },
22635                    },
22636                }; 4],
22637                getkeys_proc: None,
22638                subcommands: 0 as *const redisCommand as *mut redisCommand,
22639                args: 0 as *const redisCommandArg as *mut redisCommandArg,
22640                microseconds: 0,
22641                calls: 0,
22642                rejected_calls: 0,
22643                failed_calls: 0,
22644                id: 0,
22645                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22646                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22647                key_specs: 0 as *const keySpec as *mut keySpec,
22648                legacy_range_key_spec: keySpec {
22649                    notes: 0 as *const libc::c_char,
22650                    flags: 0,
22651                    begin_search_type: KSPEC_BS_INVALID,
22652                    bs: C2RustUnnamed_3 {
22653                        index: C2RustUnnamed_5 { pos: 0 },
22654                    },
22655                    find_keys_type: KSPEC_FK_INVALID,
22656                    fk: C2RustUnnamed_0 {
22657                        range: C2RustUnnamed_2 {
22658                            lastkey: 0,
22659                            keystep: 0,
22660                            limit: 0,
22661                        },
22662                    },
22663                },
22664                num_args: 0,
22665                num_history: 0,
22666                num_tips: 0,
22667                key_specs_num: 0,
22668                key_specs_max: 0,
22669                subcommands_dict: 0 as *const dict as *mut dict,
22670                parent: 0 as *const redisCommand as *mut redisCommand,
22671                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22672            };
22673            init
22674        },
22675        {
22676            let mut init = redisCommand {
22677                declared_name: b"monitor\0" as *const u8 as *const libc::c_char,
22678                summary: b"Start monitoring\0" as *const u8 as *const libc::c_char,
22679                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22680                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22681                doc_flags: 0 as libc::c_int,
22682                replaced_by: 0 as *const libc::c_char,
22683                deprecated_since: 0 as *const libc::c_char,
22684                group: COMMAND_GROUP_SENTINEL,
22685                history: 0 as *const commandHistory as *mut commandHistory,
22686                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22687                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22688                arity: 6 as libc::c_int,
22689                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22690                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22691                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22692                acl_categories: 0 as libc::c_int as uint64_t,
22693                key_specs_static: [keySpec {
22694                    notes: 0 as *const libc::c_char,
22695                    flags: 0,
22696                    begin_search_type: KSPEC_BS_INVALID,
22697                    bs: C2RustUnnamed_3 {
22698                        index: C2RustUnnamed_5 { pos: 0 },
22699                    },
22700                    find_keys_type: KSPEC_FK_INVALID,
22701                    fk: C2RustUnnamed_0 {
22702                        range: C2RustUnnamed_2 {
22703                            lastkey: 0,
22704                            keystep: 0,
22705                            limit: 0,
22706                        },
22707                    },
22708                }; 4],
22709                getkeys_proc: None,
22710                subcommands: 0 as *const redisCommand as *mut redisCommand,
22711                args: SENTINEL_MONITOR_Args.as_ptr() as *mut _,
22712                microseconds: 0,
22713                calls: 0,
22714                rejected_calls: 0,
22715                failed_calls: 0,
22716                id: 0,
22717                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22718                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22719                key_specs: 0 as *const keySpec as *mut keySpec,
22720                legacy_range_key_spec: keySpec {
22721                    notes: 0 as *const libc::c_char,
22722                    flags: 0,
22723                    begin_search_type: KSPEC_BS_INVALID,
22724                    bs: C2RustUnnamed_3 {
22725                        index: C2RustUnnamed_5 { pos: 0 },
22726                    },
22727                    find_keys_type: KSPEC_FK_INVALID,
22728                    fk: C2RustUnnamed_0 {
22729                        range: C2RustUnnamed_2 {
22730                            lastkey: 0,
22731                            keystep: 0,
22732                            limit: 0,
22733                        },
22734                    },
22735                },
22736                num_args: 0,
22737                num_history: 0,
22738                num_tips: 0,
22739                key_specs_num: 0,
22740                key_specs_max: 0,
22741                subcommands_dict: 0 as *const dict as *mut dict,
22742                parent: 0 as *const redisCommand as *mut redisCommand,
22743                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22744            };
22745            init
22746        },
22747        {
22748            let mut init = redisCommand {
22749                declared_name: b"myid\0" as *const u8 as *const libc::c_char,
22750                summary: b"Get the Sentinel instance ID\0" as *const u8
22751                    as *const libc::c_char,
22752                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22753                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
22754                doc_flags: 0 as libc::c_int,
22755                replaced_by: 0 as *const libc::c_char,
22756                deprecated_since: 0 as *const libc::c_char,
22757                group: COMMAND_GROUP_SENTINEL,
22758                history: 0 as *const commandHistory as *mut commandHistory,
22759                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22760                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22761                arity: 2 as libc::c_int,
22762                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22763                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22764                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22765                acl_categories: 0 as libc::c_int as uint64_t,
22766                key_specs_static: [keySpec {
22767                    notes: 0 as *const libc::c_char,
22768                    flags: 0,
22769                    begin_search_type: KSPEC_BS_INVALID,
22770                    bs: C2RustUnnamed_3 {
22771                        index: C2RustUnnamed_5 { pos: 0 },
22772                    },
22773                    find_keys_type: KSPEC_FK_INVALID,
22774                    fk: C2RustUnnamed_0 {
22775                        range: C2RustUnnamed_2 {
22776                            lastkey: 0,
22777                            keystep: 0,
22778                            limit: 0,
22779                        },
22780                    },
22781                }; 4],
22782                getkeys_proc: None,
22783                subcommands: 0 as *const redisCommand as *mut redisCommand,
22784                args: 0 as *const redisCommandArg as *mut redisCommandArg,
22785                microseconds: 0,
22786                calls: 0,
22787                rejected_calls: 0,
22788                failed_calls: 0,
22789                id: 0,
22790                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22791                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22792                key_specs: 0 as *const keySpec as *mut keySpec,
22793                legacy_range_key_spec: keySpec {
22794                    notes: 0 as *const libc::c_char,
22795                    flags: 0,
22796                    begin_search_type: KSPEC_BS_INVALID,
22797                    bs: C2RustUnnamed_3 {
22798                        index: C2RustUnnamed_5 { pos: 0 },
22799                    },
22800                    find_keys_type: KSPEC_FK_INVALID,
22801                    fk: C2RustUnnamed_0 {
22802                        range: C2RustUnnamed_2 {
22803                            lastkey: 0,
22804                            keystep: 0,
22805                            limit: 0,
22806                        },
22807                    },
22808                },
22809                num_args: 0,
22810                num_history: 0,
22811                num_tips: 0,
22812                key_specs_num: 0,
22813                key_specs_max: 0,
22814                subcommands_dict: 0 as *const dict as *mut dict,
22815                parent: 0 as *const redisCommand as *mut redisCommand,
22816                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22817            };
22818            init
22819        },
22820        {
22821            let mut init = redisCommand {
22822                declared_name: b"pending-scripts\0" as *const u8 as *const libc::c_char,
22823                summary: b"Get information about pending scripts\0" as *const u8
22824                    as *const libc::c_char,
22825                complexity: 0 as *const libc::c_char,
22826                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22827                doc_flags: 0 as libc::c_int,
22828                replaced_by: 0 as *const libc::c_char,
22829                deprecated_since: 0 as *const libc::c_char,
22830                group: COMMAND_GROUP_SENTINEL,
22831                history: 0 as *const commandHistory as *mut commandHistory,
22832                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22833                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22834                arity: 2 as libc::c_int,
22835                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22836                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22837                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22838                acl_categories: 0 as libc::c_int as uint64_t,
22839                key_specs_static: [keySpec {
22840                    notes: 0 as *const libc::c_char,
22841                    flags: 0,
22842                    begin_search_type: KSPEC_BS_INVALID,
22843                    bs: C2RustUnnamed_3 {
22844                        index: C2RustUnnamed_5 { pos: 0 },
22845                    },
22846                    find_keys_type: KSPEC_FK_INVALID,
22847                    fk: C2RustUnnamed_0 {
22848                        range: C2RustUnnamed_2 {
22849                            lastkey: 0,
22850                            keystep: 0,
22851                            limit: 0,
22852                        },
22853                    },
22854                }; 4],
22855                getkeys_proc: None,
22856                subcommands: 0 as *const redisCommand as *mut redisCommand,
22857                args: 0 as *const redisCommandArg as *mut redisCommandArg,
22858                microseconds: 0,
22859                calls: 0,
22860                rejected_calls: 0,
22861                failed_calls: 0,
22862                id: 0,
22863                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22864                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22865                key_specs: 0 as *const keySpec as *mut keySpec,
22866                legacy_range_key_spec: keySpec {
22867                    notes: 0 as *const libc::c_char,
22868                    flags: 0,
22869                    begin_search_type: KSPEC_BS_INVALID,
22870                    bs: C2RustUnnamed_3 {
22871                        index: C2RustUnnamed_5 { pos: 0 },
22872                    },
22873                    find_keys_type: KSPEC_FK_INVALID,
22874                    fk: C2RustUnnamed_0 {
22875                        range: C2RustUnnamed_2 {
22876                            lastkey: 0,
22877                            keystep: 0,
22878                            limit: 0,
22879                        },
22880                    },
22881                },
22882                num_args: 0,
22883                num_history: 0,
22884                num_tips: 0,
22885                key_specs_num: 0,
22886                key_specs_max: 0,
22887                subcommands_dict: 0 as *const dict as *mut dict,
22888                parent: 0 as *const redisCommand as *mut redisCommand,
22889                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22890            };
22891            init
22892        },
22893        {
22894            let mut init = redisCommand {
22895                declared_name: b"remove\0" as *const u8 as *const libc::c_char,
22896                summary: b"Stop monitoring\0" as *const u8 as *const libc::c_char,
22897                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
22898                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
22899                doc_flags: 0 as libc::c_int,
22900                replaced_by: 0 as *const libc::c_char,
22901                deprecated_since: 0 as *const libc::c_char,
22902                group: COMMAND_GROUP_SENTINEL,
22903                history: 0 as *const commandHistory as *mut commandHistory,
22904                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22905                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22906                arity: 3 as libc::c_int,
22907                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22908                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22909                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22910                acl_categories: 0 as libc::c_int as uint64_t,
22911                key_specs_static: [keySpec {
22912                    notes: 0 as *const libc::c_char,
22913                    flags: 0,
22914                    begin_search_type: KSPEC_BS_INVALID,
22915                    bs: C2RustUnnamed_3 {
22916                        index: C2RustUnnamed_5 { pos: 0 },
22917                    },
22918                    find_keys_type: KSPEC_FK_INVALID,
22919                    fk: C2RustUnnamed_0 {
22920                        range: C2RustUnnamed_2 {
22921                            lastkey: 0,
22922                            keystep: 0,
22923                            limit: 0,
22924                        },
22925                    },
22926                }; 4],
22927                getkeys_proc: None,
22928                subcommands: 0 as *const redisCommand as *mut redisCommand,
22929                args: SENTINEL_REMOVE_Args.as_ptr() as *mut _,
22930                microseconds: 0,
22931                calls: 0,
22932                rejected_calls: 0,
22933                failed_calls: 0,
22934                id: 0,
22935                fullname: 0 as *const libc::c_char as *mut libc::c_char,
22936                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
22937                key_specs: 0 as *const keySpec as *mut keySpec,
22938                legacy_range_key_spec: keySpec {
22939                    notes: 0 as *const libc::c_char,
22940                    flags: 0,
22941                    begin_search_type: KSPEC_BS_INVALID,
22942                    bs: C2RustUnnamed_3 {
22943                        index: C2RustUnnamed_5 { pos: 0 },
22944                    },
22945                    find_keys_type: KSPEC_FK_INVALID,
22946                    fk: C2RustUnnamed_0 {
22947                        range: C2RustUnnamed_2 {
22948                            lastkey: 0,
22949                            keystep: 0,
22950                            limit: 0,
22951                        },
22952                    },
22953                },
22954                num_args: 0,
22955                num_history: 0,
22956                num_tips: 0,
22957                key_specs_num: 0,
22958                key_specs_max: 0,
22959                subcommands_dict: 0 as *const dict as *mut dict,
22960                parent: 0 as *const redisCommand as *mut redisCommand,
22961                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
22962            };
22963            init
22964        },
22965        {
22966            let mut init = redisCommand {
22967                declared_name: b"replicas\0" as *const u8 as *const libc::c_char,
22968                summary: b"List the monitored replicas\0" as *const u8
22969                    as *const libc::c_char,
22970                complexity: b"O(N) where N is the number of replicas\0" as *const u8
22971                    as *const libc::c_char,
22972                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
22973                doc_flags: 0 as libc::c_int,
22974                replaced_by: 0 as *const libc::c_char,
22975                deprecated_since: 0 as *const libc::c_char,
22976                group: COMMAND_GROUP_SENTINEL,
22977                history: 0 as *const commandHistory as *mut commandHistory,
22978                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
22979                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
22980                arity: 3 as libc::c_int,
22981                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
22982                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
22983                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
22984                acl_categories: 0 as libc::c_int as uint64_t,
22985                key_specs_static: [keySpec {
22986                    notes: 0 as *const libc::c_char,
22987                    flags: 0,
22988                    begin_search_type: KSPEC_BS_INVALID,
22989                    bs: C2RustUnnamed_3 {
22990                        index: C2RustUnnamed_5 { pos: 0 },
22991                    },
22992                    find_keys_type: KSPEC_FK_INVALID,
22993                    fk: C2RustUnnamed_0 {
22994                        range: C2RustUnnamed_2 {
22995                            lastkey: 0,
22996                            keystep: 0,
22997                            limit: 0,
22998                        },
22999                    },
23000                }; 4],
23001                getkeys_proc: None,
23002                subcommands: 0 as *const redisCommand as *mut redisCommand,
23003                args: SENTINEL_REPLICAS_Args.as_ptr() as *mut _,
23004                microseconds: 0,
23005                calls: 0,
23006                rejected_calls: 0,
23007                failed_calls: 0,
23008                id: 0,
23009                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23010                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23011                key_specs: 0 as *const keySpec as *mut keySpec,
23012                legacy_range_key_spec: keySpec {
23013                    notes: 0 as *const libc::c_char,
23014                    flags: 0,
23015                    begin_search_type: KSPEC_BS_INVALID,
23016                    bs: C2RustUnnamed_3 {
23017                        index: C2RustUnnamed_5 { pos: 0 },
23018                    },
23019                    find_keys_type: KSPEC_FK_INVALID,
23020                    fk: C2RustUnnamed_0 {
23021                        range: C2RustUnnamed_2 {
23022                            lastkey: 0,
23023                            keystep: 0,
23024                            limit: 0,
23025                        },
23026                    },
23027                },
23028                num_args: 0,
23029                num_history: 0,
23030                num_tips: 0,
23031                key_specs_num: 0,
23032                key_specs_max: 0,
23033                subcommands_dict: 0 as *const dict as *mut dict,
23034                parent: 0 as *const redisCommand as *mut redisCommand,
23035                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23036            };
23037            init
23038        },
23039        {
23040            let mut init = redisCommand {
23041                declared_name: b"reset\0" as *const u8 as *const libc::c_char,
23042                summary: b"Reset masters by name pattern\0" as *const u8
23043                    as *const libc::c_char,
23044                complexity: b"O(N) where N is the number of monitored masters\0"
23045                    as *const u8 as *const libc::c_char,
23046                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
23047                doc_flags: 0 as libc::c_int,
23048                replaced_by: 0 as *const libc::c_char,
23049                deprecated_since: 0 as *const libc::c_char,
23050                group: COMMAND_GROUP_SENTINEL,
23051                history: 0 as *const commandHistory as *mut commandHistory,
23052                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23053                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
23054                arity: 3 as libc::c_int,
23055                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23056                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
23057                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
23058                acl_categories: 0 as libc::c_int as uint64_t,
23059                key_specs_static: [keySpec {
23060                    notes: 0 as *const libc::c_char,
23061                    flags: 0,
23062                    begin_search_type: KSPEC_BS_INVALID,
23063                    bs: C2RustUnnamed_3 {
23064                        index: C2RustUnnamed_5 { pos: 0 },
23065                    },
23066                    find_keys_type: KSPEC_FK_INVALID,
23067                    fk: C2RustUnnamed_0 {
23068                        range: C2RustUnnamed_2 {
23069                            lastkey: 0,
23070                            keystep: 0,
23071                            limit: 0,
23072                        },
23073                    },
23074                }; 4],
23075                getkeys_proc: None,
23076                subcommands: 0 as *const redisCommand as *mut redisCommand,
23077                args: SENTINEL_RESET_Args.as_ptr() as *mut _,
23078                microseconds: 0,
23079                calls: 0,
23080                rejected_calls: 0,
23081                failed_calls: 0,
23082                id: 0,
23083                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23084                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23085                key_specs: 0 as *const keySpec as *mut keySpec,
23086                legacy_range_key_spec: keySpec {
23087                    notes: 0 as *const libc::c_char,
23088                    flags: 0,
23089                    begin_search_type: KSPEC_BS_INVALID,
23090                    bs: C2RustUnnamed_3 {
23091                        index: C2RustUnnamed_5 { pos: 0 },
23092                    },
23093                    find_keys_type: KSPEC_FK_INVALID,
23094                    fk: C2RustUnnamed_0 {
23095                        range: C2RustUnnamed_2 {
23096                            lastkey: 0,
23097                            keystep: 0,
23098                            limit: 0,
23099                        },
23100                    },
23101                },
23102                num_args: 0,
23103                num_history: 0,
23104                num_tips: 0,
23105                key_specs_num: 0,
23106                key_specs_max: 0,
23107                subcommands_dict: 0 as *const dict as *mut dict,
23108                parent: 0 as *const redisCommand as *mut redisCommand,
23109                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23110            };
23111            init
23112        },
23113        {
23114            let mut init = redisCommand {
23115                declared_name: b"sentinels\0" as *const u8 as *const libc::c_char,
23116                summary: b"List the Sentinel instances\0" as *const u8
23117                    as *const libc::c_char,
23118                complexity: b"O(N) where N is the number of Sentinels\0" as *const u8
23119                    as *const libc::c_char,
23120                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
23121                doc_flags: 0 as libc::c_int,
23122                replaced_by: 0 as *const libc::c_char,
23123                deprecated_since: 0 as *const libc::c_char,
23124                group: COMMAND_GROUP_SENTINEL,
23125                history: 0 as *const commandHistory as *mut commandHistory,
23126                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23127                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
23128                arity: 3 as libc::c_int,
23129                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23130                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
23131                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
23132                acl_categories: 0 as libc::c_int as uint64_t,
23133                key_specs_static: [keySpec {
23134                    notes: 0 as *const libc::c_char,
23135                    flags: 0,
23136                    begin_search_type: KSPEC_BS_INVALID,
23137                    bs: C2RustUnnamed_3 {
23138                        index: C2RustUnnamed_5 { pos: 0 },
23139                    },
23140                    find_keys_type: KSPEC_FK_INVALID,
23141                    fk: C2RustUnnamed_0 {
23142                        range: C2RustUnnamed_2 {
23143                            lastkey: 0,
23144                            keystep: 0,
23145                            limit: 0,
23146                        },
23147                    },
23148                }; 4],
23149                getkeys_proc: None,
23150                subcommands: 0 as *const redisCommand as *mut redisCommand,
23151                args: SENTINEL_SENTINELS_Args.as_ptr() as *mut _,
23152                microseconds: 0,
23153                calls: 0,
23154                rejected_calls: 0,
23155                failed_calls: 0,
23156                id: 0,
23157                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23158                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23159                key_specs: 0 as *const keySpec as *mut keySpec,
23160                legacy_range_key_spec: keySpec {
23161                    notes: 0 as *const libc::c_char,
23162                    flags: 0,
23163                    begin_search_type: KSPEC_BS_INVALID,
23164                    bs: C2RustUnnamed_3 {
23165                        index: C2RustUnnamed_5 { pos: 0 },
23166                    },
23167                    find_keys_type: KSPEC_FK_INVALID,
23168                    fk: C2RustUnnamed_0 {
23169                        range: C2RustUnnamed_2 {
23170                            lastkey: 0,
23171                            keystep: 0,
23172                            limit: 0,
23173                        },
23174                    },
23175                },
23176                num_args: 0,
23177                num_history: 0,
23178                num_tips: 0,
23179                key_specs_num: 0,
23180                key_specs_max: 0,
23181                subcommands_dict: 0 as *const dict as *mut dict,
23182                parent: 0 as *const redisCommand as *mut redisCommand,
23183                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23184            };
23185            init
23186        },
23187        {
23188            let mut init = redisCommand {
23189                declared_name: b"set\0" as *const u8 as *const libc::c_char,
23190                summary: b"Change the configuration of a monitored master\0" as *const u8
23191                    as *const libc::c_char,
23192                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
23193                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
23194                doc_flags: 0 as libc::c_int,
23195                replaced_by: 0 as *const libc::c_char,
23196                deprecated_since: 0 as *const libc::c_char,
23197                group: COMMAND_GROUP_SENTINEL,
23198                history: 0 as *const commandHistory as *mut commandHistory,
23199                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23200                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
23201                arity: -(5 as libc::c_int),
23202                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23203                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
23204                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
23205                acl_categories: 0 as libc::c_int as uint64_t,
23206                key_specs_static: [keySpec {
23207                    notes: 0 as *const libc::c_char,
23208                    flags: 0,
23209                    begin_search_type: KSPEC_BS_INVALID,
23210                    bs: C2RustUnnamed_3 {
23211                        index: C2RustUnnamed_5 { pos: 0 },
23212                    },
23213                    find_keys_type: KSPEC_FK_INVALID,
23214                    fk: C2RustUnnamed_0 {
23215                        range: C2RustUnnamed_2 {
23216                            lastkey: 0,
23217                            keystep: 0,
23218                            limit: 0,
23219                        },
23220                    },
23221                }; 4],
23222                getkeys_proc: None,
23223                subcommands: 0 as *const redisCommand as *mut redisCommand,
23224                args: SENTINEL_SET_Args.as_ptr() as *mut _,
23225                microseconds: 0,
23226                calls: 0,
23227                rejected_calls: 0,
23228                failed_calls: 0,
23229                id: 0,
23230                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23231                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23232                key_specs: 0 as *const keySpec as *mut keySpec,
23233                legacy_range_key_spec: keySpec {
23234                    notes: 0 as *const libc::c_char,
23235                    flags: 0,
23236                    begin_search_type: KSPEC_BS_INVALID,
23237                    bs: C2RustUnnamed_3 {
23238                        index: C2RustUnnamed_5 { pos: 0 },
23239                    },
23240                    find_keys_type: KSPEC_FK_INVALID,
23241                    fk: C2RustUnnamed_0 {
23242                        range: C2RustUnnamed_2 {
23243                            lastkey: 0,
23244                            keystep: 0,
23245                            limit: 0,
23246                        },
23247                    },
23248                },
23249                num_args: 0,
23250                num_history: 0,
23251                num_tips: 0,
23252                key_specs_num: 0,
23253                key_specs_max: 0,
23254                subcommands_dict: 0 as *const dict as *mut dict,
23255                parent: 0 as *const redisCommand as *mut redisCommand,
23256                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23257            };
23258            init
23259        },
23260        {
23261            let mut init = redisCommand {
23262                declared_name: b"simulate-failure\0" as *const u8 as *const libc::c_char,
23263                summary: b"Simulate failover scenarios\0" as *const u8
23264                    as *const libc::c_char,
23265                complexity: 0 as *const libc::c_char,
23266                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
23267                doc_flags: 0 as libc::c_int,
23268                replaced_by: 0 as *const libc::c_char,
23269                deprecated_since: 0 as *const libc::c_char,
23270                group: COMMAND_GROUP_SENTINEL,
23271                history: 0 as *const commandHistory as *mut commandHistory,
23272                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23273                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
23274                arity: -(3 as libc::c_int),
23275                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23276                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
23277                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
23278                acl_categories: 0 as libc::c_int as uint64_t,
23279                key_specs_static: [keySpec {
23280                    notes: 0 as *const libc::c_char,
23281                    flags: 0,
23282                    begin_search_type: KSPEC_BS_INVALID,
23283                    bs: C2RustUnnamed_3 {
23284                        index: C2RustUnnamed_5 { pos: 0 },
23285                    },
23286                    find_keys_type: KSPEC_FK_INVALID,
23287                    fk: C2RustUnnamed_0 {
23288                        range: C2RustUnnamed_2 {
23289                            lastkey: 0,
23290                            keystep: 0,
23291                            limit: 0,
23292                        },
23293                    },
23294                }; 4],
23295                getkeys_proc: None,
23296                subcommands: 0 as *const redisCommand as *mut redisCommand,
23297                args: SENTINEL_SIMULATE_FAILURE_Args.as_ptr() as *mut _,
23298                microseconds: 0,
23299                calls: 0,
23300                rejected_calls: 0,
23301                failed_calls: 0,
23302                id: 0,
23303                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23304                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23305                key_specs: 0 as *const keySpec as *mut keySpec,
23306                legacy_range_key_spec: keySpec {
23307                    notes: 0 as *const libc::c_char,
23308                    flags: 0,
23309                    begin_search_type: KSPEC_BS_INVALID,
23310                    bs: C2RustUnnamed_3 {
23311                        index: C2RustUnnamed_5 { pos: 0 },
23312                    },
23313                    find_keys_type: KSPEC_FK_INVALID,
23314                    fk: C2RustUnnamed_0 {
23315                        range: C2RustUnnamed_2 {
23316                            lastkey: 0,
23317                            keystep: 0,
23318                            limit: 0,
23319                        },
23320                    },
23321                },
23322                num_args: 0,
23323                num_history: 0,
23324                num_tips: 0,
23325                key_specs_num: 0,
23326                key_specs_max: 0,
23327                subcommands_dict: 0 as *const dict as *mut dict,
23328                parent: 0 as *const redisCommand as *mut redisCommand,
23329                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23330            };
23331            init
23332        },
23333        {
23334            let mut init = redisCommand {
23335                declared_name: b"slaves\0" as *const u8 as *const libc::c_char,
23336                summary: b"List the monitored slaves\0" as *const u8
23337                    as *const libc::c_char,
23338                complexity: b"O(N) where N is the number of slaves\0" as *const u8
23339                    as *const libc::c_char,
23340                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
23341                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
23342                replaced_by: b"`SENTINEL REPLICAS`\0" as *const u8
23343                    as *const libc::c_char,
23344                deprecated_since: b"5.0.0\0" as *const u8 as *const libc::c_char,
23345                group: COMMAND_GROUP_SENTINEL,
23346                history: 0 as *const commandHistory as *mut commandHistory,
23347                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23348                proc_0: Some(sentinelCommand as unsafe extern "C" fn(*mut client) -> ()),
23349                arity: 3 as libc::c_int,
23350                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23351                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
23352                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
23353                acl_categories: 0 as libc::c_int as uint64_t,
23354                key_specs_static: [keySpec {
23355                    notes: 0 as *const libc::c_char,
23356                    flags: 0,
23357                    begin_search_type: KSPEC_BS_INVALID,
23358                    bs: C2RustUnnamed_3 {
23359                        index: C2RustUnnamed_5 { pos: 0 },
23360                    },
23361                    find_keys_type: KSPEC_FK_INVALID,
23362                    fk: C2RustUnnamed_0 {
23363                        range: C2RustUnnamed_2 {
23364                            lastkey: 0,
23365                            keystep: 0,
23366                            limit: 0,
23367                        },
23368                    },
23369                }; 4],
23370                getkeys_proc: None,
23371                subcommands: 0 as *const redisCommand as *mut redisCommand,
23372                args: SENTINEL_SLAVES_Args.as_ptr() as *mut _,
23373                microseconds: 0,
23374                calls: 0,
23375                rejected_calls: 0,
23376                failed_calls: 0,
23377                id: 0,
23378                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23379                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23380                key_specs: 0 as *const keySpec as *mut keySpec,
23381                legacy_range_key_spec: keySpec {
23382                    notes: 0 as *const libc::c_char,
23383                    flags: 0,
23384                    begin_search_type: KSPEC_BS_INVALID,
23385                    bs: C2RustUnnamed_3 {
23386                        index: C2RustUnnamed_5 { pos: 0 },
23387                    },
23388                    find_keys_type: KSPEC_FK_INVALID,
23389                    fk: C2RustUnnamed_0 {
23390                        range: C2RustUnnamed_2 {
23391                            lastkey: 0,
23392                            keystep: 0,
23393                            limit: 0,
23394                        },
23395                    },
23396                },
23397                num_args: 0,
23398                num_history: 0,
23399                num_tips: 0,
23400                key_specs_num: 0,
23401                key_specs_max: 0,
23402                subcommands_dict: 0 as *const dict as *mut dict,
23403                parent: 0 as *const redisCommand as *mut redisCommand,
23404                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23405            };
23406            init
23407        },
23408        {
23409            let mut init = redisCommand {
23410                declared_name: 0 as *const libc::c_char,
23411                summary: 0 as *const libc::c_char,
23412                complexity: 0 as *const libc::c_char,
23413                since: 0 as *const libc::c_char,
23414                doc_flags: 0,
23415                replaced_by: 0 as *const libc::c_char,
23416                deprecated_since: 0 as *const libc::c_char,
23417                group: COMMAND_GROUP_GENERIC,
23418                history: 0 as *const commandHistory as *mut commandHistory,
23419                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23420                proc_0: None,
23421                arity: 0,
23422                flags: 0,
23423                acl_categories: 0,
23424                key_specs_static: [keySpec {
23425                    notes: 0 as *const libc::c_char,
23426                    flags: 0,
23427                    begin_search_type: KSPEC_BS_INVALID,
23428                    bs: C2RustUnnamed_3 {
23429                        index: C2RustUnnamed_5 { pos: 0 },
23430                    },
23431                    find_keys_type: KSPEC_FK_INVALID,
23432                    fk: C2RustUnnamed_0 {
23433                        range: C2RustUnnamed_2 {
23434                            lastkey: 0,
23435                            keystep: 0,
23436                            limit: 0,
23437                        },
23438                    },
23439                }; 4],
23440                getkeys_proc: None,
23441                subcommands: 0 as *const redisCommand as *mut redisCommand,
23442                args: 0 as *const redisCommandArg as *mut redisCommandArg,
23443                microseconds: 0,
23444                calls: 0,
23445                rejected_calls: 0,
23446                failed_calls: 0,
23447                id: 0,
23448                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23449                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23450                key_specs: 0 as *const keySpec as *mut keySpec,
23451                legacy_range_key_spec: keySpec {
23452                    notes: 0 as *const libc::c_char,
23453                    flags: 0,
23454                    begin_search_type: KSPEC_BS_INVALID,
23455                    bs: C2RustUnnamed_3 {
23456                        index: C2RustUnnamed_5 { pos: 0 },
23457                    },
23458                    find_keys_type: KSPEC_FK_INVALID,
23459                    fk: C2RustUnnamed_0 {
23460                        range: C2RustUnnamed_2 {
23461                            lastkey: 0,
23462                            keystep: 0,
23463                            limit: 0,
23464                        },
23465                    },
23466                },
23467                num_args: 0,
23468                num_history: 0,
23469                num_tips: 0,
23470                key_specs_num: 0,
23471                key_specs_max: 0,
23472                subcommands_dict: 0 as *const dict as *mut dict,
23473                parent: 0 as *const redisCommand as *mut redisCommand,
23474                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23475            };
23476            init
23477        },
23478    ]
23479};
23480#[no_mangle]
23481pub static mut ACL_CAT_Args: [redisCommandArg; 2] = [
23482    {
23483        let mut init = redisCommandArg {
23484            name: b"categoryname\0" as *const u8 as *const libc::c_char,
23485            type_0: ARG_TYPE_STRING,
23486            key_spec_index: -(1 as libc::c_int),
23487            token: 0 as *const libc::c_char,
23488            summary: 0 as *const libc::c_char,
23489            since: 0 as *const libc::c_char,
23490            flags: (1 as libc::c_int) << 0 as libc::c_int,
23491            deprecated_since: 0 as *const libc::c_char,
23492            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23493            num_args: 0,
23494        };
23495        init
23496    },
23497    {
23498        let mut init = redisCommandArg {
23499            name: 0 as *const libc::c_char,
23500            type_0: ARG_TYPE_STRING,
23501            key_spec_index: 0,
23502            token: 0 as *const libc::c_char,
23503            summary: 0 as *const libc::c_char,
23504            since: 0 as *const libc::c_char,
23505            flags: 0,
23506            deprecated_since: 0 as *const libc::c_char,
23507            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23508            num_args: 0,
23509        };
23510        init
23511    },
23512];
23513#[no_mangle]
23514pub static mut ACL_DELUSER_Args: [redisCommandArg; 2] = [
23515    {
23516        let mut init = redisCommandArg {
23517            name: b"username\0" as *const u8 as *const libc::c_char,
23518            type_0: ARG_TYPE_STRING,
23519            key_spec_index: -(1 as libc::c_int),
23520            token: 0 as *const libc::c_char,
23521            summary: 0 as *const libc::c_char,
23522            since: 0 as *const libc::c_char,
23523            flags: (1 as libc::c_int) << 1 as libc::c_int,
23524            deprecated_since: 0 as *const libc::c_char,
23525            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23526            num_args: 0,
23527        };
23528        init
23529    },
23530    {
23531        let mut init = redisCommandArg {
23532            name: 0 as *const libc::c_char,
23533            type_0: ARG_TYPE_STRING,
23534            key_spec_index: 0,
23535            token: 0 as *const libc::c_char,
23536            summary: 0 as *const libc::c_char,
23537            since: 0 as *const libc::c_char,
23538            flags: 0,
23539            deprecated_since: 0 as *const libc::c_char,
23540            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23541            num_args: 0,
23542        };
23543        init
23544    },
23545];
23546#[no_mangle]
23547pub static mut ACL_DRYRUN_Args: [redisCommandArg; 4] = [
23548    {
23549        let mut init = redisCommandArg {
23550            name: b"username\0" as *const u8 as *const libc::c_char,
23551            type_0: ARG_TYPE_STRING,
23552            key_spec_index: -(1 as libc::c_int),
23553            token: 0 as *const libc::c_char,
23554            summary: 0 as *const libc::c_char,
23555            since: 0 as *const libc::c_char,
23556            flags: 0 as libc::c_int,
23557            deprecated_since: 0 as *const libc::c_char,
23558            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23559            num_args: 0,
23560        };
23561        init
23562    },
23563    {
23564        let mut init = redisCommandArg {
23565            name: b"command\0" as *const u8 as *const libc::c_char,
23566            type_0: ARG_TYPE_STRING,
23567            key_spec_index: -(1 as libc::c_int),
23568            token: 0 as *const libc::c_char,
23569            summary: 0 as *const libc::c_char,
23570            since: 0 as *const libc::c_char,
23571            flags: 0 as libc::c_int,
23572            deprecated_since: 0 as *const libc::c_char,
23573            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23574            num_args: 0,
23575        };
23576        init
23577    },
23578    {
23579        let mut init = redisCommandArg {
23580            name: b"arg\0" as *const u8 as *const libc::c_char,
23581            type_0: ARG_TYPE_STRING,
23582            key_spec_index: -(1 as libc::c_int),
23583            token: 0 as *const libc::c_char,
23584            summary: 0 as *const libc::c_char,
23585            since: 0 as *const libc::c_char,
23586            flags: (1 as libc::c_int) << 0 as libc::c_int
23587                | (1 as libc::c_int) << 1 as libc::c_int,
23588            deprecated_since: 0 as *const libc::c_char,
23589            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23590            num_args: 0,
23591        };
23592        init
23593    },
23594    {
23595        let mut init = redisCommandArg {
23596            name: 0 as *const libc::c_char,
23597            type_0: ARG_TYPE_STRING,
23598            key_spec_index: 0,
23599            token: 0 as *const libc::c_char,
23600            summary: 0 as *const libc::c_char,
23601            since: 0 as *const libc::c_char,
23602            flags: 0,
23603            deprecated_since: 0 as *const libc::c_char,
23604            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23605            num_args: 0,
23606        };
23607        init
23608    },
23609];
23610#[no_mangle]
23611pub static mut ACL_GENPASS_Args: [redisCommandArg; 2] = [
23612    {
23613        let mut init = redisCommandArg {
23614            name: b"bits\0" as *const u8 as *const libc::c_char,
23615            type_0: ARG_TYPE_INTEGER,
23616            key_spec_index: -(1 as libc::c_int),
23617            token: 0 as *const libc::c_char,
23618            summary: 0 as *const libc::c_char,
23619            since: 0 as *const libc::c_char,
23620            flags: (1 as libc::c_int) << 0 as libc::c_int,
23621            deprecated_since: 0 as *const libc::c_char,
23622            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23623            num_args: 0,
23624        };
23625        init
23626    },
23627    {
23628        let mut init = redisCommandArg {
23629            name: 0 as *const libc::c_char,
23630            type_0: ARG_TYPE_STRING,
23631            key_spec_index: 0,
23632            token: 0 as *const libc::c_char,
23633            summary: 0 as *const libc::c_char,
23634            since: 0 as *const libc::c_char,
23635            flags: 0,
23636            deprecated_since: 0 as *const libc::c_char,
23637            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23638            num_args: 0,
23639        };
23640        init
23641    },
23642];
23643#[no_mangle]
23644pub static mut ACL_GETUSER_History: [commandHistory; 3] = [
23645    {
23646        let mut init = commandHistory {
23647            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
23648            changes: b"Added Pub/Sub channel patterns.\0" as *const u8
23649                as *const libc::c_char,
23650        };
23651        init
23652    },
23653    {
23654        let mut init = commandHistory {
23655            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
23656            changes: b"Added selectors and changed the format of key and channel patterns from a list to their rule representation.\0"
23657                as *const u8 as *const libc::c_char,
23658        };
23659        init
23660    },
23661    {
23662        let mut init = commandHistory {
23663            since: 0 as *const libc::c_char,
23664            changes: 0 as *const libc::c_char,
23665        };
23666        init
23667    },
23668];
23669#[no_mangle]
23670pub static mut ACL_GETUSER_Args: [redisCommandArg; 2] = [
23671    {
23672        let mut init = redisCommandArg {
23673            name: b"username\0" as *const u8 as *const libc::c_char,
23674            type_0: ARG_TYPE_STRING,
23675            key_spec_index: -(1 as libc::c_int),
23676            token: 0 as *const libc::c_char,
23677            summary: 0 as *const libc::c_char,
23678            since: 0 as *const libc::c_char,
23679            flags: 0 as libc::c_int,
23680            deprecated_since: 0 as *const libc::c_char,
23681            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23682            num_args: 0,
23683        };
23684        init
23685    },
23686    {
23687        let mut init = redisCommandArg {
23688            name: 0 as *const libc::c_char,
23689            type_0: ARG_TYPE_STRING,
23690            key_spec_index: 0,
23691            token: 0 as *const libc::c_char,
23692            summary: 0 as *const libc::c_char,
23693            since: 0 as *const libc::c_char,
23694            flags: 0,
23695            deprecated_since: 0 as *const libc::c_char,
23696            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23697            num_args: 0,
23698        };
23699        init
23700    },
23701];
23702#[no_mangle]
23703pub static mut ACL_LOG_operation_Subargs: [redisCommandArg; 3] = [
23704    {
23705        let mut init = redisCommandArg {
23706            name: b"count\0" as *const u8 as *const libc::c_char,
23707            type_0: ARG_TYPE_INTEGER,
23708            key_spec_index: -(1 as libc::c_int),
23709            token: 0 as *const libc::c_char,
23710            summary: 0 as *const libc::c_char,
23711            since: 0 as *const libc::c_char,
23712            flags: 0 as libc::c_int,
23713            deprecated_since: 0 as *const libc::c_char,
23714            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23715            num_args: 0,
23716        };
23717        init
23718    },
23719    {
23720        let mut init = redisCommandArg {
23721            name: b"reset\0" as *const u8 as *const libc::c_char,
23722            type_0: ARG_TYPE_PURE_TOKEN,
23723            key_spec_index: -(1 as libc::c_int),
23724            token: b"RESET\0" as *const u8 as *const libc::c_char,
23725            summary: 0 as *const libc::c_char,
23726            since: 0 as *const libc::c_char,
23727            flags: 0 as libc::c_int,
23728            deprecated_since: 0 as *const libc::c_char,
23729            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23730            num_args: 0,
23731        };
23732        init
23733    },
23734    {
23735        let mut init = redisCommandArg {
23736            name: 0 as *const libc::c_char,
23737            type_0: ARG_TYPE_STRING,
23738            key_spec_index: 0,
23739            token: 0 as *const libc::c_char,
23740            summary: 0 as *const libc::c_char,
23741            since: 0 as *const libc::c_char,
23742            flags: 0,
23743            deprecated_since: 0 as *const libc::c_char,
23744            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23745            num_args: 0,
23746        };
23747        init
23748    },
23749];
23750#[no_mangle]
23751pub static mut ACL_LOG_Args: [redisCommandArg; 2] = unsafe {
23752    [
23753        {
23754            let mut init = redisCommandArg {
23755                name: b"operation\0" as *const u8 as *const libc::c_char,
23756                type_0: ARG_TYPE_ONEOF,
23757                key_spec_index: -(1 as libc::c_int),
23758                token: 0 as *const libc::c_char,
23759                summary: 0 as *const libc::c_char,
23760                since: 0 as *const libc::c_char,
23761                flags: (1 as libc::c_int) << 0 as libc::c_int,
23762                deprecated_since: 0 as *const libc::c_char,
23763                subargs: ACL_LOG_operation_Subargs.as_ptr() as *mut _,
23764                num_args: 0,
23765            };
23766            init
23767        },
23768        {
23769            let mut init = redisCommandArg {
23770                name: 0 as *const libc::c_char,
23771                type_0: ARG_TYPE_STRING,
23772                key_spec_index: 0,
23773                token: 0 as *const libc::c_char,
23774                summary: 0 as *const libc::c_char,
23775                since: 0 as *const libc::c_char,
23776                flags: 0,
23777                deprecated_since: 0 as *const libc::c_char,
23778                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23779                num_args: 0,
23780            };
23781            init
23782        },
23783    ]
23784};
23785#[no_mangle]
23786pub static mut ACL_SETUSER_History: [commandHistory; 3] = [
23787    {
23788        let mut init = commandHistory {
23789            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
23790            changes: b"Added Pub/Sub channel patterns.\0" as *const u8
23791                as *const libc::c_char,
23792        };
23793        init
23794    },
23795    {
23796        let mut init = commandHistory {
23797            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
23798            changes: b"Added selectors and key based permissions.\0" as *const u8
23799                as *const libc::c_char,
23800        };
23801        init
23802    },
23803    {
23804        let mut init = commandHistory {
23805            since: 0 as *const libc::c_char,
23806            changes: 0 as *const libc::c_char,
23807        };
23808        init
23809    },
23810];
23811#[no_mangle]
23812pub static mut ACL_SETUSER_Args: [redisCommandArg; 3] = [
23813    {
23814        let mut init = redisCommandArg {
23815            name: b"username\0" as *const u8 as *const libc::c_char,
23816            type_0: ARG_TYPE_STRING,
23817            key_spec_index: -(1 as libc::c_int),
23818            token: 0 as *const libc::c_char,
23819            summary: 0 as *const libc::c_char,
23820            since: 0 as *const libc::c_char,
23821            flags: 0 as libc::c_int,
23822            deprecated_since: 0 as *const libc::c_char,
23823            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23824            num_args: 0,
23825        };
23826        init
23827    },
23828    {
23829        let mut init = redisCommandArg {
23830            name: b"rule\0" as *const u8 as *const libc::c_char,
23831            type_0: ARG_TYPE_STRING,
23832            key_spec_index: -(1 as libc::c_int),
23833            token: 0 as *const libc::c_char,
23834            summary: 0 as *const libc::c_char,
23835            since: 0 as *const libc::c_char,
23836            flags: (1 as libc::c_int) << 0 as libc::c_int
23837                | (1 as libc::c_int) << 1 as libc::c_int,
23838            deprecated_since: 0 as *const libc::c_char,
23839            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23840            num_args: 0,
23841        };
23842        init
23843    },
23844    {
23845        let mut init = redisCommandArg {
23846            name: 0 as *const libc::c_char,
23847            type_0: ARG_TYPE_STRING,
23848            key_spec_index: 0,
23849            token: 0 as *const libc::c_char,
23850            summary: 0 as *const libc::c_char,
23851            since: 0 as *const libc::c_char,
23852            flags: 0,
23853            deprecated_since: 0 as *const libc::c_char,
23854            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
23855            num_args: 0,
23856        };
23857        init
23858    },
23859];
23860#[no_mangle]
23861pub static mut ACL_Subcommands: [redisCommand; 14] = unsafe {
23862    [
23863        {
23864            let mut init = redisCommand {
23865                declared_name: b"cat\0" as *const u8 as *const libc::c_char,
23866                summary: b"List the ACL categories or the commands inside a category\0"
23867                    as *const u8 as *const libc::c_char,
23868                complexity: b"O(1) since the categories and commands are a fixed set.\0"
23869                    as *const u8 as *const libc::c_char,
23870                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
23871                doc_flags: 0 as libc::c_int,
23872                replaced_by: 0 as *const libc::c_char,
23873                deprecated_since: 0 as *const libc::c_char,
23874                group: COMMAND_GROUP_SERVER,
23875                history: 0 as *const commandHistory as *mut commandHistory,
23876                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23877                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
23878                arity: -(2 as libc::c_int),
23879                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
23880                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
23881                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
23882                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
23883                acl_categories: 0 as libc::c_int as uint64_t,
23884                key_specs_static: [keySpec {
23885                    notes: 0 as *const libc::c_char,
23886                    flags: 0,
23887                    begin_search_type: KSPEC_BS_INVALID,
23888                    bs: C2RustUnnamed_3 {
23889                        index: C2RustUnnamed_5 { pos: 0 },
23890                    },
23891                    find_keys_type: KSPEC_FK_INVALID,
23892                    fk: C2RustUnnamed_0 {
23893                        range: C2RustUnnamed_2 {
23894                            lastkey: 0,
23895                            keystep: 0,
23896                            limit: 0,
23897                        },
23898                    },
23899                }; 4],
23900                getkeys_proc: None,
23901                subcommands: 0 as *const redisCommand as *mut redisCommand,
23902                args: ACL_CAT_Args.as_ptr() as *mut _,
23903                microseconds: 0,
23904                calls: 0,
23905                rejected_calls: 0,
23906                failed_calls: 0,
23907                id: 0,
23908                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23909                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23910                key_specs: 0 as *const keySpec as *mut keySpec,
23911                legacy_range_key_spec: keySpec {
23912                    notes: 0 as *const libc::c_char,
23913                    flags: 0,
23914                    begin_search_type: KSPEC_BS_INVALID,
23915                    bs: C2RustUnnamed_3 {
23916                        index: C2RustUnnamed_5 { pos: 0 },
23917                    },
23918                    find_keys_type: KSPEC_FK_INVALID,
23919                    fk: C2RustUnnamed_0 {
23920                        range: C2RustUnnamed_2 {
23921                            lastkey: 0,
23922                            keystep: 0,
23923                            limit: 0,
23924                        },
23925                    },
23926                },
23927                num_args: 0,
23928                num_history: 0,
23929                num_tips: 0,
23930                key_specs_num: 0,
23931                key_specs_max: 0,
23932                subcommands_dict: 0 as *const dict as *mut dict,
23933                parent: 0 as *const redisCommand as *mut redisCommand,
23934                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
23935            };
23936            init
23937        },
23938        {
23939            let mut init = redisCommand {
23940                declared_name: b"deluser\0" as *const u8 as *const libc::c_char,
23941                summary: b"Remove the specified ACL users and the associated rules\0"
23942                    as *const u8 as *const libc::c_char,
23943                complexity: b"O(1) amortized time considering the typical user.\0"
23944                    as *const u8 as *const libc::c_char,
23945                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
23946                doc_flags: 0 as libc::c_int,
23947                replaced_by: 0 as *const libc::c_char,
23948                deprecated_since: 0 as *const libc::c_char,
23949                group: COMMAND_GROUP_SERVER,
23950                history: 0 as *const commandHistory as *mut commandHistory,
23951                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
23952                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
23953                arity: -(3 as libc::c_int),
23954                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
23955                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
23956                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
23957                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
23958                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
23959                acl_categories: 0 as libc::c_int as uint64_t,
23960                key_specs_static: [keySpec {
23961                    notes: 0 as *const libc::c_char,
23962                    flags: 0,
23963                    begin_search_type: KSPEC_BS_INVALID,
23964                    bs: C2RustUnnamed_3 {
23965                        index: C2RustUnnamed_5 { pos: 0 },
23966                    },
23967                    find_keys_type: KSPEC_FK_INVALID,
23968                    fk: C2RustUnnamed_0 {
23969                        range: C2RustUnnamed_2 {
23970                            lastkey: 0,
23971                            keystep: 0,
23972                            limit: 0,
23973                        },
23974                    },
23975                }; 4],
23976                getkeys_proc: None,
23977                subcommands: 0 as *const redisCommand as *mut redisCommand,
23978                args: ACL_DELUSER_Args.as_ptr() as *mut _,
23979                microseconds: 0,
23980                calls: 0,
23981                rejected_calls: 0,
23982                failed_calls: 0,
23983                id: 0,
23984                fullname: 0 as *const libc::c_char as *mut libc::c_char,
23985                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
23986                key_specs: 0 as *const keySpec as *mut keySpec,
23987                legacy_range_key_spec: keySpec {
23988                    notes: 0 as *const libc::c_char,
23989                    flags: 0,
23990                    begin_search_type: KSPEC_BS_INVALID,
23991                    bs: C2RustUnnamed_3 {
23992                        index: C2RustUnnamed_5 { pos: 0 },
23993                    },
23994                    find_keys_type: KSPEC_FK_INVALID,
23995                    fk: C2RustUnnamed_0 {
23996                        range: C2RustUnnamed_2 {
23997                            lastkey: 0,
23998                            keystep: 0,
23999                            limit: 0,
24000                        },
24001                    },
24002                },
24003                num_args: 0,
24004                num_history: 0,
24005                num_tips: 0,
24006                key_specs_num: 0,
24007                key_specs_max: 0,
24008                subcommands_dict: 0 as *const dict as *mut dict,
24009                parent: 0 as *const redisCommand as *mut redisCommand,
24010                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24011            };
24012            init
24013        },
24014        {
24015            let mut init = redisCommand {
24016                declared_name: b"dryrun\0" as *const u8 as *const libc::c_char,
24017                summary: b"Returns whether the user can execute the given command without executing the command.\0"
24018                    as *const u8 as *const libc::c_char,
24019                complexity: b"O(1).\0" as *const u8 as *const libc::c_char,
24020                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
24021                doc_flags: 0 as libc::c_int,
24022                replaced_by: 0 as *const libc::c_char,
24023                deprecated_since: 0 as *const libc::c_char,
24024                group: COMMAND_GROUP_SERVER,
24025                history: 0 as *const commandHistory as *mut commandHistory,
24026                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24027                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24028                arity: -(4 as libc::c_int),
24029                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24030                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24031                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24032                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24033                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24034                acl_categories: 0 as libc::c_int as uint64_t,
24035                key_specs_static: [keySpec {
24036                    notes: 0 as *const libc::c_char,
24037                    flags: 0,
24038                    begin_search_type: KSPEC_BS_INVALID,
24039                    bs: C2RustUnnamed_3 {
24040                        index: C2RustUnnamed_5 { pos: 0 },
24041                    },
24042                    find_keys_type: KSPEC_FK_INVALID,
24043                    fk: C2RustUnnamed_0 {
24044                        range: C2RustUnnamed_2 {
24045                            lastkey: 0,
24046                            keystep: 0,
24047                            limit: 0,
24048                        },
24049                    },
24050                }; 4],
24051                getkeys_proc: None,
24052                subcommands: 0 as *const redisCommand as *mut redisCommand,
24053                args: ACL_DRYRUN_Args.as_ptr() as *mut _,
24054                microseconds: 0,
24055                calls: 0,
24056                rejected_calls: 0,
24057                failed_calls: 0,
24058                id: 0,
24059                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24060                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24061                key_specs: 0 as *const keySpec as *mut keySpec,
24062                legacy_range_key_spec: keySpec {
24063                    notes: 0 as *const libc::c_char,
24064                    flags: 0,
24065                    begin_search_type: KSPEC_BS_INVALID,
24066                    bs: C2RustUnnamed_3 {
24067                        index: C2RustUnnamed_5 { pos: 0 },
24068                    },
24069                    find_keys_type: KSPEC_FK_INVALID,
24070                    fk: C2RustUnnamed_0 {
24071                        range: C2RustUnnamed_2 {
24072                            lastkey: 0,
24073                            keystep: 0,
24074                            limit: 0,
24075                        },
24076                    },
24077                },
24078                num_args: 0,
24079                num_history: 0,
24080                num_tips: 0,
24081                key_specs_num: 0,
24082                key_specs_max: 0,
24083                subcommands_dict: 0 as *const dict as *mut dict,
24084                parent: 0 as *const redisCommand as *mut redisCommand,
24085                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24086            };
24087            init
24088        },
24089        {
24090            let mut init = redisCommand {
24091                declared_name: b"genpass\0" as *const u8 as *const libc::c_char,
24092                summary: b"Generate a pseudorandom secure password to use for ACL users\0"
24093                    as *const u8 as *const libc::c_char,
24094                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
24095                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24096                doc_flags: 0 as libc::c_int,
24097                replaced_by: 0 as *const libc::c_char,
24098                deprecated_since: 0 as *const libc::c_char,
24099                group: COMMAND_GROUP_SERVER,
24100                history: 0 as *const commandHistory as *mut commandHistory,
24101                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24102                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24103                arity: -(2 as libc::c_int),
24104                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
24105                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24106                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24107                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24108                acl_categories: 0 as libc::c_int as uint64_t,
24109                key_specs_static: [keySpec {
24110                    notes: 0 as *const libc::c_char,
24111                    flags: 0,
24112                    begin_search_type: KSPEC_BS_INVALID,
24113                    bs: C2RustUnnamed_3 {
24114                        index: C2RustUnnamed_5 { pos: 0 },
24115                    },
24116                    find_keys_type: KSPEC_FK_INVALID,
24117                    fk: C2RustUnnamed_0 {
24118                        range: C2RustUnnamed_2 {
24119                            lastkey: 0,
24120                            keystep: 0,
24121                            limit: 0,
24122                        },
24123                    },
24124                }; 4],
24125                getkeys_proc: None,
24126                subcommands: 0 as *const redisCommand as *mut redisCommand,
24127                args: ACL_GENPASS_Args.as_ptr() as *mut _,
24128                microseconds: 0,
24129                calls: 0,
24130                rejected_calls: 0,
24131                failed_calls: 0,
24132                id: 0,
24133                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24134                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24135                key_specs: 0 as *const keySpec as *mut keySpec,
24136                legacy_range_key_spec: keySpec {
24137                    notes: 0 as *const libc::c_char,
24138                    flags: 0,
24139                    begin_search_type: KSPEC_BS_INVALID,
24140                    bs: C2RustUnnamed_3 {
24141                        index: C2RustUnnamed_5 { pos: 0 },
24142                    },
24143                    find_keys_type: KSPEC_FK_INVALID,
24144                    fk: C2RustUnnamed_0 {
24145                        range: C2RustUnnamed_2 {
24146                            lastkey: 0,
24147                            keystep: 0,
24148                            limit: 0,
24149                        },
24150                    },
24151                },
24152                num_args: 0,
24153                num_history: 0,
24154                num_tips: 0,
24155                key_specs_num: 0,
24156                key_specs_max: 0,
24157                subcommands_dict: 0 as *const dict as *mut dict,
24158                parent: 0 as *const redisCommand as *mut redisCommand,
24159                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24160            };
24161            init
24162        },
24163        {
24164            let mut init = redisCommand {
24165                declared_name: b"getuser\0" as *const u8 as *const libc::c_char,
24166                summary: b"Get the rules for a specific ACL user\0" as *const u8
24167                    as *const libc::c_char,
24168                complexity: b"O(N). Where N is the number of password, command and pattern rules that the user has.\0"
24169                    as *const u8 as *const libc::c_char,
24170                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24171                doc_flags: 0 as libc::c_int,
24172                replaced_by: 0 as *const libc::c_char,
24173                deprecated_since: 0 as *const libc::c_char,
24174                group: COMMAND_GROUP_SERVER,
24175                history: ACL_GETUSER_History.as_ptr() as *mut _,
24176                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24177                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24178                arity: 3 as libc::c_int,
24179                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24180                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24181                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24182                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24183                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24184                acl_categories: 0 as libc::c_int as uint64_t,
24185                key_specs_static: [keySpec {
24186                    notes: 0 as *const libc::c_char,
24187                    flags: 0,
24188                    begin_search_type: KSPEC_BS_INVALID,
24189                    bs: C2RustUnnamed_3 {
24190                        index: C2RustUnnamed_5 { pos: 0 },
24191                    },
24192                    find_keys_type: KSPEC_FK_INVALID,
24193                    fk: C2RustUnnamed_0 {
24194                        range: C2RustUnnamed_2 {
24195                            lastkey: 0,
24196                            keystep: 0,
24197                            limit: 0,
24198                        },
24199                    },
24200                }; 4],
24201                getkeys_proc: None,
24202                subcommands: 0 as *const redisCommand as *mut redisCommand,
24203                args: ACL_GETUSER_Args.as_ptr() as *mut _,
24204                microseconds: 0,
24205                calls: 0,
24206                rejected_calls: 0,
24207                failed_calls: 0,
24208                id: 0,
24209                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24210                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24211                key_specs: 0 as *const keySpec as *mut keySpec,
24212                legacy_range_key_spec: keySpec {
24213                    notes: 0 as *const libc::c_char,
24214                    flags: 0,
24215                    begin_search_type: KSPEC_BS_INVALID,
24216                    bs: C2RustUnnamed_3 {
24217                        index: C2RustUnnamed_5 { pos: 0 },
24218                    },
24219                    find_keys_type: KSPEC_FK_INVALID,
24220                    fk: C2RustUnnamed_0 {
24221                        range: C2RustUnnamed_2 {
24222                            lastkey: 0,
24223                            keystep: 0,
24224                            limit: 0,
24225                        },
24226                    },
24227                },
24228                num_args: 0,
24229                num_history: 0,
24230                num_tips: 0,
24231                key_specs_num: 0,
24232                key_specs_max: 0,
24233                subcommands_dict: 0 as *const dict as *mut dict,
24234                parent: 0 as *const redisCommand as *mut redisCommand,
24235                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24236            };
24237            init
24238        },
24239        {
24240            let mut init = redisCommand {
24241                declared_name: b"help\0" as *const u8 as *const libc::c_char,
24242                summary: b"Show helpful text about the different subcommands\0"
24243                    as *const u8 as *const libc::c_char,
24244                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
24245                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24246                doc_flags: 0 as libc::c_int,
24247                replaced_by: 0 as *const libc::c_char,
24248                deprecated_since: 0 as *const libc::c_char,
24249                group: COMMAND_GROUP_SERVER,
24250                history: 0 as *const commandHistory as *mut commandHistory,
24251                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24252                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24253                arity: 2 as libc::c_int,
24254                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
24255                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24256                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24257                acl_categories: 0 as libc::c_int as uint64_t,
24258                key_specs_static: [keySpec {
24259                    notes: 0 as *const libc::c_char,
24260                    flags: 0,
24261                    begin_search_type: KSPEC_BS_INVALID,
24262                    bs: C2RustUnnamed_3 {
24263                        index: C2RustUnnamed_5 { pos: 0 },
24264                    },
24265                    find_keys_type: KSPEC_FK_INVALID,
24266                    fk: C2RustUnnamed_0 {
24267                        range: C2RustUnnamed_2 {
24268                            lastkey: 0,
24269                            keystep: 0,
24270                            limit: 0,
24271                        },
24272                    },
24273                }; 4],
24274                getkeys_proc: None,
24275                subcommands: 0 as *const redisCommand as *mut redisCommand,
24276                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24277                microseconds: 0,
24278                calls: 0,
24279                rejected_calls: 0,
24280                failed_calls: 0,
24281                id: 0,
24282                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24283                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24284                key_specs: 0 as *const keySpec as *mut keySpec,
24285                legacy_range_key_spec: keySpec {
24286                    notes: 0 as *const libc::c_char,
24287                    flags: 0,
24288                    begin_search_type: KSPEC_BS_INVALID,
24289                    bs: C2RustUnnamed_3 {
24290                        index: C2RustUnnamed_5 { pos: 0 },
24291                    },
24292                    find_keys_type: KSPEC_FK_INVALID,
24293                    fk: C2RustUnnamed_0 {
24294                        range: C2RustUnnamed_2 {
24295                            lastkey: 0,
24296                            keystep: 0,
24297                            limit: 0,
24298                        },
24299                    },
24300                },
24301                num_args: 0,
24302                num_history: 0,
24303                num_tips: 0,
24304                key_specs_num: 0,
24305                key_specs_max: 0,
24306                subcommands_dict: 0 as *const dict as *mut dict,
24307                parent: 0 as *const redisCommand as *mut redisCommand,
24308                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24309            };
24310            init
24311        },
24312        {
24313            let mut init = redisCommand {
24314                declared_name: b"list\0" as *const u8 as *const libc::c_char,
24315                summary: b"List the current ACL rules in ACL config file format\0"
24316                    as *const u8 as *const libc::c_char,
24317                complexity: b"O(N). Where N is the number of configured users.\0"
24318                    as *const u8 as *const libc::c_char,
24319                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24320                doc_flags: 0 as libc::c_int,
24321                replaced_by: 0 as *const libc::c_char,
24322                deprecated_since: 0 as *const libc::c_char,
24323                group: COMMAND_GROUP_SERVER,
24324                history: 0 as *const commandHistory as *mut commandHistory,
24325                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24326                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24327                arity: 2 as libc::c_int,
24328                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24329                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24330                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24331                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24332                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24333                acl_categories: 0 as libc::c_int as uint64_t,
24334                key_specs_static: [keySpec {
24335                    notes: 0 as *const libc::c_char,
24336                    flags: 0,
24337                    begin_search_type: KSPEC_BS_INVALID,
24338                    bs: C2RustUnnamed_3 {
24339                        index: C2RustUnnamed_5 { pos: 0 },
24340                    },
24341                    find_keys_type: KSPEC_FK_INVALID,
24342                    fk: C2RustUnnamed_0 {
24343                        range: C2RustUnnamed_2 {
24344                            lastkey: 0,
24345                            keystep: 0,
24346                            limit: 0,
24347                        },
24348                    },
24349                }; 4],
24350                getkeys_proc: None,
24351                subcommands: 0 as *const redisCommand as *mut redisCommand,
24352                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24353                microseconds: 0,
24354                calls: 0,
24355                rejected_calls: 0,
24356                failed_calls: 0,
24357                id: 0,
24358                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24359                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24360                key_specs: 0 as *const keySpec as *mut keySpec,
24361                legacy_range_key_spec: keySpec {
24362                    notes: 0 as *const libc::c_char,
24363                    flags: 0,
24364                    begin_search_type: KSPEC_BS_INVALID,
24365                    bs: C2RustUnnamed_3 {
24366                        index: C2RustUnnamed_5 { pos: 0 },
24367                    },
24368                    find_keys_type: KSPEC_FK_INVALID,
24369                    fk: C2RustUnnamed_0 {
24370                        range: C2RustUnnamed_2 {
24371                            lastkey: 0,
24372                            keystep: 0,
24373                            limit: 0,
24374                        },
24375                    },
24376                },
24377                num_args: 0,
24378                num_history: 0,
24379                num_tips: 0,
24380                key_specs_num: 0,
24381                key_specs_max: 0,
24382                subcommands_dict: 0 as *const dict as *mut dict,
24383                parent: 0 as *const redisCommand as *mut redisCommand,
24384                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24385            };
24386            init
24387        },
24388        {
24389            let mut init = redisCommand {
24390                declared_name: b"load\0" as *const u8 as *const libc::c_char,
24391                summary: b"Reload the ACLs from the configured ACL file\0" as *const u8
24392                    as *const libc::c_char,
24393                complexity: b"O(N). Where N is the number of configured users.\0"
24394                    as *const u8 as *const libc::c_char,
24395                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24396                doc_flags: 0 as libc::c_int,
24397                replaced_by: 0 as *const libc::c_char,
24398                deprecated_since: 0 as *const libc::c_char,
24399                group: COMMAND_GROUP_SERVER,
24400                history: 0 as *const commandHistory as *mut commandHistory,
24401                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24402                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24403                arity: 2 as libc::c_int,
24404                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24405                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24406                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24407                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24408                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24409                acl_categories: 0 as libc::c_int as uint64_t,
24410                key_specs_static: [keySpec {
24411                    notes: 0 as *const libc::c_char,
24412                    flags: 0,
24413                    begin_search_type: KSPEC_BS_INVALID,
24414                    bs: C2RustUnnamed_3 {
24415                        index: C2RustUnnamed_5 { pos: 0 },
24416                    },
24417                    find_keys_type: KSPEC_FK_INVALID,
24418                    fk: C2RustUnnamed_0 {
24419                        range: C2RustUnnamed_2 {
24420                            lastkey: 0,
24421                            keystep: 0,
24422                            limit: 0,
24423                        },
24424                    },
24425                }; 4],
24426                getkeys_proc: None,
24427                subcommands: 0 as *const redisCommand as *mut redisCommand,
24428                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24429                microseconds: 0,
24430                calls: 0,
24431                rejected_calls: 0,
24432                failed_calls: 0,
24433                id: 0,
24434                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24435                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24436                key_specs: 0 as *const keySpec as *mut keySpec,
24437                legacy_range_key_spec: keySpec {
24438                    notes: 0 as *const libc::c_char,
24439                    flags: 0,
24440                    begin_search_type: KSPEC_BS_INVALID,
24441                    bs: C2RustUnnamed_3 {
24442                        index: C2RustUnnamed_5 { pos: 0 },
24443                    },
24444                    find_keys_type: KSPEC_FK_INVALID,
24445                    fk: C2RustUnnamed_0 {
24446                        range: C2RustUnnamed_2 {
24447                            lastkey: 0,
24448                            keystep: 0,
24449                            limit: 0,
24450                        },
24451                    },
24452                },
24453                num_args: 0,
24454                num_history: 0,
24455                num_tips: 0,
24456                key_specs_num: 0,
24457                key_specs_max: 0,
24458                subcommands_dict: 0 as *const dict as *mut dict,
24459                parent: 0 as *const redisCommand as *mut redisCommand,
24460                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24461            };
24462            init
24463        },
24464        {
24465            let mut init = redisCommand {
24466                declared_name: b"log\0" as *const u8 as *const libc::c_char,
24467                summary: b"List latest events denied because of ACLs in place\0"
24468                    as *const u8 as *const libc::c_char,
24469                complexity: b"O(N) with N being the number of entries shown.\0"
24470                    as *const u8 as *const libc::c_char,
24471                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24472                doc_flags: 0 as libc::c_int,
24473                replaced_by: 0 as *const libc::c_char,
24474                deprecated_since: 0 as *const libc::c_char,
24475                group: COMMAND_GROUP_SERVER,
24476                history: 0 as *const commandHistory as *mut commandHistory,
24477                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24478                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24479                arity: -(2 as libc::c_int),
24480                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24481                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24482                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24483                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24484                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24485                acl_categories: 0 as libc::c_int as uint64_t,
24486                key_specs_static: [keySpec {
24487                    notes: 0 as *const libc::c_char,
24488                    flags: 0,
24489                    begin_search_type: KSPEC_BS_INVALID,
24490                    bs: C2RustUnnamed_3 {
24491                        index: C2RustUnnamed_5 { pos: 0 },
24492                    },
24493                    find_keys_type: KSPEC_FK_INVALID,
24494                    fk: C2RustUnnamed_0 {
24495                        range: C2RustUnnamed_2 {
24496                            lastkey: 0,
24497                            keystep: 0,
24498                            limit: 0,
24499                        },
24500                    },
24501                }; 4],
24502                getkeys_proc: None,
24503                subcommands: 0 as *const redisCommand as *mut redisCommand,
24504                args: ACL_LOG_Args.as_ptr() as *mut _,
24505                microseconds: 0,
24506                calls: 0,
24507                rejected_calls: 0,
24508                failed_calls: 0,
24509                id: 0,
24510                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24511                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24512                key_specs: 0 as *const keySpec as *mut keySpec,
24513                legacy_range_key_spec: keySpec {
24514                    notes: 0 as *const libc::c_char,
24515                    flags: 0,
24516                    begin_search_type: KSPEC_BS_INVALID,
24517                    bs: C2RustUnnamed_3 {
24518                        index: C2RustUnnamed_5 { pos: 0 },
24519                    },
24520                    find_keys_type: KSPEC_FK_INVALID,
24521                    fk: C2RustUnnamed_0 {
24522                        range: C2RustUnnamed_2 {
24523                            lastkey: 0,
24524                            keystep: 0,
24525                            limit: 0,
24526                        },
24527                    },
24528                },
24529                num_args: 0,
24530                num_history: 0,
24531                num_tips: 0,
24532                key_specs_num: 0,
24533                key_specs_max: 0,
24534                subcommands_dict: 0 as *const dict as *mut dict,
24535                parent: 0 as *const redisCommand as *mut redisCommand,
24536                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24537            };
24538            init
24539        },
24540        {
24541            let mut init = redisCommand {
24542                declared_name: b"save\0" as *const u8 as *const libc::c_char,
24543                summary: b"Save the current ACL rules in the configured ACL file\0"
24544                    as *const u8 as *const libc::c_char,
24545                complexity: b"O(N). Where N is the number of configured users.\0"
24546                    as *const u8 as *const libc::c_char,
24547                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24548                doc_flags: 0 as libc::c_int,
24549                replaced_by: 0 as *const libc::c_char,
24550                deprecated_since: 0 as *const libc::c_char,
24551                group: COMMAND_GROUP_SERVER,
24552                history: 0 as *const commandHistory as *mut commandHistory,
24553                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24554                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24555                arity: 2 as libc::c_int,
24556                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24557                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24558                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24559                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24560                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24561                acl_categories: 0 as libc::c_int as uint64_t,
24562                key_specs_static: [keySpec {
24563                    notes: 0 as *const libc::c_char,
24564                    flags: 0,
24565                    begin_search_type: KSPEC_BS_INVALID,
24566                    bs: C2RustUnnamed_3 {
24567                        index: C2RustUnnamed_5 { pos: 0 },
24568                    },
24569                    find_keys_type: KSPEC_FK_INVALID,
24570                    fk: C2RustUnnamed_0 {
24571                        range: C2RustUnnamed_2 {
24572                            lastkey: 0,
24573                            keystep: 0,
24574                            limit: 0,
24575                        },
24576                    },
24577                }; 4],
24578                getkeys_proc: None,
24579                subcommands: 0 as *const redisCommand as *mut redisCommand,
24580                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24581                microseconds: 0,
24582                calls: 0,
24583                rejected_calls: 0,
24584                failed_calls: 0,
24585                id: 0,
24586                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24587                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24588                key_specs: 0 as *const keySpec as *mut keySpec,
24589                legacy_range_key_spec: keySpec {
24590                    notes: 0 as *const libc::c_char,
24591                    flags: 0,
24592                    begin_search_type: KSPEC_BS_INVALID,
24593                    bs: C2RustUnnamed_3 {
24594                        index: C2RustUnnamed_5 { pos: 0 },
24595                    },
24596                    find_keys_type: KSPEC_FK_INVALID,
24597                    fk: C2RustUnnamed_0 {
24598                        range: C2RustUnnamed_2 {
24599                            lastkey: 0,
24600                            keystep: 0,
24601                            limit: 0,
24602                        },
24603                    },
24604                },
24605                num_args: 0,
24606                num_history: 0,
24607                num_tips: 0,
24608                key_specs_num: 0,
24609                key_specs_max: 0,
24610                subcommands_dict: 0 as *const dict as *mut dict,
24611                parent: 0 as *const redisCommand as *mut redisCommand,
24612                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24613            };
24614            init
24615        },
24616        {
24617            let mut init = redisCommand {
24618                declared_name: b"setuser\0" as *const u8 as *const libc::c_char,
24619                summary: b"Modify or create the rules for a specific ACL user\0"
24620                    as *const u8 as *const libc::c_char,
24621                complexity: b"O(N). Where N is the number of rules provided.\0"
24622                    as *const u8 as *const libc::c_char,
24623                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24624                doc_flags: 0 as libc::c_int,
24625                replaced_by: 0 as *const libc::c_char,
24626                deprecated_since: 0 as *const libc::c_char,
24627                group: COMMAND_GROUP_SERVER,
24628                history: ACL_SETUSER_History.as_ptr() as *mut _,
24629                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24630                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24631                arity: -(3 as libc::c_int),
24632                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24633                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24634                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24635                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24636                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24637                acl_categories: 0 as libc::c_int as uint64_t,
24638                key_specs_static: [keySpec {
24639                    notes: 0 as *const libc::c_char,
24640                    flags: 0,
24641                    begin_search_type: KSPEC_BS_INVALID,
24642                    bs: C2RustUnnamed_3 {
24643                        index: C2RustUnnamed_5 { pos: 0 },
24644                    },
24645                    find_keys_type: KSPEC_FK_INVALID,
24646                    fk: C2RustUnnamed_0 {
24647                        range: C2RustUnnamed_2 {
24648                            lastkey: 0,
24649                            keystep: 0,
24650                            limit: 0,
24651                        },
24652                    },
24653                }; 4],
24654                getkeys_proc: None,
24655                subcommands: 0 as *const redisCommand as *mut redisCommand,
24656                args: ACL_SETUSER_Args.as_ptr() as *mut _,
24657                microseconds: 0,
24658                calls: 0,
24659                rejected_calls: 0,
24660                failed_calls: 0,
24661                id: 0,
24662                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24663                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24664                key_specs: 0 as *const keySpec as *mut keySpec,
24665                legacy_range_key_spec: keySpec {
24666                    notes: 0 as *const libc::c_char,
24667                    flags: 0,
24668                    begin_search_type: KSPEC_BS_INVALID,
24669                    bs: C2RustUnnamed_3 {
24670                        index: C2RustUnnamed_5 { pos: 0 },
24671                    },
24672                    find_keys_type: KSPEC_FK_INVALID,
24673                    fk: C2RustUnnamed_0 {
24674                        range: C2RustUnnamed_2 {
24675                            lastkey: 0,
24676                            keystep: 0,
24677                            limit: 0,
24678                        },
24679                    },
24680                },
24681                num_args: 0,
24682                num_history: 0,
24683                num_tips: 0,
24684                key_specs_num: 0,
24685                key_specs_max: 0,
24686                subcommands_dict: 0 as *const dict as *mut dict,
24687                parent: 0 as *const redisCommand as *mut redisCommand,
24688                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24689            };
24690            init
24691        },
24692        {
24693            let mut init = redisCommand {
24694                declared_name: b"users\0" as *const u8 as *const libc::c_char,
24695                summary: b"List the username of all the configured ACL rules\0"
24696                    as *const u8 as *const libc::c_char,
24697                complexity: b"O(N). Where N is the number of configured users.\0"
24698                    as *const u8 as *const libc::c_char,
24699                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24700                doc_flags: 0 as libc::c_int,
24701                replaced_by: 0 as *const libc::c_char,
24702                deprecated_since: 0 as *const libc::c_char,
24703                group: COMMAND_GROUP_SERVER,
24704                history: 0 as *const commandHistory as *mut commandHistory,
24705                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24706                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24707                arity: 2 as libc::c_int,
24708                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
24709                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
24710                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24711                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24712                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24713                acl_categories: 0 as libc::c_int as uint64_t,
24714                key_specs_static: [keySpec {
24715                    notes: 0 as *const libc::c_char,
24716                    flags: 0,
24717                    begin_search_type: KSPEC_BS_INVALID,
24718                    bs: C2RustUnnamed_3 {
24719                        index: C2RustUnnamed_5 { pos: 0 },
24720                    },
24721                    find_keys_type: KSPEC_FK_INVALID,
24722                    fk: C2RustUnnamed_0 {
24723                        range: C2RustUnnamed_2 {
24724                            lastkey: 0,
24725                            keystep: 0,
24726                            limit: 0,
24727                        },
24728                    },
24729                }; 4],
24730                getkeys_proc: None,
24731                subcommands: 0 as *const redisCommand as *mut redisCommand,
24732                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24733                microseconds: 0,
24734                calls: 0,
24735                rejected_calls: 0,
24736                failed_calls: 0,
24737                id: 0,
24738                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24739                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24740                key_specs: 0 as *const keySpec as *mut keySpec,
24741                legacy_range_key_spec: keySpec {
24742                    notes: 0 as *const libc::c_char,
24743                    flags: 0,
24744                    begin_search_type: KSPEC_BS_INVALID,
24745                    bs: C2RustUnnamed_3 {
24746                        index: C2RustUnnamed_5 { pos: 0 },
24747                    },
24748                    find_keys_type: KSPEC_FK_INVALID,
24749                    fk: C2RustUnnamed_0 {
24750                        range: C2RustUnnamed_2 {
24751                            lastkey: 0,
24752                            keystep: 0,
24753                            limit: 0,
24754                        },
24755                    },
24756                },
24757                num_args: 0,
24758                num_history: 0,
24759                num_tips: 0,
24760                key_specs_num: 0,
24761                key_specs_max: 0,
24762                subcommands_dict: 0 as *const dict as *mut dict,
24763                parent: 0 as *const redisCommand as *mut redisCommand,
24764                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24765            };
24766            init
24767        },
24768        {
24769            let mut init = redisCommand {
24770                declared_name: b"whoami\0" as *const u8 as *const libc::c_char,
24771                summary: b"Return the name of the user associated to the current connection\0"
24772                    as *const u8 as *const libc::c_char,
24773                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
24774                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
24775                doc_flags: 0 as libc::c_int,
24776                replaced_by: 0 as *const libc::c_char,
24777                deprecated_since: 0 as *const libc::c_char,
24778                group: COMMAND_GROUP_SERVER,
24779                history: 0 as *const commandHistory as *mut commandHistory,
24780                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24781                proc_0: Some(aclCommand as unsafe extern "C" fn(*mut client) -> ()),
24782                arity: 2 as libc::c_int,
24783                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
24784                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
24785                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
24786                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
24787                acl_categories: 0 as libc::c_int as uint64_t,
24788                key_specs_static: [keySpec {
24789                    notes: 0 as *const libc::c_char,
24790                    flags: 0,
24791                    begin_search_type: KSPEC_BS_INVALID,
24792                    bs: C2RustUnnamed_3 {
24793                        index: C2RustUnnamed_5 { pos: 0 },
24794                    },
24795                    find_keys_type: KSPEC_FK_INVALID,
24796                    fk: C2RustUnnamed_0 {
24797                        range: C2RustUnnamed_2 {
24798                            lastkey: 0,
24799                            keystep: 0,
24800                            limit: 0,
24801                        },
24802                    },
24803                }; 4],
24804                getkeys_proc: None,
24805                subcommands: 0 as *const redisCommand as *mut redisCommand,
24806                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24807                microseconds: 0,
24808                calls: 0,
24809                rejected_calls: 0,
24810                failed_calls: 0,
24811                id: 0,
24812                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24813                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24814                key_specs: 0 as *const keySpec as *mut keySpec,
24815                legacy_range_key_spec: keySpec {
24816                    notes: 0 as *const libc::c_char,
24817                    flags: 0,
24818                    begin_search_type: KSPEC_BS_INVALID,
24819                    bs: C2RustUnnamed_3 {
24820                        index: C2RustUnnamed_5 { pos: 0 },
24821                    },
24822                    find_keys_type: KSPEC_FK_INVALID,
24823                    fk: C2RustUnnamed_0 {
24824                        range: C2RustUnnamed_2 {
24825                            lastkey: 0,
24826                            keystep: 0,
24827                            limit: 0,
24828                        },
24829                    },
24830                },
24831                num_args: 0,
24832                num_history: 0,
24833                num_tips: 0,
24834                key_specs_num: 0,
24835                key_specs_max: 0,
24836                subcommands_dict: 0 as *const dict as *mut dict,
24837                parent: 0 as *const redisCommand as *mut redisCommand,
24838                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24839            };
24840            init
24841        },
24842        {
24843            let mut init = redisCommand {
24844                declared_name: 0 as *const libc::c_char,
24845                summary: 0 as *const libc::c_char,
24846                complexity: 0 as *const libc::c_char,
24847                since: 0 as *const libc::c_char,
24848                doc_flags: 0,
24849                replaced_by: 0 as *const libc::c_char,
24850                deprecated_since: 0 as *const libc::c_char,
24851                group: COMMAND_GROUP_GENERIC,
24852                history: 0 as *const commandHistory as *mut commandHistory,
24853                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
24854                proc_0: None,
24855                arity: 0,
24856                flags: 0,
24857                acl_categories: 0,
24858                key_specs_static: [keySpec {
24859                    notes: 0 as *const libc::c_char,
24860                    flags: 0,
24861                    begin_search_type: KSPEC_BS_INVALID,
24862                    bs: C2RustUnnamed_3 {
24863                        index: C2RustUnnamed_5 { pos: 0 },
24864                    },
24865                    find_keys_type: KSPEC_FK_INVALID,
24866                    fk: C2RustUnnamed_0 {
24867                        range: C2RustUnnamed_2 {
24868                            lastkey: 0,
24869                            keystep: 0,
24870                            limit: 0,
24871                        },
24872                    },
24873                }; 4],
24874                getkeys_proc: None,
24875                subcommands: 0 as *const redisCommand as *mut redisCommand,
24876                args: 0 as *const redisCommandArg as *mut redisCommandArg,
24877                microseconds: 0,
24878                calls: 0,
24879                rejected_calls: 0,
24880                failed_calls: 0,
24881                id: 0,
24882                fullname: 0 as *const libc::c_char as *mut libc::c_char,
24883                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
24884                key_specs: 0 as *const keySpec as *mut keySpec,
24885                legacy_range_key_spec: keySpec {
24886                    notes: 0 as *const libc::c_char,
24887                    flags: 0,
24888                    begin_search_type: KSPEC_BS_INVALID,
24889                    bs: C2RustUnnamed_3 {
24890                        index: C2RustUnnamed_5 { pos: 0 },
24891                    },
24892                    find_keys_type: KSPEC_FK_INVALID,
24893                    fk: C2RustUnnamed_0 {
24894                        range: C2RustUnnamed_2 {
24895                            lastkey: 0,
24896                            keystep: 0,
24897                            limit: 0,
24898                        },
24899                    },
24900                },
24901                num_args: 0,
24902                num_history: 0,
24903                num_tips: 0,
24904                key_specs_num: 0,
24905                key_specs_max: 0,
24906                subcommands_dict: 0 as *const dict as *mut dict,
24907                parent: 0 as *const redisCommand as *mut redisCommand,
24908                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
24909            };
24910            init
24911        },
24912    ]
24913};
24914#[no_mangle]
24915pub static mut BGSAVE_History: [commandHistory; 2] = [
24916    {
24917        let mut init = commandHistory {
24918            since: b"3.2.2\0" as *const u8 as *const libc::c_char,
24919            changes: b"Added the `SCHEDULE` option.\0" as *const u8
24920                as *const libc::c_char,
24921        };
24922        init
24923    },
24924    {
24925        let mut init = commandHistory {
24926            since: 0 as *const libc::c_char,
24927            changes: 0 as *const libc::c_char,
24928        };
24929        init
24930    },
24931];
24932#[no_mangle]
24933pub static mut BGSAVE_Args: [redisCommandArg; 2] = [
24934    {
24935        let mut init = redisCommandArg {
24936            name: b"schedule\0" as *const u8 as *const libc::c_char,
24937            type_0: ARG_TYPE_PURE_TOKEN,
24938            key_spec_index: -(1 as libc::c_int),
24939            token: b"SCHEDULE\0" as *const u8 as *const libc::c_char,
24940            summary: 0 as *const libc::c_char,
24941            since: b"3.2.2\0" as *const u8 as *const libc::c_char,
24942            flags: (1 as libc::c_int) << 0 as libc::c_int,
24943            deprecated_since: 0 as *const libc::c_char,
24944            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
24945            num_args: 0,
24946        };
24947        init
24948    },
24949    {
24950        let mut init = redisCommandArg {
24951            name: 0 as *const libc::c_char,
24952            type_0: ARG_TYPE_STRING,
24953            key_spec_index: 0,
24954            token: 0 as *const libc::c_char,
24955            summary: 0 as *const libc::c_char,
24956            since: 0 as *const libc::c_char,
24957            flags: 0,
24958            deprecated_since: 0 as *const libc::c_char,
24959            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
24960            num_args: 0,
24961        };
24962        init
24963    },
24964];
24965#[no_mangle]
24966pub static mut COMMAND_DOCS_tips: [*const libc::c_char; 2] = [
24967    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
24968    0 as *const libc::c_char,
24969];
24970#[no_mangle]
24971pub static mut COMMAND_DOCS_Args: [redisCommandArg; 2] = [
24972    {
24973        let mut init = redisCommandArg {
24974            name: b"command-name\0" as *const u8 as *const libc::c_char,
24975            type_0: ARG_TYPE_STRING,
24976            key_spec_index: -(1 as libc::c_int),
24977            token: 0 as *const libc::c_char,
24978            summary: 0 as *const libc::c_char,
24979            since: 0 as *const libc::c_char,
24980            flags: (1 as libc::c_int) << 0 as libc::c_int
24981                | (1 as libc::c_int) << 1 as libc::c_int,
24982            deprecated_since: 0 as *const libc::c_char,
24983            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
24984            num_args: 0,
24985        };
24986        init
24987    },
24988    {
24989        let mut init = redisCommandArg {
24990            name: 0 as *const libc::c_char,
24991            type_0: ARG_TYPE_STRING,
24992            key_spec_index: 0,
24993            token: 0 as *const libc::c_char,
24994            summary: 0 as *const libc::c_char,
24995            since: 0 as *const libc::c_char,
24996            flags: 0,
24997            deprecated_since: 0 as *const libc::c_char,
24998            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
24999            num_args: 0,
25000        };
25001        init
25002    },
25003];
25004#[no_mangle]
25005pub static mut COMMAND_INFO_History: [commandHistory; 2] = [
25006    {
25007        let mut init = commandHistory {
25008            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25009            changes: b"Allowed to be called with no argument to get info on all commands.\0"
25010                as *const u8 as *const libc::c_char,
25011        };
25012        init
25013    },
25014    {
25015        let mut init = commandHistory {
25016            since: 0 as *const libc::c_char,
25017            changes: 0 as *const libc::c_char,
25018        };
25019        init
25020    },
25021];
25022#[no_mangle]
25023pub static mut COMMAND_INFO_tips: [*const libc::c_char; 2] = [
25024    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
25025    0 as *const libc::c_char,
25026];
25027#[no_mangle]
25028pub static mut COMMAND_INFO_Args: [redisCommandArg; 2] = [
25029    {
25030        let mut init = redisCommandArg {
25031            name: b"command-name\0" as *const u8 as *const libc::c_char,
25032            type_0: ARG_TYPE_STRING,
25033            key_spec_index: -(1 as libc::c_int),
25034            token: 0 as *const libc::c_char,
25035            summary: 0 as *const libc::c_char,
25036            since: 0 as *const libc::c_char,
25037            flags: (1 as libc::c_int) << 0 as libc::c_int
25038                | (1 as libc::c_int) << 1 as libc::c_int,
25039            deprecated_since: 0 as *const libc::c_char,
25040            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25041            num_args: 0,
25042        };
25043        init
25044    },
25045    {
25046        let mut init = redisCommandArg {
25047            name: 0 as *const libc::c_char,
25048            type_0: ARG_TYPE_STRING,
25049            key_spec_index: 0,
25050            token: 0 as *const libc::c_char,
25051            summary: 0 as *const libc::c_char,
25052            since: 0 as *const libc::c_char,
25053            flags: 0,
25054            deprecated_since: 0 as *const libc::c_char,
25055            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25056            num_args: 0,
25057        };
25058        init
25059    },
25060];
25061#[no_mangle]
25062pub static mut COMMAND_LIST_tips: [*const libc::c_char; 2] = [
25063    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
25064    0 as *const libc::c_char,
25065];
25066#[no_mangle]
25067pub static mut COMMAND_LIST_filterby_Subargs: [redisCommandArg; 4] = [
25068    {
25069        let mut init = redisCommandArg {
25070            name: b"module-name\0" as *const u8 as *const libc::c_char,
25071            type_0: ARG_TYPE_STRING,
25072            key_spec_index: -(1 as libc::c_int),
25073            token: b"MODULE\0" as *const u8 as *const libc::c_char,
25074            summary: 0 as *const libc::c_char,
25075            since: 0 as *const libc::c_char,
25076            flags: 0 as libc::c_int,
25077            deprecated_since: 0 as *const libc::c_char,
25078            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25079            num_args: 0,
25080        };
25081        init
25082    },
25083    {
25084        let mut init = redisCommandArg {
25085            name: b"category\0" as *const u8 as *const libc::c_char,
25086            type_0: ARG_TYPE_STRING,
25087            key_spec_index: -(1 as libc::c_int),
25088            token: b"ACLCAT\0" as *const u8 as *const libc::c_char,
25089            summary: 0 as *const libc::c_char,
25090            since: 0 as *const libc::c_char,
25091            flags: 0 as libc::c_int,
25092            deprecated_since: 0 as *const libc::c_char,
25093            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25094            num_args: 0,
25095        };
25096        init
25097    },
25098    {
25099        let mut init = redisCommandArg {
25100            name: b"pattern\0" as *const u8 as *const libc::c_char,
25101            type_0: ARG_TYPE_PATTERN,
25102            key_spec_index: -(1 as libc::c_int),
25103            token: b"PATTERN\0" as *const u8 as *const libc::c_char,
25104            summary: 0 as *const libc::c_char,
25105            since: 0 as *const libc::c_char,
25106            flags: 0 as libc::c_int,
25107            deprecated_since: 0 as *const libc::c_char,
25108            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25109            num_args: 0,
25110        };
25111        init
25112    },
25113    {
25114        let mut init = redisCommandArg {
25115            name: 0 as *const libc::c_char,
25116            type_0: ARG_TYPE_STRING,
25117            key_spec_index: 0,
25118            token: 0 as *const libc::c_char,
25119            summary: 0 as *const libc::c_char,
25120            since: 0 as *const libc::c_char,
25121            flags: 0,
25122            deprecated_since: 0 as *const libc::c_char,
25123            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25124            num_args: 0,
25125        };
25126        init
25127    },
25128];
25129#[no_mangle]
25130pub static mut COMMAND_LIST_Args: [redisCommandArg; 2] = unsafe {
25131    [
25132        {
25133            let mut init = redisCommandArg {
25134                name: b"filterby\0" as *const u8 as *const libc::c_char,
25135                type_0: ARG_TYPE_ONEOF,
25136                key_spec_index: -(1 as libc::c_int),
25137                token: b"FILTERBY\0" as *const u8 as *const libc::c_char,
25138                summary: 0 as *const libc::c_char,
25139                since: 0 as *const libc::c_char,
25140                flags: (1 as libc::c_int) << 0 as libc::c_int,
25141                deprecated_since: 0 as *const libc::c_char,
25142                subargs: COMMAND_LIST_filterby_Subargs.as_ptr() as *mut _,
25143                num_args: 0,
25144            };
25145            init
25146        },
25147        {
25148            let mut init = redisCommandArg {
25149                name: 0 as *const libc::c_char,
25150                type_0: ARG_TYPE_STRING,
25151                key_spec_index: 0,
25152                token: 0 as *const libc::c_char,
25153                summary: 0 as *const libc::c_char,
25154                since: 0 as *const libc::c_char,
25155                flags: 0,
25156                deprecated_since: 0 as *const libc::c_char,
25157                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25158                num_args: 0,
25159            };
25160            init
25161        },
25162    ]
25163};
25164#[no_mangle]
25165pub static mut COMMAND_Subcommands: [redisCommand; 8] = unsafe {
25166    [
25167        {
25168            let mut init = redisCommand {
25169                declared_name: b"count\0" as *const u8 as *const libc::c_char,
25170                summary: b"Get total number of Redis commands\0" as *const u8
25171                    as *const libc::c_char,
25172                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
25173                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
25174                doc_flags: 0 as libc::c_int,
25175                replaced_by: 0 as *const libc::c_char,
25176                deprecated_since: 0 as *const libc::c_char,
25177                group: COMMAND_GROUP_SERVER,
25178                history: 0 as *const commandHistory as *mut commandHistory,
25179                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25180                proc_0: Some(
25181                    commandCountCommand as unsafe extern "C" fn(*mut client) -> (),
25182                ),
25183                arity: 2 as libc::c_int,
25184                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25185                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25186                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25187                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25188                    as uint64_t,
25189                key_specs_static: [keySpec {
25190                    notes: 0 as *const libc::c_char,
25191                    flags: 0,
25192                    begin_search_type: KSPEC_BS_INVALID,
25193                    bs: C2RustUnnamed_3 {
25194                        index: C2RustUnnamed_5 { pos: 0 },
25195                    },
25196                    find_keys_type: KSPEC_FK_INVALID,
25197                    fk: C2RustUnnamed_0 {
25198                        range: C2RustUnnamed_2 {
25199                            lastkey: 0,
25200                            keystep: 0,
25201                            limit: 0,
25202                        },
25203                    },
25204                }; 4],
25205                getkeys_proc: None,
25206                subcommands: 0 as *const redisCommand as *mut redisCommand,
25207                args: 0 as *const redisCommandArg as *mut redisCommandArg,
25208                microseconds: 0,
25209                calls: 0,
25210                rejected_calls: 0,
25211                failed_calls: 0,
25212                id: 0,
25213                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25214                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25215                key_specs: 0 as *const keySpec as *mut keySpec,
25216                legacy_range_key_spec: keySpec {
25217                    notes: 0 as *const libc::c_char,
25218                    flags: 0,
25219                    begin_search_type: KSPEC_BS_INVALID,
25220                    bs: C2RustUnnamed_3 {
25221                        index: C2RustUnnamed_5 { pos: 0 },
25222                    },
25223                    find_keys_type: KSPEC_FK_INVALID,
25224                    fk: C2RustUnnamed_0 {
25225                        range: C2RustUnnamed_2 {
25226                            lastkey: 0,
25227                            keystep: 0,
25228                            limit: 0,
25229                        },
25230                    },
25231                },
25232                num_args: 0,
25233                num_history: 0,
25234                num_tips: 0,
25235                key_specs_num: 0,
25236                key_specs_max: 0,
25237                subcommands_dict: 0 as *const dict as *mut dict,
25238                parent: 0 as *const redisCommand as *mut redisCommand,
25239                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25240            };
25241            init
25242        },
25243        {
25244            let mut init = redisCommand {
25245                declared_name: b"docs\0" as *const u8 as *const libc::c_char,
25246                summary: b"Get array of specific Redis command documentation\0"
25247                    as *const u8 as *const libc::c_char,
25248                complexity: b"O(N) where N is the number of commands to look up\0"
25249                    as *const u8 as *const libc::c_char,
25250                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25251                doc_flags: 0 as libc::c_int,
25252                replaced_by: 0 as *const libc::c_char,
25253                deprecated_since: 0 as *const libc::c_char,
25254                group: COMMAND_GROUP_SERVER,
25255                history: 0 as *const commandHistory as *mut commandHistory,
25256                tips: COMMAND_DOCS_tips.as_ptr() as *mut _,
25257                proc_0: Some(
25258                    commandDocsCommand as unsafe extern "C" fn(*mut client) -> (),
25259                ),
25260                arity: -(2 as libc::c_int),
25261                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25262                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25263                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25264                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25265                    as uint64_t,
25266                key_specs_static: [keySpec {
25267                    notes: 0 as *const libc::c_char,
25268                    flags: 0,
25269                    begin_search_type: KSPEC_BS_INVALID,
25270                    bs: C2RustUnnamed_3 {
25271                        index: C2RustUnnamed_5 { pos: 0 },
25272                    },
25273                    find_keys_type: KSPEC_FK_INVALID,
25274                    fk: C2RustUnnamed_0 {
25275                        range: C2RustUnnamed_2 {
25276                            lastkey: 0,
25277                            keystep: 0,
25278                            limit: 0,
25279                        },
25280                    },
25281                }; 4],
25282                getkeys_proc: None,
25283                subcommands: 0 as *const redisCommand as *mut redisCommand,
25284                args: COMMAND_DOCS_Args.as_ptr() as *mut _,
25285                microseconds: 0,
25286                calls: 0,
25287                rejected_calls: 0,
25288                failed_calls: 0,
25289                id: 0,
25290                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25291                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25292                key_specs: 0 as *const keySpec as *mut keySpec,
25293                legacy_range_key_spec: keySpec {
25294                    notes: 0 as *const libc::c_char,
25295                    flags: 0,
25296                    begin_search_type: KSPEC_BS_INVALID,
25297                    bs: C2RustUnnamed_3 {
25298                        index: C2RustUnnamed_5 { pos: 0 },
25299                    },
25300                    find_keys_type: KSPEC_FK_INVALID,
25301                    fk: C2RustUnnamed_0 {
25302                        range: C2RustUnnamed_2 {
25303                            lastkey: 0,
25304                            keystep: 0,
25305                            limit: 0,
25306                        },
25307                    },
25308                },
25309                num_args: 0,
25310                num_history: 0,
25311                num_tips: 0,
25312                key_specs_num: 0,
25313                key_specs_max: 0,
25314                subcommands_dict: 0 as *const dict as *mut dict,
25315                parent: 0 as *const redisCommand as *mut redisCommand,
25316                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25317            };
25318            init
25319        },
25320        {
25321            let mut init = redisCommand {
25322                declared_name: b"getkeys\0" as *const u8 as *const libc::c_char,
25323                summary: b"Extract keys given a full Redis command\0" as *const u8
25324                    as *const libc::c_char,
25325                complexity: b"O(N) where N is the number of arguments to the command\0"
25326                    as *const u8 as *const libc::c_char,
25327                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
25328                doc_flags: 0 as libc::c_int,
25329                replaced_by: 0 as *const libc::c_char,
25330                deprecated_since: 0 as *const libc::c_char,
25331                group: COMMAND_GROUP_SERVER,
25332                history: 0 as *const commandHistory as *mut commandHistory,
25333                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25334                proc_0: Some(
25335                    commandGetKeysCommand as unsafe extern "C" fn(*mut client) -> (),
25336                ),
25337                arity: -(4 as libc::c_int),
25338                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25339                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25340                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25341                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25342                    as uint64_t,
25343                key_specs_static: [keySpec {
25344                    notes: 0 as *const libc::c_char,
25345                    flags: 0,
25346                    begin_search_type: KSPEC_BS_INVALID,
25347                    bs: C2RustUnnamed_3 {
25348                        index: C2RustUnnamed_5 { pos: 0 },
25349                    },
25350                    find_keys_type: KSPEC_FK_INVALID,
25351                    fk: C2RustUnnamed_0 {
25352                        range: C2RustUnnamed_2 {
25353                            lastkey: 0,
25354                            keystep: 0,
25355                            limit: 0,
25356                        },
25357                    },
25358                }; 4],
25359                getkeys_proc: None,
25360                subcommands: 0 as *const redisCommand as *mut redisCommand,
25361                args: 0 as *const redisCommandArg as *mut redisCommandArg,
25362                microseconds: 0,
25363                calls: 0,
25364                rejected_calls: 0,
25365                failed_calls: 0,
25366                id: 0,
25367                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25368                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25369                key_specs: 0 as *const keySpec as *mut keySpec,
25370                legacy_range_key_spec: keySpec {
25371                    notes: 0 as *const libc::c_char,
25372                    flags: 0,
25373                    begin_search_type: KSPEC_BS_INVALID,
25374                    bs: C2RustUnnamed_3 {
25375                        index: C2RustUnnamed_5 { pos: 0 },
25376                    },
25377                    find_keys_type: KSPEC_FK_INVALID,
25378                    fk: C2RustUnnamed_0 {
25379                        range: C2RustUnnamed_2 {
25380                            lastkey: 0,
25381                            keystep: 0,
25382                            limit: 0,
25383                        },
25384                    },
25385                },
25386                num_args: 0,
25387                num_history: 0,
25388                num_tips: 0,
25389                key_specs_num: 0,
25390                key_specs_max: 0,
25391                subcommands_dict: 0 as *const dict as *mut dict,
25392                parent: 0 as *const redisCommand as *mut redisCommand,
25393                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25394            };
25395            init
25396        },
25397        {
25398            let mut init = redisCommand {
25399                declared_name: b"getkeysandflags\0" as *const u8 as *const libc::c_char,
25400                summary: b"Extract keys and access flags given a full Redis command\0"
25401                    as *const u8 as *const libc::c_char,
25402                complexity: b"O(N) where N is the number of arguments to the command\0"
25403                    as *const u8 as *const libc::c_char,
25404                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25405                doc_flags: 0 as libc::c_int,
25406                replaced_by: 0 as *const libc::c_char,
25407                deprecated_since: 0 as *const libc::c_char,
25408                group: COMMAND_GROUP_SERVER,
25409                history: 0 as *const commandHistory as *mut commandHistory,
25410                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25411                proc_0: Some(
25412                    commandGetKeysAndFlagsCommand
25413                        as unsafe extern "C" fn(*mut client) -> (),
25414                ),
25415                arity: -(4 as libc::c_int),
25416                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25417                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25418                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25419                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25420                    as uint64_t,
25421                key_specs_static: [keySpec {
25422                    notes: 0 as *const libc::c_char,
25423                    flags: 0,
25424                    begin_search_type: KSPEC_BS_INVALID,
25425                    bs: C2RustUnnamed_3 {
25426                        index: C2RustUnnamed_5 { pos: 0 },
25427                    },
25428                    find_keys_type: KSPEC_FK_INVALID,
25429                    fk: C2RustUnnamed_0 {
25430                        range: C2RustUnnamed_2 {
25431                            lastkey: 0,
25432                            keystep: 0,
25433                            limit: 0,
25434                        },
25435                    },
25436                }; 4],
25437                getkeys_proc: None,
25438                subcommands: 0 as *const redisCommand as *mut redisCommand,
25439                args: 0 as *const redisCommandArg as *mut redisCommandArg,
25440                microseconds: 0,
25441                calls: 0,
25442                rejected_calls: 0,
25443                failed_calls: 0,
25444                id: 0,
25445                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25446                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25447                key_specs: 0 as *const keySpec as *mut keySpec,
25448                legacy_range_key_spec: keySpec {
25449                    notes: 0 as *const libc::c_char,
25450                    flags: 0,
25451                    begin_search_type: KSPEC_BS_INVALID,
25452                    bs: C2RustUnnamed_3 {
25453                        index: C2RustUnnamed_5 { pos: 0 },
25454                    },
25455                    find_keys_type: KSPEC_FK_INVALID,
25456                    fk: C2RustUnnamed_0 {
25457                        range: C2RustUnnamed_2 {
25458                            lastkey: 0,
25459                            keystep: 0,
25460                            limit: 0,
25461                        },
25462                    },
25463                },
25464                num_args: 0,
25465                num_history: 0,
25466                num_tips: 0,
25467                key_specs_num: 0,
25468                key_specs_max: 0,
25469                subcommands_dict: 0 as *const dict as *mut dict,
25470                parent: 0 as *const redisCommand as *mut redisCommand,
25471                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25472            };
25473            init
25474        },
25475        {
25476            let mut init = redisCommand {
25477                declared_name: b"help\0" as *const u8 as *const libc::c_char,
25478                summary: b"Show helpful text about the different subcommands\0"
25479                    as *const u8 as *const libc::c_char,
25480                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
25481                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
25482                doc_flags: 0 as libc::c_int,
25483                replaced_by: 0 as *const libc::c_char,
25484                deprecated_since: 0 as *const libc::c_char,
25485                group: COMMAND_GROUP_SERVER,
25486                history: 0 as *const commandHistory as *mut commandHistory,
25487                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25488                proc_0: Some(
25489                    commandHelpCommand as unsafe extern "C" fn(*mut client) -> (),
25490                ),
25491                arity: 2 as libc::c_int,
25492                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25493                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25494                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25495                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25496                    as uint64_t,
25497                key_specs_static: [keySpec {
25498                    notes: 0 as *const libc::c_char,
25499                    flags: 0,
25500                    begin_search_type: KSPEC_BS_INVALID,
25501                    bs: C2RustUnnamed_3 {
25502                        index: C2RustUnnamed_5 { pos: 0 },
25503                    },
25504                    find_keys_type: KSPEC_FK_INVALID,
25505                    fk: C2RustUnnamed_0 {
25506                        range: C2RustUnnamed_2 {
25507                            lastkey: 0,
25508                            keystep: 0,
25509                            limit: 0,
25510                        },
25511                    },
25512                }; 4],
25513                getkeys_proc: None,
25514                subcommands: 0 as *const redisCommand as *mut redisCommand,
25515                args: 0 as *const redisCommandArg as *mut redisCommandArg,
25516                microseconds: 0,
25517                calls: 0,
25518                rejected_calls: 0,
25519                failed_calls: 0,
25520                id: 0,
25521                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25522                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25523                key_specs: 0 as *const keySpec as *mut keySpec,
25524                legacy_range_key_spec: keySpec {
25525                    notes: 0 as *const libc::c_char,
25526                    flags: 0,
25527                    begin_search_type: KSPEC_BS_INVALID,
25528                    bs: C2RustUnnamed_3 {
25529                        index: C2RustUnnamed_5 { pos: 0 },
25530                    },
25531                    find_keys_type: KSPEC_FK_INVALID,
25532                    fk: C2RustUnnamed_0 {
25533                        range: C2RustUnnamed_2 {
25534                            lastkey: 0,
25535                            keystep: 0,
25536                            limit: 0,
25537                        },
25538                    },
25539                },
25540                num_args: 0,
25541                num_history: 0,
25542                num_tips: 0,
25543                key_specs_num: 0,
25544                key_specs_max: 0,
25545                subcommands_dict: 0 as *const dict as *mut dict,
25546                parent: 0 as *const redisCommand as *mut redisCommand,
25547                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25548            };
25549            init
25550        },
25551        {
25552            let mut init = redisCommand {
25553                declared_name: b"info\0" as *const u8 as *const libc::c_char,
25554                summary: b"Get array of specific Redis command details, or all when no argument is given.\0"
25555                    as *const u8 as *const libc::c_char,
25556                complexity: b"O(N) where N is the number of commands to look up\0"
25557                    as *const u8 as *const libc::c_char,
25558                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
25559                doc_flags: 0 as libc::c_int,
25560                replaced_by: 0 as *const libc::c_char,
25561                deprecated_since: 0 as *const libc::c_char,
25562                group: COMMAND_GROUP_SERVER,
25563                history: COMMAND_INFO_History.as_ptr() as *mut _,
25564                tips: COMMAND_INFO_tips.as_ptr() as *mut _,
25565                proc_0: Some(
25566                    commandInfoCommand as unsafe extern "C" fn(*mut client) -> (),
25567                ),
25568                arity: -(2 as libc::c_int),
25569                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25570                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25571                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25572                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25573                    as uint64_t,
25574                key_specs_static: [keySpec {
25575                    notes: 0 as *const libc::c_char,
25576                    flags: 0,
25577                    begin_search_type: KSPEC_BS_INVALID,
25578                    bs: C2RustUnnamed_3 {
25579                        index: C2RustUnnamed_5 { pos: 0 },
25580                    },
25581                    find_keys_type: KSPEC_FK_INVALID,
25582                    fk: C2RustUnnamed_0 {
25583                        range: C2RustUnnamed_2 {
25584                            lastkey: 0,
25585                            keystep: 0,
25586                            limit: 0,
25587                        },
25588                    },
25589                }; 4],
25590                getkeys_proc: None,
25591                subcommands: 0 as *const redisCommand as *mut redisCommand,
25592                args: COMMAND_INFO_Args.as_ptr() as *mut _,
25593                microseconds: 0,
25594                calls: 0,
25595                rejected_calls: 0,
25596                failed_calls: 0,
25597                id: 0,
25598                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25599                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25600                key_specs: 0 as *const keySpec as *mut keySpec,
25601                legacy_range_key_spec: keySpec {
25602                    notes: 0 as *const libc::c_char,
25603                    flags: 0,
25604                    begin_search_type: KSPEC_BS_INVALID,
25605                    bs: C2RustUnnamed_3 {
25606                        index: C2RustUnnamed_5 { pos: 0 },
25607                    },
25608                    find_keys_type: KSPEC_FK_INVALID,
25609                    fk: C2RustUnnamed_0 {
25610                        range: C2RustUnnamed_2 {
25611                            lastkey: 0,
25612                            keystep: 0,
25613                            limit: 0,
25614                        },
25615                    },
25616                },
25617                num_args: 0,
25618                num_history: 0,
25619                num_tips: 0,
25620                key_specs_num: 0,
25621                key_specs_max: 0,
25622                subcommands_dict: 0 as *const dict as *mut dict,
25623                parent: 0 as *const redisCommand as *mut redisCommand,
25624                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25625            };
25626            init
25627        },
25628        {
25629            let mut init = redisCommand {
25630                declared_name: b"list\0" as *const u8 as *const libc::c_char,
25631                summary: b"Get an array of Redis command names\0" as *const u8
25632                    as *const libc::c_char,
25633                complexity: b"O(N) where N is the total number of Redis commands\0"
25634                    as *const u8 as *const libc::c_char,
25635                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25636                doc_flags: 0 as libc::c_int,
25637                replaced_by: 0 as *const libc::c_char,
25638                deprecated_since: 0 as *const libc::c_char,
25639                group: COMMAND_GROUP_SERVER,
25640                history: 0 as *const commandHistory as *mut commandHistory,
25641                tips: COMMAND_LIST_tips.as_ptr() as *mut _,
25642                proc_0: Some(
25643                    commandListCommand as unsafe extern "C" fn(*mut client) -> (),
25644                ),
25645                arity: -(2 as libc::c_int),
25646                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
25647                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
25648                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
25649                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
25650                    as uint64_t,
25651                key_specs_static: [keySpec {
25652                    notes: 0 as *const libc::c_char,
25653                    flags: 0,
25654                    begin_search_type: KSPEC_BS_INVALID,
25655                    bs: C2RustUnnamed_3 {
25656                        index: C2RustUnnamed_5 { pos: 0 },
25657                    },
25658                    find_keys_type: KSPEC_FK_INVALID,
25659                    fk: C2RustUnnamed_0 {
25660                        range: C2RustUnnamed_2 {
25661                            lastkey: 0,
25662                            keystep: 0,
25663                            limit: 0,
25664                        },
25665                    },
25666                }; 4],
25667                getkeys_proc: None,
25668                subcommands: 0 as *const redisCommand as *mut redisCommand,
25669                args: COMMAND_LIST_Args.as_ptr() as *mut _,
25670                microseconds: 0,
25671                calls: 0,
25672                rejected_calls: 0,
25673                failed_calls: 0,
25674                id: 0,
25675                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25676                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25677                key_specs: 0 as *const keySpec as *mut keySpec,
25678                legacy_range_key_spec: keySpec {
25679                    notes: 0 as *const libc::c_char,
25680                    flags: 0,
25681                    begin_search_type: KSPEC_BS_INVALID,
25682                    bs: C2RustUnnamed_3 {
25683                        index: C2RustUnnamed_5 { pos: 0 },
25684                    },
25685                    find_keys_type: KSPEC_FK_INVALID,
25686                    fk: C2RustUnnamed_0 {
25687                        range: C2RustUnnamed_2 {
25688                            lastkey: 0,
25689                            keystep: 0,
25690                            limit: 0,
25691                        },
25692                    },
25693                },
25694                num_args: 0,
25695                num_history: 0,
25696                num_tips: 0,
25697                key_specs_num: 0,
25698                key_specs_max: 0,
25699                subcommands_dict: 0 as *const dict as *mut dict,
25700                parent: 0 as *const redisCommand as *mut redisCommand,
25701                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25702            };
25703            init
25704        },
25705        {
25706            let mut init = redisCommand {
25707                declared_name: 0 as *const libc::c_char,
25708                summary: 0 as *const libc::c_char,
25709                complexity: 0 as *const libc::c_char,
25710                since: 0 as *const libc::c_char,
25711                doc_flags: 0,
25712                replaced_by: 0 as *const libc::c_char,
25713                deprecated_since: 0 as *const libc::c_char,
25714                group: COMMAND_GROUP_GENERIC,
25715                history: 0 as *const commandHistory as *mut commandHistory,
25716                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25717                proc_0: None,
25718                arity: 0,
25719                flags: 0,
25720                acl_categories: 0,
25721                key_specs_static: [keySpec {
25722                    notes: 0 as *const libc::c_char,
25723                    flags: 0,
25724                    begin_search_type: KSPEC_BS_INVALID,
25725                    bs: C2RustUnnamed_3 {
25726                        index: C2RustUnnamed_5 { pos: 0 },
25727                    },
25728                    find_keys_type: KSPEC_FK_INVALID,
25729                    fk: C2RustUnnamed_0 {
25730                        range: C2RustUnnamed_2 {
25731                            lastkey: 0,
25732                            keystep: 0,
25733                            limit: 0,
25734                        },
25735                    },
25736                }; 4],
25737                getkeys_proc: None,
25738                subcommands: 0 as *const redisCommand as *mut redisCommand,
25739                args: 0 as *const redisCommandArg as *mut redisCommandArg,
25740                microseconds: 0,
25741                calls: 0,
25742                rejected_calls: 0,
25743                failed_calls: 0,
25744                id: 0,
25745                fullname: 0 as *const libc::c_char as *mut libc::c_char,
25746                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
25747                key_specs: 0 as *const keySpec as *mut keySpec,
25748                legacy_range_key_spec: keySpec {
25749                    notes: 0 as *const libc::c_char,
25750                    flags: 0,
25751                    begin_search_type: KSPEC_BS_INVALID,
25752                    bs: C2RustUnnamed_3 {
25753                        index: C2RustUnnamed_5 { pos: 0 },
25754                    },
25755                    find_keys_type: KSPEC_FK_INVALID,
25756                    fk: C2RustUnnamed_0 {
25757                        range: C2RustUnnamed_2 {
25758                            lastkey: 0,
25759                            keystep: 0,
25760                            limit: 0,
25761                        },
25762                    },
25763                },
25764                num_args: 0,
25765                num_history: 0,
25766                num_tips: 0,
25767                key_specs_num: 0,
25768                key_specs_max: 0,
25769                subcommands_dict: 0 as *const dict as *mut dict,
25770                parent: 0 as *const redisCommand as *mut redisCommand,
25771                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
25772            };
25773            init
25774        },
25775    ]
25776};
25777#[no_mangle]
25778pub static mut COMMAND_tips: [*const libc::c_char; 2] = [
25779    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
25780    0 as *const libc::c_char,
25781];
25782#[no_mangle]
25783pub static mut CONFIG_GET_History: [commandHistory; 2] = [
25784    {
25785        let mut init = commandHistory {
25786            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25787            changes: b"Added the ability to pass multiple pattern parameters in one call\0"
25788                as *const u8 as *const libc::c_char,
25789        };
25790        init
25791    },
25792    {
25793        let mut init = commandHistory {
25794            since: 0 as *const libc::c_char,
25795            changes: 0 as *const libc::c_char,
25796        };
25797        init
25798    },
25799];
25800#[no_mangle]
25801pub static mut CONFIG_GET_parameter_Subargs: [redisCommandArg; 2] = [
25802    {
25803        let mut init = redisCommandArg {
25804            name: b"parameter\0" as *const u8 as *const libc::c_char,
25805            type_0: ARG_TYPE_STRING,
25806            key_spec_index: -(1 as libc::c_int),
25807            token: 0 as *const libc::c_char,
25808            summary: 0 as *const libc::c_char,
25809            since: 0 as *const libc::c_char,
25810            flags: 0 as libc::c_int,
25811            deprecated_since: 0 as *const libc::c_char,
25812            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25813            num_args: 0,
25814        };
25815        init
25816    },
25817    {
25818        let mut init = redisCommandArg {
25819            name: 0 as *const libc::c_char,
25820            type_0: ARG_TYPE_STRING,
25821            key_spec_index: 0,
25822            token: 0 as *const libc::c_char,
25823            summary: 0 as *const libc::c_char,
25824            since: 0 as *const libc::c_char,
25825            flags: 0,
25826            deprecated_since: 0 as *const libc::c_char,
25827            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25828            num_args: 0,
25829        };
25830        init
25831    },
25832];
25833#[no_mangle]
25834pub static mut CONFIG_GET_Args: [redisCommandArg; 2] = unsafe {
25835    [
25836        {
25837            let mut init = redisCommandArg {
25838                name: b"parameter\0" as *const u8 as *const libc::c_char,
25839                type_0: ARG_TYPE_BLOCK,
25840                key_spec_index: -(1 as libc::c_int),
25841                token: 0 as *const libc::c_char,
25842                summary: 0 as *const libc::c_char,
25843                since: 0 as *const libc::c_char,
25844                flags: (1 as libc::c_int) << 1 as libc::c_int,
25845                deprecated_since: 0 as *const libc::c_char,
25846                subargs: CONFIG_GET_parameter_Subargs.as_ptr() as *mut _,
25847                num_args: 0,
25848            };
25849            init
25850        },
25851        {
25852            let mut init = redisCommandArg {
25853                name: 0 as *const libc::c_char,
25854                type_0: ARG_TYPE_STRING,
25855                key_spec_index: 0,
25856                token: 0 as *const libc::c_char,
25857                summary: 0 as *const libc::c_char,
25858                since: 0 as *const libc::c_char,
25859                flags: 0,
25860                deprecated_since: 0 as *const libc::c_char,
25861                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25862                num_args: 0,
25863            };
25864            init
25865        },
25866    ]
25867};
25868#[no_mangle]
25869pub static mut CONFIG_SET_History: [commandHistory; 2] = [
25870    {
25871        let mut init = commandHistory {
25872            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
25873            changes: b"Added the ability to set multiple parameters in one call.\0"
25874                as *const u8 as *const libc::c_char,
25875        };
25876        init
25877    },
25878    {
25879        let mut init = commandHistory {
25880            since: 0 as *const libc::c_char,
25881            changes: 0 as *const libc::c_char,
25882        };
25883        init
25884    },
25885];
25886#[no_mangle]
25887pub static mut CONFIG_SET_tips: [*const libc::c_char; 3] = [
25888    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
25889    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
25890    0 as *const libc::c_char,
25891];
25892#[no_mangle]
25893pub static mut CONFIG_SET_parameter_value_Subargs: [redisCommandArg; 3] = [
25894    {
25895        let mut init = redisCommandArg {
25896            name: b"parameter\0" as *const u8 as *const libc::c_char,
25897            type_0: ARG_TYPE_STRING,
25898            key_spec_index: -(1 as libc::c_int),
25899            token: 0 as *const libc::c_char,
25900            summary: 0 as *const libc::c_char,
25901            since: 0 as *const libc::c_char,
25902            flags: 0 as libc::c_int,
25903            deprecated_since: 0 as *const libc::c_char,
25904            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25905            num_args: 0,
25906        };
25907        init
25908    },
25909    {
25910        let mut init = redisCommandArg {
25911            name: b"value\0" as *const u8 as *const libc::c_char,
25912            type_0: ARG_TYPE_STRING,
25913            key_spec_index: -(1 as libc::c_int),
25914            token: 0 as *const libc::c_char,
25915            summary: 0 as *const libc::c_char,
25916            since: 0 as *const libc::c_char,
25917            flags: 0 as libc::c_int,
25918            deprecated_since: 0 as *const libc::c_char,
25919            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25920            num_args: 0,
25921        };
25922        init
25923    },
25924    {
25925        let mut init = redisCommandArg {
25926            name: 0 as *const libc::c_char,
25927            type_0: ARG_TYPE_STRING,
25928            key_spec_index: 0,
25929            token: 0 as *const libc::c_char,
25930            summary: 0 as *const libc::c_char,
25931            since: 0 as *const libc::c_char,
25932            flags: 0,
25933            deprecated_since: 0 as *const libc::c_char,
25934            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25935            num_args: 0,
25936        };
25937        init
25938    },
25939];
25940#[no_mangle]
25941pub static mut CONFIG_SET_Args: [redisCommandArg; 2] = unsafe {
25942    [
25943        {
25944            let mut init = redisCommandArg {
25945                name: b"parameter_value\0" as *const u8 as *const libc::c_char,
25946                type_0: ARG_TYPE_BLOCK,
25947                key_spec_index: -(1 as libc::c_int),
25948                token: 0 as *const libc::c_char,
25949                summary: 0 as *const libc::c_char,
25950                since: 0 as *const libc::c_char,
25951                flags: (1 as libc::c_int) << 1 as libc::c_int,
25952                deprecated_since: 0 as *const libc::c_char,
25953                subargs: CONFIG_SET_parameter_value_Subargs.as_ptr() as *mut _,
25954                num_args: 0,
25955            };
25956            init
25957        },
25958        {
25959            let mut init = redisCommandArg {
25960                name: 0 as *const libc::c_char,
25961                type_0: ARG_TYPE_STRING,
25962                key_spec_index: 0,
25963                token: 0 as *const libc::c_char,
25964                summary: 0 as *const libc::c_char,
25965                since: 0 as *const libc::c_char,
25966                flags: 0,
25967                deprecated_since: 0 as *const libc::c_char,
25968                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
25969                num_args: 0,
25970            };
25971            init
25972        },
25973    ]
25974};
25975#[no_mangle]
25976pub static mut CONFIG_Subcommands: [redisCommand; 6] = unsafe {
25977    [
25978        {
25979            let mut init = redisCommand {
25980                declared_name: b"get\0" as *const u8 as *const libc::c_char,
25981                summary: b"Get the values of configuration parameters\0" as *const u8
25982                    as *const libc::c_char,
25983                complexity: b"O(N) when N is the number of configuration parameters provided\0"
25984                    as *const u8 as *const libc::c_char,
25985                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
25986                doc_flags: 0 as libc::c_int,
25987                replaced_by: 0 as *const libc::c_char,
25988                deprecated_since: 0 as *const libc::c_char,
25989                group: COMMAND_GROUP_SERVER,
25990                history: CONFIG_GET_History.as_ptr() as *mut _,
25991                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
25992                proc_0: Some(
25993                    configGetCommand as unsafe extern "C" fn(*mut client) -> (),
25994                ),
25995                arity: -(3 as libc::c_int),
25996                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
25997                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
25998                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
25999                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
26000                acl_categories: 0 as libc::c_int as uint64_t,
26001                key_specs_static: [keySpec {
26002                    notes: 0 as *const libc::c_char,
26003                    flags: 0,
26004                    begin_search_type: KSPEC_BS_INVALID,
26005                    bs: C2RustUnnamed_3 {
26006                        index: C2RustUnnamed_5 { pos: 0 },
26007                    },
26008                    find_keys_type: KSPEC_FK_INVALID,
26009                    fk: C2RustUnnamed_0 {
26010                        range: C2RustUnnamed_2 {
26011                            lastkey: 0,
26012                            keystep: 0,
26013                            limit: 0,
26014                        },
26015                    },
26016                }; 4],
26017                getkeys_proc: None,
26018                subcommands: 0 as *const redisCommand as *mut redisCommand,
26019                args: CONFIG_GET_Args.as_ptr() as *mut _,
26020                microseconds: 0,
26021                calls: 0,
26022                rejected_calls: 0,
26023                failed_calls: 0,
26024                id: 0,
26025                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26026                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26027                key_specs: 0 as *const keySpec as *mut keySpec,
26028                legacy_range_key_spec: keySpec {
26029                    notes: 0 as *const libc::c_char,
26030                    flags: 0,
26031                    begin_search_type: KSPEC_BS_INVALID,
26032                    bs: C2RustUnnamed_3 {
26033                        index: C2RustUnnamed_5 { pos: 0 },
26034                    },
26035                    find_keys_type: KSPEC_FK_INVALID,
26036                    fk: C2RustUnnamed_0 {
26037                        range: C2RustUnnamed_2 {
26038                            lastkey: 0,
26039                            keystep: 0,
26040                            limit: 0,
26041                        },
26042                    },
26043                },
26044                num_args: 0,
26045                num_history: 0,
26046                num_tips: 0,
26047                key_specs_num: 0,
26048                key_specs_max: 0,
26049                subcommands_dict: 0 as *const dict as *mut dict,
26050                parent: 0 as *const redisCommand as *mut redisCommand,
26051                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26052            };
26053            init
26054        },
26055        {
26056            let mut init = redisCommand {
26057                declared_name: b"help\0" as *const u8 as *const libc::c_char,
26058                summary: b"Show helpful text about the different subcommands\0"
26059                    as *const u8 as *const libc::c_char,
26060                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
26061                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
26062                doc_flags: 0 as libc::c_int,
26063                replaced_by: 0 as *const libc::c_char,
26064                deprecated_since: 0 as *const libc::c_char,
26065                group: COMMAND_GROUP_SERVER,
26066                history: 0 as *const commandHistory as *mut commandHistory,
26067                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
26068                proc_0: Some(
26069                    configHelpCommand as unsafe extern "C" fn(*mut client) -> (),
26070                ),
26071                arity: 2 as libc::c_int,
26072                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
26073                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
26074                acl_categories: 0 as libc::c_int as uint64_t,
26075                key_specs_static: [keySpec {
26076                    notes: 0 as *const libc::c_char,
26077                    flags: 0,
26078                    begin_search_type: KSPEC_BS_INVALID,
26079                    bs: C2RustUnnamed_3 {
26080                        index: C2RustUnnamed_5 { pos: 0 },
26081                    },
26082                    find_keys_type: KSPEC_FK_INVALID,
26083                    fk: C2RustUnnamed_0 {
26084                        range: C2RustUnnamed_2 {
26085                            lastkey: 0,
26086                            keystep: 0,
26087                            limit: 0,
26088                        },
26089                    },
26090                }; 4],
26091                getkeys_proc: None,
26092                subcommands: 0 as *const redisCommand as *mut redisCommand,
26093                args: 0 as *const redisCommandArg as *mut redisCommandArg,
26094                microseconds: 0,
26095                calls: 0,
26096                rejected_calls: 0,
26097                failed_calls: 0,
26098                id: 0,
26099                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26100                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26101                key_specs: 0 as *const keySpec as *mut keySpec,
26102                legacy_range_key_spec: keySpec {
26103                    notes: 0 as *const libc::c_char,
26104                    flags: 0,
26105                    begin_search_type: KSPEC_BS_INVALID,
26106                    bs: C2RustUnnamed_3 {
26107                        index: C2RustUnnamed_5 { pos: 0 },
26108                    },
26109                    find_keys_type: KSPEC_FK_INVALID,
26110                    fk: C2RustUnnamed_0 {
26111                        range: C2RustUnnamed_2 {
26112                            lastkey: 0,
26113                            keystep: 0,
26114                            limit: 0,
26115                        },
26116                    },
26117                },
26118                num_args: 0,
26119                num_history: 0,
26120                num_tips: 0,
26121                key_specs_num: 0,
26122                key_specs_max: 0,
26123                subcommands_dict: 0 as *const dict as *mut dict,
26124                parent: 0 as *const redisCommand as *mut redisCommand,
26125                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26126            };
26127            init
26128        },
26129        {
26130            let mut init = redisCommand {
26131                declared_name: b"resetstat\0" as *const u8 as *const libc::c_char,
26132                summary: b"Reset the stats returned by INFO\0" as *const u8
26133                    as *const libc::c_char,
26134                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
26135                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
26136                doc_flags: 0 as libc::c_int,
26137                replaced_by: 0 as *const libc::c_char,
26138                deprecated_since: 0 as *const libc::c_char,
26139                group: COMMAND_GROUP_SERVER,
26140                history: 0 as *const commandHistory as *mut commandHistory,
26141                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
26142                proc_0: Some(
26143                    configResetStatCommand as unsafe extern "C" fn(*mut client) -> (),
26144                ),
26145                arity: 2 as libc::c_int,
26146                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
26147                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
26148                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
26149                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
26150                acl_categories: 0 as libc::c_int as uint64_t,
26151                key_specs_static: [keySpec {
26152                    notes: 0 as *const libc::c_char,
26153                    flags: 0,
26154                    begin_search_type: KSPEC_BS_INVALID,
26155                    bs: C2RustUnnamed_3 {
26156                        index: C2RustUnnamed_5 { pos: 0 },
26157                    },
26158                    find_keys_type: KSPEC_FK_INVALID,
26159                    fk: C2RustUnnamed_0 {
26160                        range: C2RustUnnamed_2 {
26161                            lastkey: 0,
26162                            keystep: 0,
26163                            limit: 0,
26164                        },
26165                    },
26166                }; 4],
26167                getkeys_proc: None,
26168                subcommands: 0 as *const redisCommand as *mut redisCommand,
26169                args: 0 as *const redisCommandArg as *mut redisCommandArg,
26170                microseconds: 0,
26171                calls: 0,
26172                rejected_calls: 0,
26173                failed_calls: 0,
26174                id: 0,
26175                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26176                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26177                key_specs: 0 as *const keySpec as *mut keySpec,
26178                legacy_range_key_spec: keySpec {
26179                    notes: 0 as *const libc::c_char,
26180                    flags: 0,
26181                    begin_search_type: KSPEC_BS_INVALID,
26182                    bs: C2RustUnnamed_3 {
26183                        index: C2RustUnnamed_5 { pos: 0 },
26184                    },
26185                    find_keys_type: KSPEC_FK_INVALID,
26186                    fk: C2RustUnnamed_0 {
26187                        range: C2RustUnnamed_2 {
26188                            lastkey: 0,
26189                            keystep: 0,
26190                            limit: 0,
26191                        },
26192                    },
26193                },
26194                num_args: 0,
26195                num_history: 0,
26196                num_tips: 0,
26197                key_specs_num: 0,
26198                key_specs_max: 0,
26199                subcommands_dict: 0 as *const dict as *mut dict,
26200                parent: 0 as *const redisCommand as *mut redisCommand,
26201                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26202            };
26203            init
26204        },
26205        {
26206            let mut init = redisCommand {
26207                declared_name: b"rewrite\0" as *const u8 as *const libc::c_char,
26208                summary: b"Rewrite the configuration file with the in memory configuration\0"
26209                    as *const u8 as *const libc::c_char,
26210                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
26211                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
26212                doc_flags: 0 as libc::c_int,
26213                replaced_by: 0 as *const libc::c_char,
26214                deprecated_since: 0 as *const libc::c_char,
26215                group: COMMAND_GROUP_SERVER,
26216                history: 0 as *const commandHistory as *mut commandHistory,
26217                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
26218                proc_0: Some(
26219                    configRewriteCommand as unsafe extern "C" fn(*mut client) -> (),
26220                ),
26221                arity: 2 as libc::c_int,
26222                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
26223                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
26224                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
26225                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
26226                acl_categories: 0 as libc::c_int as uint64_t,
26227                key_specs_static: [keySpec {
26228                    notes: 0 as *const libc::c_char,
26229                    flags: 0,
26230                    begin_search_type: KSPEC_BS_INVALID,
26231                    bs: C2RustUnnamed_3 {
26232                        index: C2RustUnnamed_5 { pos: 0 },
26233                    },
26234                    find_keys_type: KSPEC_FK_INVALID,
26235                    fk: C2RustUnnamed_0 {
26236                        range: C2RustUnnamed_2 {
26237                            lastkey: 0,
26238                            keystep: 0,
26239                            limit: 0,
26240                        },
26241                    },
26242                }; 4],
26243                getkeys_proc: None,
26244                subcommands: 0 as *const redisCommand as *mut redisCommand,
26245                args: 0 as *const redisCommandArg as *mut redisCommandArg,
26246                microseconds: 0,
26247                calls: 0,
26248                rejected_calls: 0,
26249                failed_calls: 0,
26250                id: 0,
26251                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26252                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26253                key_specs: 0 as *const keySpec as *mut keySpec,
26254                legacy_range_key_spec: keySpec {
26255                    notes: 0 as *const libc::c_char,
26256                    flags: 0,
26257                    begin_search_type: KSPEC_BS_INVALID,
26258                    bs: C2RustUnnamed_3 {
26259                        index: C2RustUnnamed_5 { pos: 0 },
26260                    },
26261                    find_keys_type: KSPEC_FK_INVALID,
26262                    fk: C2RustUnnamed_0 {
26263                        range: C2RustUnnamed_2 {
26264                            lastkey: 0,
26265                            keystep: 0,
26266                            limit: 0,
26267                        },
26268                    },
26269                },
26270                num_args: 0,
26271                num_history: 0,
26272                num_tips: 0,
26273                key_specs_num: 0,
26274                key_specs_max: 0,
26275                subcommands_dict: 0 as *const dict as *mut dict,
26276                parent: 0 as *const redisCommand as *mut redisCommand,
26277                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26278            };
26279            init
26280        },
26281        {
26282            let mut init = redisCommand {
26283                declared_name: b"set\0" as *const u8 as *const libc::c_char,
26284                summary: b"Set configuration parameters to the given values\0"
26285                    as *const u8 as *const libc::c_char,
26286                complexity: b"O(N) when N is the number of configuration parameters provided\0"
26287                    as *const u8 as *const libc::c_char,
26288                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
26289                doc_flags: 0 as libc::c_int,
26290                replaced_by: 0 as *const libc::c_char,
26291                deprecated_since: 0 as *const libc::c_char,
26292                group: COMMAND_GROUP_SERVER,
26293                history: CONFIG_SET_History.as_ptr() as *mut _,
26294                tips: CONFIG_SET_tips.as_ptr() as *mut _,
26295                proc_0: Some(
26296                    configSetCommand as unsafe extern "C" fn(*mut client) -> (),
26297                ),
26298                arity: -(4 as libc::c_int),
26299                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
26300                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
26301                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
26302                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
26303                acl_categories: 0 as libc::c_int as uint64_t,
26304                key_specs_static: [keySpec {
26305                    notes: 0 as *const libc::c_char,
26306                    flags: 0,
26307                    begin_search_type: KSPEC_BS_INVALID,
26308                    bs: C2RustUnnamed_3 {
26309                        index: C2RustUnnamed_5 { pos: 0 },
26310                    },
26311                    find_keys_type: KSPEC_FK_INVALID,
26312                    fk: C2RustUnnamed_0 {
26313                        range: C2RustUnnamed_2 {
26314                            lastkey: 0,
26315                            keystep: 0,
26316                            limit: 0,
26317                        },
26318                    },
26319                }; 4],
26320                getkeys_proc: None,
26321                subcommands: 0 as *const redisCommand as *mut redisCommand,
26322                args: CONFIG_SET_Args.as_ptr() as *mut _,
26323                microseconds: 0,
26324                calls: 0,
26325                rejected_calls: 0,
26326                failed_calls: 0,
26327                id: 0,
26328                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26329                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26330                key_specs: 0 as *const keySpec as *mut keySpec,
26331                legacy_range_key_spec: keySpec {
26332                    notes: 0 as *const libc::c_char,
26333                    flags: 0,
26334                    begin_search_type: KSPEC_BS_INVALID,
26335                    bs: C2RustUnnamed_3 {
26336                        index: C2RustUnnamed_5 { pos: 0 },
26337                    },
26338                    find_keys_type: KSPEC_FK_INVALID,
26339                    fk: C2RustUnnamed_0 {
26340                        range: C2RustUnnamed_2 {
26341                            lastkey: 0,
26342                            keystep: 0,
26343                            limit: 0,
26344                        },
26345                    },
26346                },
26347                num_args: 0,
26348                num_history: 0,
26349                num_tips: 0,
26350                key_specs_num: 0,
26351                key_specs_max: 0,
26352                subcommands_dict: 0 as *const dict as *mut dict,
26353                parent: 0 as *const redisCommand as *mut redisCommand,
26354                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26355            };
26356            init
26357        },
26358        {
26359            let mut init = redisCommand {
26360                declared_name: 0 as *const libc::c_char,
26361                summary: 0 as *const libc::c_char,
26362                complexity: 0 as *const libc::c_char,
26363                since: 0 as *const libc::c_char,
26364                doc_flags: 0,
26365                replaced_by: 0 as *const libc::c_char,
26366                deprecated_since: 0 as *const libc::c_char,
26367                group: COMMAND_GROUP_GENERIC,
26368                history: 0 as *const commandHistory as *mut commandHistory,
26369                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
26370                proc_0: None,
26371                arity: 0,
26372                flags: 0,
26373                acl_categories: 0,
26374                key_specs_static: [keySpec {
26375                    notes: 0 as *const libc::c_char,
26376                    flags: 0,
26377                    begin_search_type: KSPEC_BS_INVALID,
26378                    bs: C2RustUnnamed_3 {
26379                        index: C2RustUnnamed_5 { pos: 0 },
26380                    },
26381                    find_keys_type: KSPEC_FK_INVALID,
26382                    fk: C2RustUnnamed_0 {
26383                        range: C2RustUnnamed_2 {
26384                            lastkey: 0,
26385                            keystep: 0,
26386                            limit: 0,
26387                        },
26388                    },
26389                }; 4],
26390                getkeys_proc: None,
26391                subcommands: 0 as *const redisCommand as *mut redisCommand,
26392                args: 0 as *const redisCommandArg as *mut redisCommandArg,
26393                microseconds: 0,
26394                calls: 0,
26395                rejected_calls: 0,
26396                failed_calls: 0,
26397                id: 0,
26398                fullname: 0 as *const libc::c_char as *mut libc::c_char,
26399                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
26400                key_specs: 0 as *const keySpec as *mut keySpec,
26401                legacy_range_key_spec: keySpec {
26402                    notes: 0 as *const libc::c_char,
26403                    flags: 0,
26404                    begin_search_type: KSPEC_BS_INVALID,
26405                    bs: C2RustUnnamed_3 {
26406                        index: C2RustUnnamed_5 { pos: 0 },
26407                    },
26408                    find_keys_type: KSPEC_FK_INVALID,
26409                    fk: C2RustUnnamed_0 {
26410                        range: C2RustUnnamed_2 {
26411                            lastkey: 0,
26412                            keystep: 0,
26413                            limit: 0,
26414                        },
26415                    },
26416                },
26417                num_args: 0,
26418                num_history: 0,
26419                num_tips: 0,
26420                key_specs_num: 0,
26421                key_specs_max: 0,
26422                subcommands_dict: 0 as *const dict as *mut dict,
26423                parent: 0 as *const redisCommand as *mut redisCommand,
26424                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
26425            };
26426            init
26427        },
26428    ]
26429};
26430#[no_mangle]
26431pub static mut DBSIZE_tips: [*const libc::c_char; 3] = [
26432    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
26433    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
26434    0 as *const libc::c_char,
26435];
26436#[no_mangle]
26437pub static mut FAILOVER_target_Subargs: [redisCommandArg; 4] = [
26438    {
26439        let mut init = redisCommandArg {
26440            name: b"host\0" as *const u8 as *const libc::c_char,
26441            type_0: ARG_TYPE_STRING,
26442            key_spec_index: -(1 as libc::c_int),
26443            token: 0 as *const libc::c_char,
26444            summary: 0 as *const libc::c_char,
26445            since: 0 as *const libc::c_char,
26446            flags: 0 as libc::c_int,
26447            deprecated_since: 0 as *const libc::c_char,
26448            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26449            num_args: 0,
26450        };
26451        init
26452    },
26453    {
26454        let mut init = redisCommandArg {
26455            name: b"port\0" as *const u8 as *const libc::c_char,
26456            type_0: ARG_TYPE_INTEGER,
26457            key_spec_index: -(1 as libc::c_int),
26458            token: 0 as *const libc::c_char,
26459            summary: 0 as *const libc::c_char,
26460            since: 0 as *const libc::c_char,
26461            flags: 0 as libc::c_int,
26462            deprecated_since: 0 as *const libc::c_char,
26463            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26464            num_args: 0,
26465        };
26466        init
26467    },
26468    {
26469        let mut init = redisCommandArg {
26470            name: b"force\0" as *const u8 as *const libc::c_char,
26471            type_0: ARG_TYPE_PURE_TOKEN,
26472            key_spec_index: -(1 as libc::c_int),
26473            token: b"FORCE\0" as *const u8 as *const libc::c_char,
26474            summary: 0 as *const libc::c_char,
26475            since: 0 as *const libc::c_char,
26476            flags: (1 as libc::c_int) << 0 as libc::c_int,
26477            deprecated_since: 0 as *const libc::c_char,
26478            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26479            num_args: 0,
26480        };
26481        init
26482    },
26483    {
26484        let mut init = redisCommandArg {
26485            name: 0 as *const libc::c_char,
26486            type_0: ARG_TYPE_STRING,
26487            key_spec_index: 0,
26488            token: 0 as *const libc::c_char,
26489            summary: 0 as *const libc::c_char,
26490            since: 0 as *const libc::c_char,
26491            flags: 0,
26492            deprecated_since: 0 as *const libc::c_char,
26493            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26494            num_args: 0,
26495        };
26496        init
26497    },
26498];
26499#[no_mangle]
26500pub static mut FAILOVER_Args: [redisCommandArg; 4] = unsafe {
26501    [
26502        {
26503            let mut init = redisCommandArg {
26504                name: b"target\0" as *const u8 as *const libc::c_char,
26505                type_0: ARG_TYPE_BLOCK,
26506                key_spec_index: -(1 as libc::c_int),
26507                token: b"TO\0" as *const u8 as *const libc::c_char,
26508                summary: 0 as *const libc::c_char,
26509                since: 0 as *const libc::c_char,
26510                flags: (1 as libc::c_int) << 0 as libc::c_int,
26511                deprecated_since: 0 as *const libc::c_char,
26512                subargs: FAILOVER_target_Subargs.as_ptr() as *mut _,
26513                num_args: 0,
26514            };
26515            init
26516        },
26517        {
26518            let mut init = redisCommandArg {
26519                name: b"abort\0" as *const u8 as *const libc::c_char,
26520                type_0: ARG_TYPE_PURE_TOKEN,
26521                key_spec_index: -(1 as libc::c_int),
26522                token: b"ABORT\0" as *const u8 as *const libc::c_char,
26523                summary: 0 as *const libc::c_char,
26524                since: 0 as *const libc::c_char,
26525                flags: (1 as libc::c_int) << 0 as libc::c_int,
26526                deprecated_since: 0 as *const libc::c_char,
26527                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26528                num_args: 0,
26529            };
26530            init
26531        },
26532        {
26533            let mut init = redisCommandArg {
26534                name: b"milliseconds\0" as *const u8 as *const libc::c_char,
26535                type_0: ARG_TYPE_INTEGER,
26536                key_spec_index: -(1 as libc::c_int),
26537                token: b"TIMEOUT\0" as *const u8 as *const libc::c_char,
26538                summary: 0 as *const libc::c_char,
26539                since: 0 as *const libc::c_char,
26540                flags: (1 as libc::c_int) << 0 as libc::c_int,
26541                deprecated_since: 0 as *const libc::c_char,
26542                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26543                num_args: 0,
26544            };
26545            init
26546        },
26547        {
26548            let mut init = redisCommandArg {
26549                name: 0 as *const libc::c_char,
26550                type_0: ARG_TYPE_STRING,
26551                key_spec_index: 0,
26552                token: 0 as *const libc::c_char,
26553                summary: 0 as *const libc::c_char,
26554                since: 0 as *const libc::c_char,
26555                flags: 0,
26556                deprecated_since: 0 as *const libc::c_char,
26557                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26558                num_args: 0,
26559            };
26560            init
26561        },
26562    ]
26563};
26564#[no_mangle]
26565pub static mut FLUSHALL_History: [commandHistory; 3] = [
26566    {
26567        let mut init = commandHistory {
26568            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
26569            changes: b"Added the `ASYNC` flushing mode modifier.\0" as *const u8
26570                as *const libc::c_char,
26571        };
26572        init
26573    },
26574    {
26575        let mut init = commandHistory {
26576            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
26577            changes: b"Added the `SYNC` flushing mode modifier.\0" as *const u8
26578                as *const libc::c_char,
26579        };
26580        init
26581    },
26582    {
26583        let mut init = commandHistory {
26584            since: 0 as *const libc::c_char,
26585            changes: 0 as *const libc::c_char,
26586        };
26587        init
26588    },
26589];
26590#[no_mangle]
26591pub static mut FLUSHALL_tips: [*const libc::c_char; 3] = [
26592    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
26593    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
26594    0 as *const libc::c_char,
26595];
26596#[no_mangle]
26597pub static mut FLUSHALL_async_Subargs: [redisCommandArg; 3] = [
26598    {
26599        let mut init = redisCommandArg {
26600            name: b"async\0" as *const u8 as *const libc::c_char,
26601            type_0: ARG_TYPE_PURE_TOKEN,
26602            key_spec_index: -(1 as libc::c_int),
26603            token: b"ASYNC\0" as *const u8 as *const libc::c_char,
26604            summary: 0 as *const libc::c_char,
26605            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
26606            flags: 0 as libc::c_int,
26607            deprecated_since: 0 as *const libc::c_char,
26608            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26609            num_args: 0,
26610        };
26611        init
26612    },
26613    {
26614        let mut init = redisCommandArg {
26615            name: b"sync\0" as *const u8 as *const libc::c_char,
26616            type_0: ARG_TYPE_PURE_TOKEN,
26617            key_spec_index: -(1 as libc::c_int),
26618            token: b"SYNC\0" as *const u8 as *const libc::c_char,
26619            summary: 0 as *const libc::c_char,
26620            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
26621            flags: 0 as libc::c_int,
26622            deprecated_since: 0 as *const libc::c_char,
26623            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26624            num_args: 0,
26625        };
26626        init
26627    },
26628    {
26629        let mut init = redisCommandArg {
26630            name: 0 as *const libc::c_char,
26631            type_0: ARG_TYPE_STRING,
26632            key_spec_index: 0,
26633            token: 0 as *const libc::c_char,
26634            summary: 0 as *const libc::c_char,
26635            since: 0 as *const libc::c_char,
26636            flags: 0,
26637            deprecated_since: 0 as *const libc::c_char,
26638            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26639            num_args: 0,
26640        };
26641        init
26642    },
26643];
26644#[no_mangle]
26645pub static mut FLUSHALL_Args: [redisCommandArg; 2] = unsafe {
26646    [
26647        {
26648            let mut init = redisCommandArg {
26649                name: b"async\0" as *const u8 as *const libc::c_char,
26650                type_0: ARG_TYPE_ONEOF,
26651                key_spec_index: -(1 as libc::c_int),
26652                token: 0 as *const libc::c_char,
26653                summary: 0 as *const libc::c_char,
26654                since: 0 as *const libc::c_char,
26655                flags: (1 as libc::c_int) << 0 as libc::c_int,
26656                deprecated_since: 0 as *const libc::c_char,
26657                subargs: FLUSHALL_async_Subargs.as_ptr() as *mut _,
26658                num_args: 0,
26659            };
26660            init
26661        },
26662        {
26663            let mut init = redisCommandArg {
26664                name: 0 as *const libc::c_char,
26665                type_0: ARG_TYPE_STRING,
26666                key_spec_index: 0,
26667                token: 0 as *const libc::c_char,
26668                summary: 0 as *const libc::c_char,
26669                since: 0 as *const libc::c_char,
26670                flags: 0,
26671                deprecated_since: 0 as *const libc::c_char,
26672                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26673                num_args: 0,
26674            };
26675            init
26676        },
26677    ]
26678};
26679#[no_mangle]
26680pub static mut FLUSHDB_History: [commandHistory; 3] = [
26681    {
26682        let mut init = commandHistory {
26683            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
26684            changes: b"Added the `ASYNC` flushing mode modifier.\0" as *const u8
26685                as *const libc::c_char,
26686        };
26687        init
26688    },
26689    {
26690        let mut init = commandHistory {
26691            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
26692            changes: b"Added the `SYNC` flushing mode modifier.\0" as *const u8
26693                as *const libc::c_char,
26694        };
26695        init
26696    },
26697    {
26698        let mut init = commandHistory {
26699            since: 0 as *const libc::c_char,
26700            changes: 0 as *const libc::c_char,
26701        };
26702        init
26703    },
26704];
26705#[no_mangle]
26706pub static mut FLUSHDB_tips: [*const libc::c_char; 3] = [
26707    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
26708    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
26709    0 as *const libc::c_char,
26710];
26711#[no_mangle]
26712pub static mut FLUSHDB_async_Subargs: [redisCommandArg; 3] = [
26713    {
26714        let mut init = redisCommandArg {
26715            name: b"async\0" as *const u8 as *const libc::c_char,
26716            type_0: ARG_TYPE_PURE_TOKEN,
26717            key_spec_index: -(1 as libc::c_int),
26718            token: b"ASYNC\0" as *const u8 as *const libc::c_char,
26719            summary: 0 as *const libc::c_char,
26720            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
26721            flags: 0 as libc::c_int,
26722            deprecated_since: 0 as *const libc::c_char,
26723            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26724            num_args: 0,
26725        };
26726        init
26727    },
26728    {
26729        let mut init = redisCommandArg {
26730            name: b"sync\0" as *const u8 as *const libc::c_char,
26731            type_0: ARG_TYPE_PURE_TOKEN,
26732            key_spec_index: -(1 as libc::c_int),
26733            token: b"SYNC\0" as *const u8 as *const libc::c_char,
26734            summary: 0 as *const libc::c_char,
26735            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
26736            flags: 0 as libc::c_int,
26737            deprecated_since: 0 as *const libc::c_char,
26738            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26739            num_args: 0,
26740        };
26741        init
26742    },
26743    {
26744        let mut init = redisCommandArg {
26745            name: 0 as *const libc::c_char,
26746            type_0: ARG_TYPE_STRING,
26747            key_spec_index: 0,
26748            token: 0 as *const libc::c_char,
26749            summary: 0 as *const libc::c_char,
26750            since: 0 as *const libc::c_char,
26751            flags: 0,
26752            deprecated_since: 0 as *const libc::c_char,
26753            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26754            num_args: 0,
26755        };
26756        init
26757    },
26758];
26759#[no_mangle]
26760pub static mut FLUSHDB_Args: [redisCommandArg; 2] = unsafe {
26761    [
26762        {
26763            let mut init = redisCommandArg {
26764                name: b"async\0" as *const u8 as *const libc::c_char,
26765                type_0: ARG_TYPE_ONEOF,
26766                key_spec_index: -(1 as libc::c_int),
26767                token: 0 as *const libc::c_char,
26768                summary: 0 as *const libc::c_char,
26769                since: 0 as *const libc::c_char,
26770                flags: (1 as libc::c_int) << 0 as libc::c_int,
26771                deprecated_since: 0 as *const libc::c_char,
26772                subargs: FLUSHDB_async_Subargs.as_ptr() as *mut _,
26773                num_args: 0,
26774            };
26775            init
26776        },
26777        {
26778            let mut init = redisCommandArg {
26779                name: 0 as *const libc::c_char,
26780                type_0: ARG_TYPE_STRING,
26781                key_spec_index: 0,
26782                token: 0 as *const libc::c_char,
26783                summary: 0 as *const libc::c_char,
26784                since: 0 as *const libc::c_char,
26785                flags: 0,
26786                deprecated_since: 0 as *const libc::c_char,
26787                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26788                num_args: 0,
26789            };
26790            init
26791        },
26792    ]
26793};
26794#[no_mangle]
26795pub static mut INFO_History: [commandHistory; 2] = [
26796    {
26797        let mut init = commandHistory {
26798            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
26799            changes: b"Added support for taking multiple section arguments.\0"
26800                as *const u8 as *const libc::c_char,
26801        };
26802        init
26803    },
26804    {
26805        let mut init = commandHistory {
26806            since: 0 as *const libc::c_char,
26807            changes: 0 as *const libc::c_char,
26808        };
26809        init
26810    },
26811];
26812#[no_mangle]
26813pub static mut INFO_tips: [*const libc::c_char; 4] = [
26814    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26815    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
26816    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26817    0 as *const libc::c_char,
26818];
26819#[no_mangle]
26820pub static mut INFO_Args: [redisCommandArg; 2] = [
26821    {
26822        let mut init = redisCommandArg {
26823            name: b"section\0" as *const u8 as *const libc::c_char,
26824            type_0: ARG_TYPE_STRING,
26825            key_spec_index: -(1 as libc::c_int),
26826            token: 0 as *const libc::c_char,
26827            summary: 0 as *const libc::c_char,
26828            since: 0 as *const libc::c_char,
26829            flags: (1 as libc::c_int) << 0 as libc::c_int
26830                | (1 as libc::c_int) << 1 as libc::c_int,
26831            deprecated_since: 0 as *const libc::c_char,
26832            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26833            num_args: 0,
26834        };
26835        init
26836    },
26837    {
26838        let mut init = redisCommandArg {
26839            name: 0 as *const libc::c_char,
26840            type_0: ARG_TYPE_STRING,
26841            key_spec_index: 0,
26842            token: 0 as *const libc::c_char,
26843            summary: 0 as *const libc::c_char,
26844            since: 0 as *const libc::c_char,
26845            flags: 0,
26846            deprecated_since: 0 as *const libc::c_char,
26847            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26848            num_args: 0,
26849        };
26850        init
26851    },
26852];
26853#[no_mangle]
26854pub static mut LASTSAVE_tips: [*const libc::c_char; 2] = [
26855    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26856    0 as *const libc::c_char,
26857];
26858#[no_mangle]
26859pub static mut LATENCY_DOCTOR_tips: [*const libc::c_char; 4] = [
26860    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26861    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26862    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26863    0 as *const libc::c_char,
26864];
26865#[no_mangle]
26866pub static mut LATENCY_GRAPH_tips: [*const libc::c_char; 4] = [
26867    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26868    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26869    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26870    0 as *const libc::c_char,
26871];
26872#[no_mangle]
26873pub static mut LATENCY_GRAPH_Args: [redisCommandArg; 2] = [
26874    {
26875        let mut init = redisCommandArg {
26876            name: b"event\0" as *const u8 as *const libc::c_char,
26877            type_0: ARG_TYPE_STRING,
26878            key_spec_index: -(1 as libc::c_int),
26879            token: 0 as *const libc::c_char,
26880            summary: 0 as *const libc::c_char,
26881            since: 0 as *const libc::c_char,
26882            flags: 0 as libc::c_int,
26883            deprecated_since: 0 as *const libc::c_char,
26884            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26885            num_args: 0,
26886        };
26887        init
26888    },
26889    {
26890        let mut init = redisCommandArg {
26891            name: 0 as *const libc::c_char,
26892            type_0: ARG_TYPE_STRING,
26893            key_spec_index: 0,
26894            token: 0 as *const libc::c_char,
26895            summary: 0 as *const libc::c_char,
26896            since: 0 as *const libc::c_char,
26897            flags: 0,
26898            deprecated_since: 0 as *const libc::c_char,
26899            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26900            num_args: 0,
26901        };
26902        init
26903    },
26904];
26905#[no_mangle]
26906pub static mut LATENCY_HISTOGRAM_tips: [*const libc::c_char; 4] = [
26907    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26908    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26909    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26910    0 as *const libc::c_char,
26911];
26912#[no_mangle]
26913pub static mut LATENCY_HISTOGRAM_Args: [redisCommandArg; 2] = [
26914    {
26915        let mut init = redisCommandArg {
26916            name: b"command\0" as *const u8 as *const libc::c_char,
26917            type_0: ARG_TYPE_STRING,
26918            key_spec_index: -(1 as libc::c_int),
26919            token: 0 as *const libc::c_char,
26920            summary: 0 as *const libc::c_char,
26921            since: 0 as *const libc::c_char,
26922            flags: (1 as libc::c_int) << 0 as libc::c_int
26923                | (1 as libc::c_int) << 1 as libc::c_int,
26924            deprecated_since: 0 as *const libc::c_char,
26925            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26926            num_args: 0,
26927        };
26928        init
26929    },
26930    {
26931        let mut init = redisCommandArg {
26932            name: 0 as *const libc::c_char,
26933            type_0: ARG_TYPE_STRING,
26934            key_spec_index: 0,
26935            token: 0 as *const libc::c_char,
26936            summary: 0 as *const libc::c_char,
26937            since: 0 as *const libc::c_char,
26938            flags: 0,
26939            deprecated_since: 0 as *const libc::c_char,
26940            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26941            num_args: 0,
26942        };
26943        init
26944    },
26945];
26946#[no_mangle]
26947pub static mut LATENCY_HISTORY_tips: [*const libc::c_char; 4] = [
26948    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26949    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26950    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26951    0 as *const libc::c_char,
26952];
26953#[no_mangle]
26954pub static mut LATENCY_HISTORY_Args: [redisCommandArg; 2] = [
26955    {
26956        let mut init = redisCommandArg {
26957            name: b"event\0" as *const u8 as *const libc::c_char,
26958            type_0: ARG_TYPE_STRING,
26959            key_spec_index: -(1 as libc::c_int),
26960            token: 0 as *const libc::c_char,
26961            summary: 0 as *const libc::c_char,
26962            since: 0 as *const libc::c_char,
26963            flags: 0 as libc::c_int,
26964            deprecated_since: 0 as *const libc::c_char,
26965            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26966            num_args: 0,
26967        };
26968        init
26969    },
26970    {
26971        let mut init = redisCommandArg {
26972            name: 0 as *const libc::c_char,
26973            type_0: ARG_TYPE_STRING,
26974            key_spec_index: 0,
26975            token: 0 as *const libc::c_char,
26976            summary: 0 as *const libc::c_char,
26977            since: 0 as *const libc::c_char,
26978            flags: 0,
26979            deprecated_since: 0 as *const libc::c_char,
26980            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
26981            num_args: 0,
26982        };
26983        init
26984    },
26985];
26986#[no_mangle]
26987pub static mut LATENCY_LATEST_tips: [*const libc::c_char; 4] = [
26988    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
26989    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26990    b"response_policy:special\0" as *const u8 as *const libc::c_char,
26991    0 as *const libc::c_char,
26992];
26993#[no_mangle]
26994pub static mut LATENCY_RESET_tips: [*const libc::c_char; 3] = [
26995    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
26996    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
26997    0 as *const libc::c_char,
26998];
26999#[no_mangle]
27000pub static mut LATENCY_RESET_Args: [redisCommandArg; 2] = [
27001    {
27002        let mut init = redisCommandArg {
27003            name: b"event\0" as *const u8 as *const libc::c_char,
27004            type_0: ARG_TYPE_STRING,
27005            key_spec_index: -(1 as libc::c_int),
27006            token: 0 as *const libc::c_char,
27007            summary: 0 as *const libc::c_char,
27008            since: 0 as *const libc::c_char,
27009            flags: (1 as libc::c_int) << 0 as libc::c_int
27010                | (1 as libc::c_int) << 1 as libc::c_int,
27011            deprecated_since: 0 as *const libc::c_char,
27012            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27013            num_args: 0,
27014        };
27015        init
27016    },
27017    {
27018        let mut init = redisCommandArg {
27019            name: 0 as *const libc::c_char,
27020            type_0: ARG_TYPE_STRING,
27021            key_spec_index: 0,
27022            token: 0 as *const libc::c_char,
27023            summary: 0 as *const libc::c_char,
27024            since: 0 as *const libc::c_char,
27025            flags: 0,
27026            deprecated_since: 0 as *const libc::c_char,
27027            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27028            num_args: 0,
27029        };
27030        init
27031    },
27032];
27033#[no_mangle]
27034pub static mut LATENCY_Subcommands: [redisCommand; 8] = unsafe {
27035    [
27036        {
27037            let mut init = redisCommand {
27038                declared_name: b"doctor\0" as *const u8 as *const libc::c_char,
27039                summary: b"Return a human readable latency analysis report.\0"
27040                    as *const u8 as *const libc::c_char,
27041                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27042                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27043                doc_flags: 0 as libc::c_int,
27044                replaced_by: 0 as *const libc::c_char,
27045                deprecated_since: 0 as *const libc::c_char,
27046                group: COMMAND_GROUP_SERVER,
27047                history: 0 as *const commandHistory as *mut commandHistory,
27048                tips: LATENCY_DOCTOR_tips.as_ptr() as *mut _,
27049                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27050                arity: 2 as libc::c_int,
27051                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27052                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27053                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27054                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27055                acl_categories: 0 as libc::c_int as uint64_t,
27056                key_specs_static: [keySpec {
27057                    notes: 0 as *const libc::c_char,
27058                    flags: 0,
27059                    begin_search_type: KSPEC_BS_INVALID,
27060                    bs: C2RustUnnamed_3 {
27061                        index: C2RustUnnamed_5 { pos: 0 },
27062                    },
27063                    find_keys_type: KSPEC_FK_INVALID,
27064                    fk: C2RustUnnamed_0 {
27065                        range: C2RustUnnamed_2 {
27066                            lastkey: 0,
27067                            keystep: 0,
27068                            limit: 0,
27069                        },
27070                    },
27071                }; 4],
27072                getkeys_proc: None,
27073                subcommands: 0 as *const redisCommand as *mut redisCommand,
27074                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27075                microseconds: 0,
27076                calls: 0,
27077                rejected_calls: 0,
27078                failed_calls: 0,
27079                id: 0,
27080                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27081                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27082                key_specs: 0 as *const keySpec as *mut keySpec,
27083                legacy_range_key_spec: keySpec {
27084                    notes: 0 as *const libc::c_char,
27085                    flags: 0,
27086                    begin_search_type: KSPEC_BS_INVALID,
27087                    bs: C2RustUnnamed_3 {
27088                        index: C2RustUnnamed_5 { pos: 0 },
27089                    },
27090                    find_keys_type: KSPEC_FK_INVALID,
27091                    fk: C2RustUnnamed_0 {
27092                        range: C2RustUnnamed_2 {
27093                            lastkey: 0,
27094                            keystep: 0,
27095                            limit: 0,
27096                        },
27097                    },
27098                },
27099                num_args: 0,
27100                num_history: 0,
27101                num_tips: 0,
27102                key_specs_num: 0,
27103                key_specs_max: 0,
27104                subcommands_dict: 0 as *const dict as *mut dict,
27105                parent: 0 as *const redisCommand as *mut redisCommand,
27106                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27107            };
27108            init
27109        },
27110        {
27111            let mut init = redisCommand {
27112                declared_name: b"graph\0" as *const u8 as *const libc::c_char,
27113                summary: b"Return a latency graph for the event.\0" as *const u8
27114                    as *const libc::c_char,
27115                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27116                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27117                doc_flags: 0 as libc::c_int,
27118                replaced_by: 0 as *const libc::c_char,
27119                deprecated_since: 0 as *const libc::c_char,
27120                group: COMMAND_GROUP_SERVER,
27121                history: 0 as *const commandHistory as *mut commandHistory,
27122                tips: LATENCY_GRAPH_tips.as_ptr() as *mut _,
27123                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27124                arity: 3 as libc::c_int,
27125                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27126                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27127                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27128                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27129                acl_categories: 0 as libc::c_int as uint64_t,
27130                key_specs_static: [keySpec {
27131                    notes: 0 as *const libc::c_char,
27132                    flags: 0,
27133                    begin_search_type: KSPEC_BS_INVALID,
27134                    bs: C2RustUnnamed_3 {
27135                        index: C2RustUnnamed_5 { pos: 0 },
27136                    },
27137                    find_keys_type: KSPEC_FK_INVALID,
27138                    fk: C2RustUnnamed_0 {
27139                        range: C2RustUnnamed_2 {
27140                            lastkey: 0,
27141                            keystep: 0,
27142                            limit: 0,
27143                        },
27144                    },
27145                }; 4],
27146                getkeys_proc: None,
27147                subcommands: 0 as *const redisCommand as *mut redisCommand,
27148                args: LATENCY_GRAPH_Args.as_ptr() as *mut _,
27149                microseconds: 0,
27150                calls: 0,
27151                rejected_calls: 0,
27152                failed_calls: 0,
27153                id: 0,
27154                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27155                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27156                key_specs: 0 as *const keySpec as *mut keySpec,
27157                legacy_range_key_spec: keySpec {
27158                    notes: 0 as *const libc::c_char,
27159                    flags: 0,
27160                    begin_search_type: KSPEC_BS_INVALID,
27161                    bs: C2RustUnnamed_3 {
27162                        index: C2RustUnnamed_5 { pos: 0 },
27163                    },
27164                    find_keys_type: KSPEC_FK_INVALID,
27165                    fk: C2RustUnnamed_0 {
27166                        range: C2RustUnnamed_2 {
27167                            lastkey: 0,
27168                            keystep: 0,
27169                            limit: 0,
27170                        },
27171                    },
27172                },
27173                num_args: 0,
27174                num_history: 0,
27175                num_tips: 0,
27176                key_specs_num: 0,
27177                key_specs_max: 0,
27178                subcommands_dict: 0 as *const dict as *mut dict,
27179                parent: 0 as *const redisCommand as *mut redisCommand,
27180                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27181            };
27182            init
27183        },
27184        {
27185            let mut init = redisCommand {
27186                declared_name: b"help\0" as *const u8 as *const libc::c_char,
27187                summary: b"Show helpful text about the different subcommands.\0"
27188                    as *const u8 as *const libc::c_char,
27189                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27190                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27191                doc_flags: 0 as libc::c_int,
27192                replaced_by: 0 as *const libc::c_char,
27193                deprecated_since: 0 as *const libc::c_char,
27194                group: COMMAND_GROUP_SERVER,
27195                history: 0 as *const commandHistory as *mut commandHistory,
27196                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
27197                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27198                arity: 2 as libc::c_int,
27199                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
27200                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27201                acl_categories: 0 as libc::c_int as uint64_t,
27202                key_specs_static: [keySpec {
27203                    notes: 0 as *const libc::c_char,
27204                    flags: 0,
27205                    begin_search_type: KSPEC_BS_INVALID,
27206                    bs: C2RustUnnamed_3 {
27207                        index: C2RustUnnamed_5 { pos: 0 },
27208                    },
27209                    find_keys_type: KSPEC_FK_INVALID,
27210                    fk: C2RustUnnamed_0 {
27211                        range: C2RustUnnamed_2 {
27212                            lastkey: 0,
27213                            keystep: 0,
27214                            limit: 0,
27215                        },
27216                    },
27217                }; 4],
27218                getkeys_proc: None,
27219                subcommands: 0 as *const redisCommand as *mut redisCommand,
27220                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27221                microseconds: 0,
27222                calls: 0,
27223                rejected_calls: 0,
27224                failed_calls: 0,
27225                id: 0,
27226                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27227                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27228                key_specs: 0 as *const keySpec as *mut keySpec,
27229                legacy_range_key_spec: keySpec {
27230                    notes: 0 as *const libc::c_char,
27231                    flags: 0,
27232                    begin_search_type: KSPEC_BS_INVALID,
27233                    bs: C2RustUnnamed_3 {
27234                        index: C2RustUnnamed_5 { pos: 0 },
27235                    },
27236                    find_keys_type: KSPEC_FK_INVALID,
27237                    fk: C2RustUnnamed_0 {
27238                        range: C2RustUnnamed_2 {
27239                            lastkey: 0,
27240                            keystep: 0,
27241                            limit: 0,
27242                        },
27243                    },
27244                },
27245                num_args: 0,
27246                num_history: 0,
27247                num_tips: 0,
27248                key_specs_num: 0,
27249                key_specs_max: 0,
27250                subcommands_dict: 0 as *const dict as *mut dict,
27251                parent: 0 as *const redisCommand as *mut redisCommand,
27252                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27253            };
27254            init
27255        },
27256        {
27257            let mut init = redisCommand {
27258                declared_name: b"histogram\0" as *const u8 as *const libc::c_char,
27259                summary: b"Return the cumulative distribution of latencies of a subset of commands or all.\0"
27260                    as *const u8 as *const libc::c_char,
27261                complexity: b"O(N) where N is the number of commands with latency information being retrieved.\0"
27262                    as *const u8 as *const libc::c_char,
27263                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
27264                doc_flags: 0 as libc::c_int,
27265                replaced_by: 0 as *const libc::c_char,
27266                deprecated_since: 0 as *const libc::c_char,
27267                group: COMMAND_GROUP_SERVER,
27268                history: 0 as *const commandHistory as *mut commandHistory,
27269                tips: LATENCY_HISTOGRAM_tips.as_ptr() as *mut _,
27270                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27271                arity: -(2 as libc::c_int),
27272                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27273                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27274                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27275                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27276                acl_categories: 0 as libc::c_int as uint64_t,
27277                key_specs_static: [keySpec {
27278                    notes: 0 as *const libc::c_char,
27279                    flags: 0,
27280                    begin_search_type: KSPEC_BS_INVALID,
27281                    bs: C2RustUnnamed_3 {
27282                        index: C2RustUnnamed_5 { pos: 0 },
27283                    },
27284                    find_keys_type: KSPEC_FK_INVALID,
27285                    fk: C2RustUnnamed_0 {
27286                        range: C2RustUnnamed_2 {
27287                            lastkey: 0,
27288                            keystep: 0,
27289                            limit: 0,
27290                        },
27291                    },
27292                }; 4],
27293                getkeys_proc: None,
27294                subcommands: 0 as *const redisCommand as *mut redisCommand,
27295                args: LATENCY_HISTOGRAM_Args.as_ptr() as *mut _,
27296                microseconds: 0,
27297                calls: 0,
27298                rejected_calls: 0,
27299                failed_calls: 0,
27300                id: 0,
27301                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27302                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27303                key_specs: 0 as *const keySpec as *mut keySpec,
27304                legacy_range_key_spec: keySpec {
27305                    notes: 0 as *const libc::c_char,
27306                    flags: 0,
27307                    begin_search_type: KSPEC_BS_INVALID,
27308                    bs: C2RustUnnamed_3 {
27309                        index: C2RustUnnamed_5 { pos: 0 },
27310                    },
27311                    find_keys_type: KSPEC_FK_INVALID,
27312                    fk: C2RustUnnamed_0 {
27313                        range: C2RustUnnamed_2 {
27314                            lastkey: 0,
27315                            keystep: 0,
27316                            limit: 0,
27317                        },
27318                    },
27319                },
27320                num_args: 0,
27321                num_history: 0,
27322                num_tips: 0,
27323                key_specs_num: 0,
27324                key_specs_max: 0,
27325                subcommands_dict: 0 as *const dict as *mut dict,
27326                parent: 0 as *const redisCommand as *mut redisCommand,
27327                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27328            };
27329            init
27330        },
27331        {
27332            let mut init = redisCommand {
27333                declared_name: b"history\0" as *const u8 as *const libc::c_char,
27334                summary: b"Return timestamp-latency samples for the event.\0"
27335                    as *const u8 as *const libc::c_char,
27336                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27337                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27338                doc_flags: 0 as libc::c_int,
27339                replaced_by: 0 as *const libc::c_char,
27340                deprecated_since: 0 as *const libc::c_char,
27341                group: COMMAND_GROUP_SERVER,
27342                history: 0 as *const commandHistory as *mut commandHistory,
27343                tips: LATENCY_HISTORY_tips.as_ptr() as *mut _,
27344                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27345                arity: 3 as libc::c_int,
27346                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27347                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27348                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27349                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27350                acl_categories: 0 as libc::c_int as uint64_t,
27351                key_specs_static: [keySpec {
27352                    notes: 0 as *const libc::c_char,
27353                    flags: 0,
27354                    begin_search_type: KSPEC_BS_INVALID,
27355                    bs: C2RustUnnamed_3 {
27356                        index: C2RustUnnamed_5 { pos: 0 },
27357                    },
27358                    find_keys_type: KSPEC_FK_INVALID,
27359                    fk: C2RustUnnamed_0 {
27360                        range: C2RustUnnamed_2 {
27361                            lastkey: 0,
27362                            keystep: 0,
27363                            limit: 0,
27364                        },
27365                    },
27366                }; 4],
27367                getkeys_proc: None,
27368                subcommands: 0 as *const redisCommand as *mut redisCommand,
27369                args: LATENCY_HISTORY_Args.as_ptr() as *mut _,
27370                microseconds: 0,
27371                calls: 0,
27372                rejected_calls: 0,
27373                failed_calls: 0,
27374                id: 0,
27375                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27376                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27377                key_specs: 0 as *const keySpec as *mut keySpec,
27378                legacy_range_key_spec: keySpec {
27379                    notes: 0 as *const libc::c_char,
27380                    flags: 0,
27381                    begin_search_type: KSPEC_BS_INVALID,
27382                    bs: C2RustUnnamed_3 {
27383                        index: C2RustUnnamed_5 { pos: 0 },
27384                    },
27385                    find_keys_type: KSPEC_FK_INVALID,
27386                    fk: C2RustUnnamed_0 {
27387                        range: C2RustUnnamed_2 {
27388                            lastkey: 0,
27389                            keystep: 0,
27390                            limit: 0,
27391                        },
27392                    },
27393                },
27394                num_args: 0,
27395                num_history: 0,
27396                num_tips: 0,
27397                key_specs_num: 0,
27398                key_specs_max: 0,
27399                subcommands_dict: 0 as *const dict as *mut dict,
27400                parent: 0 as *const redisCommand as *mut redisCommand,
27401                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27402            };
27403            init
27404        },
27405        {
27406            let mut init = redisCommand {
27407                declared_name: b"latest\0" as *const u8 as *const libc::c_char,
27408                summary: b"Return the latest latency samples for all events.\0"
27409                    as *const u8 as *const libc::c_char,
27410                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27411                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27412                doc_flags: 0 as libc::c_int,
27413                replaced_by: 0 as *const libc::c_char,
27414                deprecated_since: 0 as *const libc::c_char,
27415                group: COMMAND_GROUP_SERVER,
27416                history: 0 as *const commandHistory as *mut commandHistory,
27417                tips: LATENCY_LATEST_tips.as_ptr() as *mut _,
27418                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27419                arity: 2 as libc::c_int,
27420                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27421                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27422                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27423                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27424                acl_categories: 0 as libc::c_int as uint64_t,
27425                key_specs_static: [keySpec {
27426                    notes: 0 as *const libc::c_char,
27427                    flags: 0,
27428                    begin_search_type: KSPEC_BS_INVALID,
27429                    bs: C2RustUnnamed_3 {
27430                        index: C2RustUnnamed_5 { pos: 0 },
27431                    },
27432                    find_keys_type: KSPEC_FK_INVALID,
27433                    fk: C2RustUnnamed_0 {
27434                        range: C2RustUnnamed_2 {
27435                            lastkey: 0,
27436                            keystep: 0,
27437                            limit: 0,
27438                        },
27439                    },
27440                }; 4],
27441                getkeys_proc: None,
27442                subcommands: 0 as *const redisCommand as *mut redisCommand,
27443                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27444                microseconds: 0,
27445                calls: 0,
27446                rejected_calls: 0,
27447                failed_calls: 0,
27448                id: 0,
27449                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27450                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27451                key_specs: 0 as *const keySpec as *mut keySpec,
27452                legacy_range_key_spec: keySpec {
27453                    notes: 0 as *const libc::c_char,
27454                    flags: 0,
27455                    begin_search_type: KSPEC_BS_INVALID,
27456                    bs: C2RustUnnamed_3 {
27457                        index: C2RustUnnamed_5 { pos: 0 },
27458                    },
27459                    find_keys_type: KSPEC_FK_INVALID,
27460                    fk: C2RustUnnamed_0 {
27461                        range: C2RustUnnamed_2 {
27462                            lastkey: 0,
27463                            keystep: 0,
27464                            limit: 0,
27465                        },
27466                    },
27467                },
27468                num_args: 0,
27469                num_history: 0,
27470                num_tips: 0,
27471                key_specs_num: 0,
27472                key_specs_max: 0,
27473                subcommands_dict: 0 as *const dict as *mut dict,
27474                parent: 0 as *const redisCommand as *mut redisCommand,
27475                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27476            };
27477            init
27478        },
27479        {
27480            let mut init = redisCommand {
27481                declared_name: b"reset\0" as *const u8 as *const libc::c_char,
27482                summary: b"Reset latency data for one or more events.\0" as *const u8
27483                    as *const libc::c_char,
27484                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27485                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
27486                doc_flags: 0 as libc::c_int,
27487                replaced_by: 0 as *const libc::c_char,
27488                deprecated_since: 0 as *const libc::c_char,
27489                group: COMMAND_GROUP_SERVER,
27490                history: 0 as *const commandHistory as *mut commandHistory,
27491                tips: LATENCY_RESET_tips.as_ptr() as *mut _,
27492                proc_0: Some(latencyCommand as unsafe extern "C" fn(*mut client) -> ()),
27493                arity: -(2 as libc::c_int),
27494                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
27495                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
27496                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
27497                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27498                acl_categories: 0 as libc::c_int as uint64_t,
27499                key_specs_static: [keySpec {
27500                    notes: 0 as *const libc::c_char,
27501                    flags: 0,
27502                    begin_search_type: KSPEC_BS_INVALID,
27503                    bs: C2RustUnnamed_3 {
27504                        index: C2RustUnnamed_5 { pos: 0 },
27505                    },
27506                    find_keys_type: KSPEC_FK_INVALID,
27507                    fk: C2RustUnnamed_0 {
27508                        range: C2RustUnnamed_2 {
27509                            lastkey: 0,
27510                            keystep: 0,
27511                            limit: 0,
27512                        },
27513                    },
27514                }; 4],
27515                getkeys_proc: None,
27516                subcommands: 0 as *const redisCommand as *mut redisCommand,
27517                args: LATENCY_RESET_Args.as_ptr() as *mut _,
27518                microseconds: 0,
27519                calls: 0,
27520                rejected_calls: 0,
27521                failed_calls: 0,
27522                id: 0,
27523                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27524                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27525                key_specs: 0 as *const keySpec as *mut keySpec,
27526                legacy_range_key_spec: keySpec {
27527                    notes: 0 as *const libc::c_char,
27528                    flags: 0,
27529                    begin_search_type: KSPEC_BS_INVALID,
27530                    bs: C2RustUnnamed_3 {
27531                        index: C2RustUnnamed_5 { pos: 0 },
27532                    },
27533                    find_keys_type: KSPEC_FK_INVALID,
27534                    fk: C2RustUnnamed_0 {
27535                        range: C2RustUnnamed_2 {
27536                            lastkey: 0,
27537                            keystep: 0,
27538                            limit: 0,
27539                        },
27540                    },
27541                },
27542                num_args: 0,
27543                num_history: 0,
27544                num_tips: 0,
27545                key_specs_num: 0,
27546                key_specs_max: 0,
27547                subcommands_dict: 0 as *const dict as *mut dict,
27548                parent: 0 as *const redisCommand as *mut redisCommand,
27549                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27550            };
27551            init
27552        },
27553        {
27554            let mut init = redisCommand {
27555                declared_name: 0 as *const libc::c_char,
27556                summary: 0 as *const libc::c_char,
27557                complexity: 0 as *const libc::c_char,
27558                since: 0 as *const libc::c_char,
27559                doc_flags: 0,
27560                replaced_by: 0 as *const libc::c_char,
27561                deprecated_since: 0 as *const libc::c_char,
27562                group: COMMAND_GROUP_GENERIC,
27563                history: 0 as *const commandHistory as *mut commandHistory,
27564                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
27565                proc_0: None,
27566                arity: 0,
27567                flags: 0,
27568                acl_categories: 0,
27569                key_specs_static: [keySpec {
27570                    notes: 0 as *const libc::c_char,
27571                    flags: 0,
27572                    begin_search_type: KSPEC_BS_INVALID,
27573                    bs: C2RustUnnamed_3 {
27574                        index: C2RustUnnamed_5 { pos: 0 },
27575                    },
27576                    find_keys_type: KSPEC_FK_INVALID,
27577                    fk: C2RustUnnamed_0 {
27578                        range: C2RustUnnamed_2 {
27579                            lastkey: 0,
27580                            keystep: 0,
27581                            limit: 0,
27582                        },
27583                    },
27584                }; 4],
27585                getkeys_proc: None,
27586                subcommands: 0 as *const redisCommand as *mut redisCommand,
27587                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27588                microseconds: 0,
27589                calls: 0,
27590                rejected_calls: 0,
27591                failed_calls: 0,
27592                id: 0,
27593                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27594                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27595                key_specs: 0 as *const keySpec as *mut keySpec,
27596                legacy_range_key_spec: keySpec {
27597                    notes: 0 as *const libc::c_char,
27598                    flags: 0,
27599                    begin_search_type: KSPEC_BS_INVALID,
27600                    bs: C2RustUnnamed_3 {
27601                        index: C2RustUnnamed_5 { pos: 0 },
27602                    },
27603                    find_keys_type: KSPEC_FK_INVALID,
27604                    fk: C2RustUnnamed_0 {
27605                        range: C2RustUnnamed_2 {
27606                            lastkey: 0,
27607                            keystep: 0,
27608                            limit: 0,
27609                        },
27610                    },
27611                },
27612                num_args: 0,
27613                num_history: 0,
27614                num_tips: 0,
27615                key_specs_num: 0,
27616                key_specs_max: 0,
27617                subcommands_dict: 0 as *const dict as *mut dict,
27618                parent: 0 as *const redisCommand as *mut redisCommand,
27619                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27620            };
27621            init
27622        },
27623    ]
27624};
27625#[no_mangle]
27626pub static mut LOLWUT_Args: [redisCommandArg; 2] = [
27627    {
27628        let mut init = redisCommandArg {
27629            name: b"version\0" as *const u8 as *const libc::c_char,
27630            type_0: ARG_TYPE_INTEGER,
27631            key_spec_index: -(1 as libc::c_int),
27632            token: b"VERSION\0" as *const u8 as *const libc::c_char,
27633            summary: 0 as *const libc::c_char,
27634            since: 0 as *const libc::c_char,
27635            flags: (1 as libc::c_int) << 0 as libc::c_int,
27636            deprecated_since: 0 as *const libc::c_char,
27637            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27638            num_args: 0,
27639        };
27640        init
27641    },
27642    {
27643        let mut init = redisCommandArg {
27644            name: 0 as *const libc::c_char,
27645            type_0: ARG_TYPE_STRING,
27646            key_spec_index: 0,
27647            token: 0 as *const libc::c_char,
27648            summary: 0 as *const libc::c_char,
27649            since: 0 as *const libc::c_char,
27650            flags: 0,
27651            deprecated_since: 0 as *const libc::c_char,
27652            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27653            num_args: 0,
27654        };
27655        init
27656    },
27657];
27658#[no_mangle]
27659pub static mut MEMORY_DOCTOR_tips: [*const libc::c_char; 4] = [
27660    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
27661    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
27662    b"response_policy:special\0" as *const u8 as *const libc::c_char,
27663    0 as *const libc::c_char,
27664];
27665#[no_mangle]
27666pub static mut MEMORY_MALLOC_STATS_tips: [*const libc::c_char; 4] = [
27667    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
27668    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
27669    b"response_policy:special\0" as *const u8 as *const libc::c_char,
27670    0 as *const libc::c_char,
27671];
27672#[no_mangle]
27673pub static mut MEMORY_PURGE_tips: [*const libc::c_char; 3] = [
27674    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
27675    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
27676    0 as *const libc::c_char,
27677];
27678#[no_mangle]
27679pub static mut MEMORY_STATS_tips: [*const libc::c_char; 4] = [
27680    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
27681    b"request_policy:all_shards\0" as *const u8 as *const libc::c_char,
27682    b"response_policy:special\0" as *const u8 as *const libc::c_char,
27683    0 as *const libc::c_char,
27684];
27685#[no_mangle]
27686pub static mut MEMORY_USAGE_Args: [redisCommandArg; 3] = [
27687    {
27688        let mut init = redisCommandArg {
27689            name: b"key\0" as *const u8 as *const libc::c_char,
27690            type_0: ARG_TYPE_KEY,
27691            key_spec_index: 0 as libc::c_int,
27692            token: 0 as *const libc::c_char,
27693            summary: 0 as *const libc::c_char,
27694            since: 0 as *const libc::c_char,
27695            flags: 0 as libc::c_int,
27696            deprecated_since: 0 as *const libc::c_char,
27697            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27698            num_args: 0,
27699        };
27700        init
27701    },
27702    {
27703        let mut init = redisCommandArg {
27704            name: b"count\0" as *const u8 as *const libc::c_char,
27705            type_0: ARG_TYPE_INTEGER,
27706            key_spec_index: -(1 as libc::c_int),
27707            token: b"SAMPLES\0" as *const u8 as *const libc::c_char,
27708            summary: 0 as *const libc::c_char,
27709            since: 0 as *const libc::c_char,
27710            flags: (1 as libc::c_int) << 0 as libc::c_int,
27711            deprecated_since: 0 as *const libc::c_char,
27712            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27713            num_args: 0,
27714        };
27715        init
27716    },
27717    {
27718        let mut init = redisCommandArg {
27719            name: 0 as *const libc::c_char,
27720            type_0: ARG_TYPE_STRING,
27721            key_spec_index: 0,
27722            token: 0 as *const libc::c_char,
27723            summary: 0 as *const libc::c_char,
27724            since: 0 as *const libc::c_char,
27725            flags: 0,
27726            deprecated_since: 0 as *const libc::c_char,
27727            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
27728            num_args: 0,
27729        };
27730        init
27731    },
27732];
27733#[no_mangle]
27734pub static mut MEMORY_Subcommands: [redisCommand; 7] = unsafe {
27735    [
27736        {
27737            let mut init = redisCommand {
27738                declared_name: b"doctor\0" as *const u8 as *const libc::c_char,
27739                summary: b"Outputs memory problems report\0" as *const u8
27740                    as *const libc::c_char,
27741                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27742                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
27743                doc_flags: 0 as libc::c_int,
27744                replaced_by: 0 as *const libc::c_char,
27745                deprecated_since: 0 as *const libc::c_char,
27746                group: COMMAND_GROUP_SERVER,
27747                history: 0 as *const commandHistory as *mut commandHistory,
27748                tips: MEMORY_DOCTOR_tips.as_ptr() as *mut _,
27749                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
27750                arity: 2 as libc::c_int,
27751                flags: 0 as libc::c_int as uint64_t,
27752                acl_categories: 0 as libc::c_int as uint64_t,
27753                key_specs_static: [keySpec {
27754                    notes: 0 as *const libc::c_char,
27755                    flags: 0,
27756                    begin_search_type: KSPEC_BS_INVALID,
27757                    bs: C2RustUnnamed_3 {
27758                        index: C2RustUnnamed_5 { pos: 0 },
27759                    },
27760                    find_keys_type: KSPEC_FK_INVALID,
27761                    fk: C2RustUnnamed_0 {
27762                        range: C2RustUnnamed_2 {
27763                            lastkey: 0,
27764                            keystep: 0,
27765                            limit: 0,
27766                        },
27767                    },
27768                }; 4],
27769                getkeys_proc: None,
27770                subcommands: 0 as *const redisCommand as *mut redisCommand,
27771                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27772                microseconds: 0,
27773                calls: 0,
27774                rejected_calls: 0,
27775                failed_calls: 0,
27776                id: 0,
27777                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27778                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27779                key_specs: 0 as *const keySpec as *mut keySpec,
27780                legacy_range_key_spec: keySpec {
27781                    notes: 0 as *const libc::c_char,
27782                    flags: 0,
27783                    begin_search_type: KSPEC_BS_INVALID,
27784                    bs: C2RustUnnamed_3 {
27785                        index: C2RustUnnamed_5 { pos: 0 },
27786                    },
27787                    find_keys_type: KSPEC_FK_INVALID,
27788                    fk: C2RustUnnamed_0 {
27789                        range: C2RustUnnamed_2 {
27790                            lastkey: 0,
27791                            keystep: 0,
27792                            limit: 0,
27793                        },
27794                    },
27795                },
27796                num_args: 0,
27797                num_history: 0,
27798                num_tips: 0,
27799                key_specs_num: 0,
27800                key_specs_max: 0,
27801                subcommands_dict: 0 as *const dict as *mut dict,
27802                parent: 0 as *const redisCommand as *mut redisCommand,
27803                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27804            };
27805            init
27806        },
27807        {
27808            let mut init = redisCommand {
27809                declared_name: b"help\0" as *const u8 as *const libc::c_char,
27810                summary: b"Show helpful text about the different subcommands\0"
27811                    as *const u8 as *const libc::c_char,
27812                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
27813                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
27814                doc_flags: 0 as libc::c_int,
27815                replaced_by: 0 as *const libc::c_char,
27816                deprecated_since: 0 as *const libc::c_char,
27817                group: COMMAND_GROUP_SERVER,
27818                history: 0 as *const commandHistory as *mut commandHistory,
27819                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
27820                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
27821                arity: 2 as libc::c_int,
27822                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
27823                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
27824                acl_categories: 0 as libc::c_int as uint64_t,
27825                key_specs_static: [keySpec {
27826                    notes: 0 as *const libc::c_char,
27827                    flags: 0,
27828                    begin_search_type: KSPEC_BS_INVALID,
27829                    bs: C2RustUnnamed_3 {
27830                        index: C2RustUnnamed_5 { pos: 0 },
27831                    },
27832                    find_keys_type: KSPEC_FK_INVALID,
27833                    fk: C2RustUnnamed_0 {
27834                        range: C2RustUnnamed_2 {
27835                            lastkey: 0,
27836                            keystep: 0,
27837                            limit: 0,
27838                        },
27839                    },
27840                }; 4],
27841                getkeys_proc: None,
27842                subcommands: 0 as *const redisCommand as *mut redisCommand,
27843                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27844                microseconds: 0,
27845                calls: 0,
27846                rejected_calls: 0,
27847                failed_calls: 0,
27848                id: 0,
27849                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27850                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27851                key_specs: 0 as *const keySpec as *mut keySpec,
27852                legacy_range_key_spec: keySpec {
27853                    notes: 0 as *const libc::c_char,
27854                    flags: 0,
27855                    begin_search_type: KSPEC_BS_INVALID,
27856                    bs: C2RustUnnamed_3 {
27857                        index: C2RustUnnamed_5 { pos: 0 },
27858                    },
27859                    find_keys_type: KSPEC_FK_INVALID,
27860                    fk: C2RustUnnamed_0 {
27861                        range: C2RustUnnamed_2 {
27862                            lastkey: 0,
27863                            keystep: 0,
27864                            limit: 0,
27865                        },
27866                    },
27867                },
27868                num_args: 0,
27869                num_history: 0,
27870                num_tips: 0,
27871                key_specs_num: 0,
27872                key_specs_max: 0,
27873                subcommands_dict: 0 as *const dict as *mut dict,
27874                parent: 0 as *const redisCommand as *mut redisCommand,
27875                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27876            };
27877            init
27878        },
27879        {
27880            let mut init = redisCommand {
27881                declared_name: b"malloc-stats\0" as *const u8 as *const libc::c_char,
27882                summary: b"Show allocator internal stats\0" as *const u8
27883                    as *const libc::c_char,
27884                complexity: b"Depends on how much memory is allocated, could be slow\0"
27885                    as *const u8 as *const libc::c_char,
27886                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
27887                doc_flags: 0 as libc::c_int,
27888                replaced_by: 0 as *const libc::c_char,
27889                deprecated_since: 0 as *const libc::c_char,
27890                group: COMMAND_GROUP_SERVER,
27891                history: 0 as *const commandHistory as *mut commandHistory,
27892                tips: MEMORY_MALLOC_STATS_tips.as_ptr() as *mut _,
27893                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
27894                arity: 2 as libc::c_int,
27895                flags: 0 as libc::c_int as uint64_t,
27896                acl_categories: 0 as libc::c_int as uint64_t,
27897                key_specs_static: [keySpec {
27898                    notes: 0 as *const libc::c_char,
27899                    flags: 0,
27900                    begin_search_type: KSPEC_BS_INVALID,
27901                    bs: C2RustUnnamed_3 {
27902                        index: C2RustUnnamed_5 { pos: 0 },
27903                    },
27904                    find_keys_type: KSPEC_FK_INVALID,
27905                    fk: C2RustUnnamed_0 {
27906                        range: C2RustUnnamed_2 {
27907                            lastkey: 0,
27908                            keystep: 0,
27909                            limit: 0,
27910                        },
27911                    },
27912                }; 4],
27913                getkeys_proc: None,
27914                subcommands: 0 as *const redisCommand as *mut redisCommand,
27915                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27916                microseconds: 0,
27917                calls: 0,
27918                rejected_calls: 0,
27919                failed_calls: 0,
27920                id: 0,
27921                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27922                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27923                key_specs: 0 as *const keySpec as *mut keySpec,
27924                legacy_range_key_spec: keySpec {
27925                    notes: 0 as *const libc::c_char,
27926                    flags: 0,
27927                    begin_search_type: KSPEC_BS_INVALID,
27928                    bs: C2RustUnnamed_3 {
27929                        index: C2RustUnnamed_5 { pos: 0 },
27930                    },
27931                    find_keys_type: KSPEC_FK_INVALID,
27932                    fk: C2RustUnnamed_0 {
27933                        range: C2RustUnnamed_2 {
27934                            lastkey: 0,
27935                            keystep: 0,
27936                            limit: 0,
27937                        },
27938                    },
27939                },
27940                num_args: 0,
27941                num_history: 0,
27942                num_tips: 0,
27943                key_specs_num: 0,
27944                key_specs_max: 0,
27945                subcommands_dict: 0 as *const dict as *mut dict,
27946                parent: 0 as *const redisCommand as *mut redisCommand,
27947                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
27948            };
27949            init
27950        },
27951        {
27952            let mut init = redisCommand {
27953                declared_name: b"purge\0" as *const u8 as *const libc::c_char,
27954                summary: b"Ask the allocator to release memory\0" as *const u8
27955                    as *const libc::c_char,
27956                complexity: b"Depends on how much memory is allocated, could be slow\0"
27957                    as *const u8 as *const libc::c_char,
27958                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
27959                doc_flags: 0 as libc::c_int,
27960                replaced_by: 0 as *const libc::c_char,
27961                deprecated_since: 0 as *const libc::c_char,
27962                group: COMMAND_GROUP_SERVER,
27963                history: 0 as *const commandHistory as *mut commandHistory,
27964                tips: MEMORY_PURGE_tips.as_ptr() as *mut _,
27965                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
27966                arity: 2 as libc::c_int,
27967                flags: 0 as libc::c_int as uint64_t,
27968                acl_categories: 0 as libc::c_int as uint64_t,
27969                key_specs_static: [keySpec {
27970                    notes: 0 as *const libc::c_char,
27971                    flags: 0,
27972                    begin_search_type: KSPEC_BS_INVALID,
27973                    bs: C2RustUnnamed_3 {
27974                        index: C2RustUnnamed_5 { pos: 0 },
27975                    },
27976                    find_keys_type: KSPEC_FK_INVALID,
27977                    fk: C2RustUnnamed_0 {
27978                        range: C2RustUnnamed_2 {
27979                            lastkey: 0,
27980                            keystep: 0,
27981                            limit: 0,
27982                        },
27983                    },
27984                }; 4],
27985                getkeys_proc: None,
27986                subcommands: 0 as *const redisCommand as *mut redisCommand,
27987                args: 0 as *const redisCommandArg as *mut redisCommandArg,
27988                microseconds: 0,
27989                calls: 0,
27990                rejected_calls: 0,
27991                failed_calls: 0,
27992                id: 0,
27993                fullname: 0 as *const libc::c_char as *mut libc::c_char,
27994                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
27995                key_specs: 0 as *const keySpec as *mut keySpec,
27996                legacy_range_key_spec: keySpec {
27997                    notes: 0 as *const libc::c_char,
27998                    flags: 0,
27999                    begin_search_type: KSPEC_BS_INVALID,
28000                    bs: C2RustUnnamed_3 {
28001                        index: C2RustUnnamed_5 { pos: 0 },
28002                    },
28003                    find_keys_type: KSPEC_FK_INVALID,
28004                    fk: C2RustUnnamed_0 {
28005                        range: C2RustUnnamed_2 {
28006                            lastkey: 0,
28007                            keystep: 0,
28008                            limit: 0,
28009                        },
28010                    },
28011                },
28012                num_args: 0,
28013                num_history: 0,
28014                num_tips: 0,
28015                key_specs_num: 0,
28016                key_specs_max: 0,
28017                subcommands_dict: 0 as *const dict as *mut dict,
28018                parent: 0 as *const redisCommand as *mut redisCommand,
28019                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28020            };
28021            init
28022        },
28023        {
28024            let mut init = redisCommand {
28025                declared_name: b"stats\0" as *const u8 as *const libc::c_char,
28026                summary: b"Show memory usage details\0" as *const u8
28027                    as *const libc::c_char,
28028                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
28029                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
28030                doc_flags: 0 as libc::c_int,
28031                replaced_by: 0 as *const libc::c_char,
28032                deprecated_since: 0 as *const libc::c_char,
28033                group: COMMAND_GROUP_SERVER,
28034                history: 0 as *const commandHistory as *mut commandHistory,
28035                tips: MEMORY_STATS_tips.as_ptr() as *mut _,
28036                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
28037                arity: 2 as libc::c_int,
28038                flags: 0 as libc::c_int as uint64_t,
28039                acl_categories: 0 as libc::c_int as uint64_t,
28040                key_specs_static: [keySpec {
28041                    notes: 0 as *const libc::c_char,
28042                    flags: 0,
28043                    begin_search_type: KSPEC_BS_INVALID,
28044                    bs: C2RustUnnamed_3 {
28045                        index: C2RustUnnamed_5 { pos: 0 },
28046                    },
28047                    find_keys_type: KSPEC_FK_INVALID,
28048                    fk: C2RustUnnamed_0 {
28049                        range: C2RustUnnamed_2 {
28050                            lastkey: 0,
28051                            keystep: 0,
28052                            limit: 0,
28053                        },
28054                    },
28055                }; 4],
28056                getkeys_proc: None,
28057                subcommands: 0 as *const redisCommand as *mut redisCommand,
28058                args: 0 as *const redisCommandArg as *mut redisCommandArg,
28059                microseconds: 0,
28060                calls: 0,
28061                rejected_calls: 0,
28062                failed_calls: 0,
28063                id: 0,
28064                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28065                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28066                key_specs: 0 as *const keySpec as *mut keySpec,
28067                legacy_range_key_spec: keySpec {
28068                    notes: 0 as *const libc::c_char,
28069                    flags: 0,
28070                    begin_search_type: KSPEC_BS_INVALID,
28071                    bs: C2RustUnnamed_3 {
28072                        index: C2RustUnnamed_5 { pos: 0 },
28073                    },
28074                    find_keys_type: KSPEC_FK_INVALID,
28075                    fk: C2RustUnnamed_0 {
28076                        range: C2RustUnnamed_2 {
28077                            lastkey: 0,
28078                            keystep: 0,
28079                            limit: 0,
28080                        },
28081                    },
28082                },
28083                num_args: 0,
28084                num_history: 0,
28085                num_tips: 0,
28086                key_specs_num: 0,
28087                key_specs_max: 0,
28088                subcommands_dict: 0 as *const dict as *mut dict,
28089                parent: 0 as *const redisCommand as *mut redisCommand,
28090                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28091            };
28092            init
28093        },
28094        {
28095            let mut init = redisCommand {
28096                declared_name: b"usage\0" as *const u8 as *const libc::c_char,
28097                summary: b"Estimate the memory usage of a key\0" as *const u8
28098                    as *const libc::c_char,
28099                complexity: b"O(N) where N is the number of samples.\0" as *const u8
28100                    as *const libc::c_char,
28101                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
28102                doc_flags: 0 as libc::c_int,
28103                replaced_by: 0 as *const libc::c_char,
28104                deprecated_since: 0 as *const libc::c_char,
28105                group: COMMAND_GROUP_SERVER,
28106                history: 0 as *const commandHistory as *mut commandHistory,
28107                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28108                proc_0: Some(memoryCommand as unsafe extern "C" fn(*mut client) -> ()),
28109                arity: -(3 as libc::c_int),
28110                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
28111                acl_categories: 0 as libc::c_int as uint64_t,
28112                key_specs_static: [
28113                    {
28114                        let mut init = keySpec {
28115                            notes: 0 as *const libc::c_char,
28116                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
28117                                as uint64_t,
28118                            begin_search_type: KSPEC_BS_INDEX,
28119                            bs: C2RustUnnamed_3 {
28120                                index: {
28121                                    let mut init = C2RustUnnamed_5 {
28122                                        pos: 2 as libc::c_int,
28123                                    };
28124                                    init
28125                                },
28126                            },
28127                            find_keys_type: KSPEC_FK_RANGE,
28128                            fk: C2RustUnnamed_0 {
28129                                range: {
28130                                    let mut init = C2RustUnnamed_2 {
28131                                        lastkey: 0 as libc::c_int,
28132                                        keystep: 1 as libc::c_int,
28133                                        limit: 0 as libc::c_int,
28134                                    };
28135                                    init
28136                                },
28137                            },
28138                        };
28139                        init
28140                    },
28141                    keySpec {
28142                        notes: 0 as *const libc::c_char,
28143                        flags: 0,
28144                        begin_search_type: KSPEC_BS_INVALID,
28145                        bs: C2RustUnnamed_3 {
28146                            index: C2RustUnnamed_5 { pos: 0 },
28147                        },
28148                        find_keys_type: KSPEC_FK_INVALID,
28149                        fk: C2RustUnnamed_0 {
28150                            range: C2RustUnnamed_2 {
28151                                lastkey: 0,
28152                                keystep: 0,
28153                                limit: 0,
28154                            },
28155                        },
28156                    },
28157                    keySpec {
28158                        notes: 0 as *const libc::c_char,
28159                        flags: 0,
28160                        begin_search_type: KSPEC_BS_INVALID,
28161                        bs: C2RustUnnamed_3 {
28162                            index: C2RustUnnamed_5 { pos: 0 },
28163                        },
28164                        find_keys_type: KSPEC_FK_INVALID,
28165                        fk: C2RustUnnamed_0 {
28166                            range: C2RustUnnamed_2 {
28167                                lastkey: 0,
28168                                keystep: 0,
28169                                limit: 0,
28170                            },
28171                        },
28172                    },
28173                    keySpec {
28174                        notes: 0 as *const libc::c_char,
28175                        flags: 0,
28176                        begin_search_type: KSPEC_BS_INVALID,
28177                        bs: C2RustUnnamed_3 {
28178                            index: C2RustUnnamed_5 { pos: 0 },
28179                        },
28180                        find_keys_type: KSPEC_FK_INVALID,
28181                        fk: C2RustUnnamed_0 {
28182                            range: C2RustUnnamed_2 {
28183                                lastkey: 0,
28184                                keystep: 0,
28185                                limit: 0,
28186                            },
28187                        },
28188                    },
28189                ],
28190                getkeys_proc: None,
28191                subcommands: 0 as *const redisCommand as *mut redisCommand,
28192                args: MEMORY_USAGE_Args.as_ptr() as *mut _,
28193                microseconds: 0,
28194                calls: 0,
28195                rejected_calls: 0,
28196                failed_calls: 0,
28197                id: 0,
28198                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28199                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28200                key_specs: 0 as *const keySpec as *mut keySpec,
28201                legacy_range_key_spec: keySpec {
28202                    notes: 0 as *const libc::c_char,
28203                    flags: 0,
28204                    begin_search_type: KSPEC_BS_INVALID,
28205                    bs: C2RustUnnamed_3 {
28206                        index: C2RustUnnamed_5 { pos: 0 },
28207                    },
28208                    find_keys_type: KSPEC_FK_INVALID,
28209                    fk: C2RustUnnamed_0 {
28210                        range: C2RustUnnamed_2 {
28211                            lastkey: 0,
28212                            keystep: 0,
28213                            limit: 0,
28214                        },
28215                    },
28216                },
28217                num_args: 0,
28218                num_history: 0,
28219                num_tips: 0,
28220                key_specs_num: 0,
28221                key_specs_max: 0,
28222                subcommands_dict: 0 as *const dict as *mut dict,
28223                parent: 0 as *const redisCommand as *mut redisCommand,
28224                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28225            };
28226            init
28227        },
28228        {
28229            let mut init = redisCommand {
28230                declared_name: 0 as *const libc::c_char,
28231                summary: 0 as *const libc::c_char,
28232                complexity: 0 as *const libc::c_char,
28233                since: 0 as *const libc::c_char,
28234                doc_flags: 0,
28235                replaced_by: 0 as *const libc::c_char,
28236                deprecated_since: 0 as *const libc::c_char,
28237                group: COMMAND_GROUP_GENERIC,
28238                history: 0 as *const commandHistory as *mut commandHistory,
28239                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28240                proc_0: None,
28241                arity: 0,
28242                flags: 0,
28243                acl_categories: 0,
28244                key_specs_static: [keySpec {
28245                    notes: 0 as *const libc::c_char,
28246                    flags: 0,
28247                    begin_search_type: KSPEC_BS_INVALID,
28248                    bs: C2RustUnnamed_3 {
28249                        index: C2RustUnnamed_5 { pos: 0 },
28250                    },
28251                    find_keys_type: KSPEC_FK_INVALID,
28252                    fk: C2RustUnnamed_0 {
28253                        range: C2RustUnnamed_2 {
28254                            lastkey: 0,
28255                            keystep: 0,
28256                            limit: 0,
28257                        },
28258                    },
28259                }; 4],
28260                getkeys_proc: None,
28261                subcommands: 0 as *const redisCommand as *mut redisCommand,
28262                args: 0 as *const redisCommandArg as *mut redisCommandArg,
28263                microseconds: 0,
28264                calls: 0,
28265                rejected_calls: 0,
28266                failed_calls: 0,
28267                id: 0,
28268                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28269                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28270                key_specs: 0 as *const keySpec as *mut keySpec,
28271                legacy_range_key_spec: keySpec {
28272                    notes: 0 as *const libc::c_char,
28273                    flags: 0,
28274                    begin_search_type: KSPEC_BS_INVALID,
28275                    bs: C2RustUnnamed_3 {
28276                        index: C2RustUnnamed_5 { pos: 0 },
28277                    },
28278                    find_keys_type: KSPEC_FK_INVALID,
28279                    fk: C2RustUnnamed_0 {
28280                        range: C2RustUnnamed_2 {
28281                            lastkey: 0,
28282                            keystep: 0,
28283                            limit: 0,
28284                        },
28285                    },
28286                },
28287                num_args: 0,
28288                num_history: 0,
28289                num_tips: 0,
28290                key_specs_num: 0,
28291                key_specs_max: 0,
28292                subcommands_dict: 0 as *const dict as *mut dict,
28293                parent: 0 as *const redisCommand as *mut redisCommand,
28294                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28295            };
28296            init
28297        },
28298    ]
28299};
28300#[no_mangle]
28301pub static mut MODULE_LIST_tips: [*const libc::c_char; 2] = [
28302    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
28303    0 as *const libc::c_char,
28304];
28305#[no_mangle]
28306pub static mut MODULE_LOAD_Args: [redisCommandArg; 3] = [
28307    {
28308        let mut init = redisCommandArg {
28309            name: b"path\0" as *const u8 as *const libc::c_char,
28310            type_0: ARG_TYPE_STRING,
28311            key_spec_index: -(1 as libc::c_int),
28312            token: 0 as *const libc::c_char,
28313            summary: 0 as *const libc::c_char,
28314            since: 0 as *const libc::c_char,
28315            flags: 0 as libc::c_int,
28316            deprecated_since: 0 as *const libc::c_char,
28317            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28318            num_args: 0,
28319        };
28320        init
28321    },
28322    {
28323        let mut init = redisCommandArg {
28324            name: b"arg\0" as *const u8 as *const libc::c_char,
28325            type_0: ARG_TYPE_STRING,
28326            key_spec_index: -(1 as libc::c_int),
28327            token: 0 as *const libc::c_char,
28328            summary: 0 as *const libc::c_char,
28329            since: 0 as *const libc::c_char,
28330            flags: (1 as libc::c_int) << 0 as libc::c_int
28331                | (1 as libc::c_int) << 1 as libc::c_int,
28332            deprecated_since: 0 as *const libc::c_char,
28333            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28334            num_args: 0,
28335        };
28336        init
28337    },
28338    {
28339        let mut init = redisCommandArg {
28340            name: 0 as *const libc::c_char,
28341            type_0: ARG_TYPE_STRING,
28342            key_spec_index: 0,
28343            token: 0 as *const libc::c_char,
28344            summary: 0 as *const libc::c_char,
28345            since: 0 as *const libc::c_char,
28346            flags: 0,
28347            deprecated_since: 0 as *const libc::c_char,
28348            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28349            num_args: 0,
28350        };
28351        init
28352    },
28353];
28354#[no_mangle]
28355pub static mut MODULE_LOADEX_configs_Subargs: [redisCommandArg; 3] = [
28356    {
28357        let mut init = redisCommandArg {
28358            name: b"name\0" as *const u8 as *const libc::c_char,
28359            type_0: ARG_TYPE_STRING,
28360            key_spec_index: -(1 as libc::c_int),
28361            token: 0 as *const libc::c_char,
28362            summary: 0 as *const libc::c_char,
28363            since: 0 as *const libc::c_char,
28364            flags: 0 as libc::c_int,
28365            deprecated_since: 0 as *const libc::c_char,
28366            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28367            num_args: 0,
28368        };
28369        init
28370    },
28371    {
28372        let mut init = redisCommandArg {
28373            name: b"value\0" as *const u8 as *const libc::c_char,
28374            type_0: ARG_TYPE_STRING,
28375            key_spec_index: -(1 as libc::c_int),
28376            token: 0 as *const libc::c_char,
28377            summary: 0 as *const libc::c_char,
28378            since: 0 as *const libc::c_char,
28379            flags: 0 as libc::c_int,
28380            deprecated_since: 0 as *const libc::c_char,
28381            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28382            num_args: 0,
28383        };
28384        init
28385    },
28386    {
28387        let mut init = redisCommandArg {
28388            name: 0 as *const libc::c_char,
28389            type_0: ARG_TYPE_STRING,
28390            key_spec_index: 0,
28391            token: 0 as *const libc::c_char,
28392            summary: 0 as *const libc::c_char,
28393            since: 0 as *const libc::c_char,
28394            flags: 0,
28395            deprecated_since: 0 as *const libc::c_char,
28396            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28397            num_args: 0,
28398        };
28399        init
28400    },
28401];
28402#[no_mangle]
28403pub static mut MODULE_LOADEX_args_Subargs: [redisCommandArg; 2] = [
28404    {
28405        let mut init = redisCommandArg {
28406            name: b"arg\0" as *const u8 as *const libc::c_char,
28407            type_0: ARG_TYPE_STRING,
28408            key_spec_index: -(1 as libc::c_int),
28409            token: 0 as *const libc::c_char,
28410            summary: 0 as *const libc::c_char,
28411            since: 0 as *const libc::c_char,
28412            flags: 0 as libc::c_int,
28413            deprecated_since: 0 as *const libc::c_char,
28414            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28415            num_args: 0,
28416        };
28417        init
28418    },
28419    {
28420        let mut init = redisCommandArg {
28421            name: 0 as *const libc::c_char,
28422            type_0: ARG_TYPE_STRING,
28423            key_spec_index: 0,
28424            token: 0 as *const libc::c_char,
28425            summary: 0 as *const libc::c_char,
28426            since: 0 as *const libc::c_char,
28427            flags: 0,
28428            deprecated_since: 0 as *const libc::c_char,
28429            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28430            num_args: 0,
28431        };
28432        init
28433    },
28434];
28435#[no_mangle]
28436pub static mut MODULE_LOADEX_Args: [redisCommandArg; 4] = unsafe {
28437    [
28438        {
28439            let mut init = redisCommandArg {
28440                name: b"path\0" as *const u8 as *const libc::c_char,
28441                type_0: ARG_TYPE_STRING,
28442                key_spec_index: -(1 as libc::c_int),
28443                token: 0 as *const libc::c_char,
28444                summary: 0 as *const libc::c_char,
28445                since: 0 as *const libc::c_char,
28446                flags: 0 as libc::c_int,
28447                deprecated_since: 0 as *const libc::c_char,
28448                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28449                num_args: 0,
28450            };
28451            init
28452        },
28453        {
28454            let mut init = redisCommandArg {
28455                name: b"configs\0" as *const u8 as *const libc::c_char,
28456                type_0: ARG_TYPE_BLOCK,
28457                key_spec_index: -(1 as libc::c_int),
28458                token: b"CONFIG\0" as *const u8 as *const libc::c_char,
28459                summary: 0 as *const libc::c_char,
28460                since: 0 as *const libc::c_char,
28461                flags: (1 as libc::c_int) << 0 as libc::c_int
28462                    | (1 as libc::c_int) << 1 as libc::c_int
28463                    | (1 as libc::c_int) << 2 as libc::c_int,
28464                deprecated_since: 0 as *const libc::c_char,
28465                subargs: MODULE_LOADEX_configs_Subargs.as_ptr() as *mut _,
28466                num_args: 0,
28467            };
28468            init
28469        },
28470        {
28471            let mut init = redisCommandArg {
28472                name: b"args\0" as *const u8 as *const libc::c_char,
28473                type_0: ARG_TYPE_BLOCK,
28474                key_spec_index: -(1 as libc::c_int),
28475                token: b"ARGS\0" as *const u8 as *const libc::c_char,
28476                summary: 0 as *const libc::c_char,
28477                since: 0 as *const libc::c_char,
28478                flags: (1 as libc::c_int) << 0 as libc::c_int
28479                    | (1 as libc::c_int) << 1 as libc::c_int,
28480                deprecated_since: 0 as *const libc::c_char,
28481                subargs: MODULE_LOADEX_args_Subargs.as_ptr() as *mut _,
28482                num_args: 0,
28483            };
28484            init
28485        },
28486        {
28487            let mut init = redisCommandArg {
28488                name: 0 as *const libc::c_char,
28489                type_0: ARG_TYPE_STRING,
28490                key_spec_index: 0,
28491                token: 0 as *const libc::c_char,
28492                summary: 0 as *const libc::c_char,
28493                since: 0 as *const libc::c_char,
28494                flags: 0,
28495                deprecated_since: 0 as *const libc::c_char,
28496                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28497                num_args: 0,
28498            };
28499            init
28500        },
28501    ]
28502};
28503#[no_mangle]
28504pub static mut MODULE_UNLOAD_Args: [redisCommandArg; 2] = [
28505    {
28506        let mut init = redisCommandArg {
28507            name: b"name\0" as *const u8 as *const libc::c_char,
28508            type_0: ARG_TYPE_STRING,
28509            key_spec_index: -(1 as libc::c_int),
28510            token: 0 as *const libc::c_char,
28511            summary: 0 as *const libc::c_char,
28512            since: 0 as *const libc::c_char,
28513            flags: 0 as libc::c_int,
28514            deprecated_since: 0 as *const libc::c_char,
28515            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28516            num_args: 0,
28517        };
28518        init
28519    },
28520    {
28521        let mut init = redisCommandArg {
28522            name: 0 as *const libc::c_char,
28523            type_0: ARG_TYPE_STRING,
28524            key_spec_index: 0,
28525            token: 0 as *const libc::c_char,
28526            summary: 0 as *const libc::c_char,
28527            since: 0 as *const libc::c_char,
28528            flags: 0,
28529            deprecated_since: 0 as *const libc::c_char,
28530            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28531            num_args: 0,
28532        };
28533        init
28534    },
28535];
28536#[no_mangle]
28537pub static mut MODULE_Subcommands: [redisCommand; 6] = unsafe {
28538    [
28539        {
28540            let mut init = redisCommand {
28541                declared_name: b"help\0" as *const u8 as *const libc::c_char,
28542                summary: b"Show helpful text about the different subcommands\0"
28543                    as *const u8 as *const libc::c_char,
28544                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
28545                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
28546                doc_flags: 0 as libc::c_int,
28547                replaced_by: 0 as *const libc::c_char,
28548                deprecated_since: 0 as *const libc::c_char,
28549                group: COMMAND_GROUP_SERVER,
28550                history: 0 as *const commandHistory as *mut commandHistory,
28551                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28552                proc_0: Some(moduleCommand as unsafe extern "C" fn(*mut client) -> ()),
28553                arity: 2 as libc::c_int,
28554                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
28555                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
28556                acl_categories: 0 as libc::c_int as uint64_t,
28557                key_specs_static: [keySpec {
28558                    notes: 0 as *const libc::c_char,
28559                    flags: 0,
28560                    begin_search_type: KSPEC_BS_INVALID,
28561                    bs: C2RustUnnamed_3 {
28562                        index: C2RustUnnamed_5 { pos: 0 },
28563                    },
28564                    find_keys_type: KSPEC_FK_INVALID,
28565                    fk: C2RustUnnamed_0 {
28566                        range: C2RustUnnamed_2 {
28567                            lastkey: 0,
28568                            keystep: 0,
28569                            limit: 0,
28570                        },
28571                    },
28572                }; 4],
28573                getkeys_proc: None,
28574                subcommands: 0 as *const redisCommand as *mut redisCommand,
28575                args: 0 as *const redisCommandArg as *mut redisCommandArg,
28576                microseconds: 0,
28577                calls: 0,
28578                rejected_calls: 0,
28579                failed_calls: 0,
28580                id: 0,
28581                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28582                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28583                key_specs: 0 as *const keySpec as *mut keySpec,
28584                legacy_range_key_spec: keySpec {
28585                    notes: 0 as *const libc::c_char,
28586                    flags: 0,
28587                    begin_search_type: KSPEC_BS_INVALID,
28588                    bs: C2RustUnnamed_3 {
28589                        index: C2RustUnnamed_5 { pos: 0 },
28590                    },
28591                    find_keys_type: KSPEC_FK_INVALID,
28592                    fk: C2RustUnnamed_0 {
28593                        range: C2RustUnnamed_2 {
28594                            lastkey: 0,
28595                            keystep: 0,
28596                            limit: 0,
28597                        },
28598                    },
28599                },
28600                num_args: 0,
28601                num_history: 0,
28602                num_tips: 0,
28603                key_specs_num: 0,
28604                key_specs_max: 0,
28605                subcommands_dict: 0 as *const dict as *mut dict,
28606                parent: 0 as *const redisCommand as *mut redisCommand,
28607                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28608            };
28609            init
28610        },
28611        {
28612            let mut init = redisCommand {
28613                declared_name: b"list\0" as *const u8 as *const libc::c_char,
28614                summary: b"List all modules loaded by the server\0" as *const u8
28615                    as *const libc::c_char,
28616                complexity: b"O(N) where N is the number of loaded modules.\0"
28617                    as *const u8 as *const libc::c_char,
28618                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
28619                doc_flags: 0 as libc::c_int,
28620                replaced_by: 0 as *const libc::c_char,
28621                deprecated_since: 0 as *const libc::c_char,
28622                group: COMMAND_GROUP_SERVER,
28623                history: 0 as *const commandHistory as *mut commandHistory,
28624                tips: MODULE_LIST_tips.as_ptr() as *mut _,
28625                proc_0: Some(moduleCommand as unsafe extern "C" fn(*mut client) -> ()),
28626                arity: 2 as libc::c_int,
28627                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
28628                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
28629                acl_categories: 0 as libc::c_int as uint64_t,
28630                key_specs_static: [keySpec {
28631                    notes: 0 as *const libc::c_char,
28632                    flags: 0,
28633                    begin_search_type: KSPEC_BS_INVALID,
28634                    bs: C2RustUnnamed_3 {
28635                        index: C2RustUnnamed_5 { pos: 0 },
28636                    },
28637                    find_keys_type: KSPEC_FK_INVALID,
28638                    fk: C2RustUnnamed_0 {
28639                        range: C2RustUnnamed_2 {
28640                            lastkey: 0,
28641                            keystep: 0,
28642                            limit: 0,
28643                        },
28644                    },
28645                }; 4],
28646                getkeys_proc: None,
28647                subcommands: 0 as *const redisCommand as *mut redisCommand,
28648                args: 0 as *const redisCommandArg as *mut redisCommandArg,
28649                microseconds: 0,
28650                calls: 0,
28651                rejected_calls: 0,
28652                failed_calls: 0,
28653                id: 0,
28654                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28655                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28656                key_specs: 0 as *const keySpec as *mut keySpec,
28657                legacy_range_key_spec: keySpec {
28658                    notes: 0 as *const libc::c_char,
28659                    flags: 0,
28660                    begin_search_type: KSPEC_BS_INVALID,
28661                    bs: C2RustUnnamed_3 {
28662                        index: C2RustUnnamed_5 { pos: 0 },
28663                    },
28664                    find_keys_type: KSPEC_FK_INVALID,
28665                    fk: C2RustUnnamed_0 {
28666                        range: C2RustUnnamed_2 {
28667                            lastkey: 0,
28668                            keystep: 0,
28669                            limit: 0,
28670                        },
28671                    },
28672                },
28673                num_args: 0,
28674                num_history: 0,
28675                num_tips: 0,
28676                key_specs_num: 0,
28677                key_specs_max: 0,
28678                subcommands_dict: 0 as *const dict as *mut dict,
28679                parent: 0 as *const redisCommand as *mut redisCommand,
28680                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28681            };
28682            init
28683        },
28684        {
28685            let mut init = redisCommand {
28686                declared_name: b"load\0" as *const u8 as *const libc::c_char,
28687                summary: b"Load a module\0" as *const u8 as *const libc::c_char,
28688                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
28689                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
28690                doc_flags: 0 as libc::c_int,
28691                replaced_by: 0 as *const libc::c_char,
28692                deprecated_since: 0 as *const libc::c_char,
28693                group: COMMAND_GROUP_SERVER,
28694                history: 0 as *const commandHistory as *mut commandHistory,
28695                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28696                proc_0: Some(moduleCommand as unsafe extern "C" fn(*mut client) -> ()),
28697                arity: -(3 as libc::c_int),
28698                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
28699                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
28700                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
28701                    | (1 as libc::c_ulonglong) << 20 as libc::c_int) as uint64_t,
28702                acl_categories: 0 as libc::c_int as uint64_t,
28703                key_specs_static: [keySpec {
28704                    notes: 0 as *const libc::c_char,
28705                    flags: 0,
28706                    begin_search_type: KSPEC_BS_INVALID,
28707                    bs: C2RustUnnamed_3 {
28708                        index: C2RustUnnamed_5 { pos: 0 },
28709                    },
28710                    find_keys_type: KSPEC_FK_INVALID,
28711                    fk: C2RustUnnamed_0 {
28712                        range: C2RustUnnamed_2 {
28713                            lastkey: 0,
28714                            keystep: 0,
28715                            limit: 0,
28716                        },
28717                    },
28718                }; 4],
28719                getkeys_proc: None,
28720                subcommands: 0 as *const redisCommand as *mut redisCommand,
28721                args: MODULE_LOAD_Args.as_ptr() as *mut _,
28722                microseconds: 0,
28723                calls: 0,
28724                rejected_calls: 0,
28725                failed_calls: 0,
28726                id: 0,
28727                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28728                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28729                key_specs: 0 as *const keySpec as *mut keySpec,
28730                legacy_range_key_spec: keySpec {
28731                    notes: 0 as *const libc::c_char,
28732                    flags: 0,
28733                    begin_search_type: KSPEC_BS_INVALID,
28734                    bs: C2RustUnnamed_3 {
28735                        index: C2RustUnnamed_5 { pos: 0 },
28736                    },
28737                    find_keys_type: KSPEC_FK_INVALID,
28738                    fk: C2RustUnnamed_0 {
28739                        range: C2RustUnnamed_2 {
28740                            lastkey: 0,
28741                            keystep: 0,
28742                            limit: 0,
28743                        },
28744                    },
28745                },
28746                num_args: 0,
28747                num_history: 0,
28748                num_tips: 0,
28749                key_specs_num: 0,
28750                key_specs_max: 0,
28751                subcommands_dict: 0 as *const dict as *mut dict,
28752                parent: 0 as *const redisCommand as *mut redisCommand,
28753                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28754            };
28755            init
28756        },
28757        {
28758            let mut init = redisCommand {
28759                declared_name: b"loadex\0" as *const u8 as *const libc::c_char,
28760                summary: b"Load a module with extended parameters\0" as *const u8
28761                    as *const libc::c_char,
28762                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
28763                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
28764                doc_flags: 0 as libc::c_int,
28765                replaced_by: 0 as *const libc::c_char,
28766                deprecated_since: 0 as *const libc::c_char,
28767                group: COMMAND_GROUP_SERVER,
28768                history: 0 as *const commandHistory as *mut commandHistory,
28769                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28770                proc_0: Some(moduleCommand as unsafe extern "C" fn(*mut client) -> ()),
28771                arity: -(3 as libc::c_int),
28772                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
28773                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
28774                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
28775                    | (1 as libc::c_ulonglong) << 20 as libc::c_int) as uint64_t,
28776                acl_categories: 0 as libc::c_int as uint64_t,
28777                key_specs_static: [keySpec {
28778                    notes: 0 as *const libc::c_char,
28779                    flags: 0,
28780                    begin_search_type: KSPEC_BS_INVALID,
28781                    bs: C2RustUnnamed_3 {
28782                        index: C2RustUnnamed_5 { pos: 0 },
28783                    },
28784                    find_keys_type: KSPEC_FK_INVALID,
28785                    fk: C2RustUnnamed_0 {
28786                        range: C2RustUnnamed_2 {
28787                            lastkey: 0,
28788                            keystep: 0,
28789                            limit: 0,
28790                        },
28791                    },
28792                }; 4],
28793                getkeys_proc: None,
28794                subcommands: 0 as *const redisCommand as *mut redisCommand,
28795                args: MODULE_LOADEX_Args.as_ptr() as *mut _,
28796                microseconds: 0,
28797                calls: 0,
28798                rejected_calls: 0,
28799                failed_calls: 0,
28800                id: 0,
28801                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28802                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28803                key_specs: 0 as *const keySpec as *mut keySpec,
28804                legacy_range_key_spec: keySpec {
28805                    notes: 0 as *const libc::c_char,
28806                    flags: 0,
28807                    begin_search_type: KSPEC_BS_INVALID,
28808                    bs: C2RustUnnamed_3 {
28809                        index: C2RustUnnamed_5 { pos: 0 },
28810                    },
28811                    find_keys_type: KSPEC_FK_INVALID,
28812                    fk: C2RustUnnamed_0 {
28813                        range: C2RustUnnamed_2 {
28814                            lastkey: 0,
28815                            keystep: 0,
28816                            limit: 0,
28817                        },
28818                    },
28819                },
28820                num_args: 0,
28821                num_history: 0,
28822                num_tips: 0,
28823                key_specs_num: 0,
28824                key_specs_max: 0,
28825                subcommands_dict: 0 as *const dict as *mut dict,
28826                parent: 0 as *const redisCommand as *mut redisCommand,
28827                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28828            };
28829            init
28830        },
28831        {
28832            let mut init = redisCommand {
28833                declared_name: b"unload\0" as *const u8 as *const libc::c_char,
28834                summary: b"Unload a module\0" as *const u8 as *const libc::c_char,
28835                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
28836                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
28837                doc_flags: 0 as libc::c_int,
28838                replaced_by: 0 as *const libc::c_char,
28839                deprecated_since: 0 as *const libc::c_char,
28840                group: COMMAND_GROUP_SERVER,
28841                history: 0 as *const commandHistory as *mut commandHistory,
28842                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28843                proc_0: Some(moduleCommand as unsafe extern "C" fn(*mut client) -> ()),
28844                arity: 3 as libc::c_int,
28845                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
28846                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
28847                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
28848                    | (1 as libc::c_ulonglong) << 20 as libc::c_int) as uint64_t,
28849                acl_categories: 0 as libc::c_int as uint64_t,
28850                key_specs_static: [keySpec {
28851                    notes: 0 as *const libc::c_char,
28852                    flags: 0,
28853                    begin_search_type: KSPEC_BS_INVALID,
28854                    bs: C2RustUnnamed_3 {
28855                        index: C2RustUnnamed_5 { pos: 0 },
28856                    },
28857                    find_keys_type: KSPEC_FK_INVALID,
28858                    fk: C2RustUnnamed_0 {
28859                        range: C2RustUnnamed_2 {
28860                            lastkey: 0,
28861                            keystep: 0,
28862                            limit: 0,
28863                        },
28864                    },
28865                }; 4],
28866                getkeys_proc: None,
28867                subcommands: 0 as *const redisCommand as *mut redisCommand,
28868                args: MODULE_UNLOAD_Args.as_ptr() as *mut _,
28869                microseconds: 0,
28870                calls: 0,
28871                rejected_calls: 0,
28872                failed_calls: 0,
28873                id: 0,
28874                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28875                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28876                key_specs: 0 as *const keySpec as *mut keySpec,
28877                legacy_range_key_spec: keySpec {
28878                    notes: 0 as *const libc::c_char,
28879                    flags: 0,
28880                    begin_search_type: KSPEC_BS_INVALID,
28881                    bs: C2RustUnnamed_3 {
28882                        index: C2RustUnnamed_5 { pos: 0 },
28883                    },
28884                    find_keys_type: KSPEC_FK_INVALID,
28885                    fk: C2RustUnnamed_0 {
28886                        range: C2RustUnnamed_2 {
28887                            lastkey: 0,
28888                            keystep: 0,
28889                            limit: 0,
28890                        },
28891                    },
28892                },
28893                num_args: 0,
28894                num_history: 0,
28895                num_tips: 0,
28896                key_specs_num: 0,
28897                key_specs_max: 0,
28898                subcommands_dict: 0 as *const dict as *mut dict,
28899                parent: 0 as *const redisCommand as *mut redisCommand,
28900                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28901            };
28902            init
28903        },
28904        {
28905            let mut init = redisCommand {
28906                declared_name: 0 as *const libc::c_char,
28907                summary: 0 as *const libc::c_char,
28908                complexity: 0 as *const libc::c_char,
28909                since: 0 as *const libc::c_char,
28910                doc_flags: 0,
28911                replaced_by: 0 as *const libc::c_char,
28912                deprecated_since: 0 as *const libc::c_char,
28913                group: COMMAND_GROUP_GENERIC,
28914                history: 0 as *const commandHistory as *mut commandHistory,
28915                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
28916                proc_0: None,
28917                arity: 0,
28918                flags: 0,
28919                acl_categories: 0,
28920                key_specs_static: [keySpec {
28921                    notes: 0 as *const libc::c_char,
28922                    flags: 0,
28923                    begin_search_type: KSPEC_BS_INVALID,
28924                    bs: C2RustUnnamed_3 {
28925                        index: C2RustUnnamed_5 { pos: 0 },
28926                    },
28927                    find_keys_type: KSPEC_FK_INVALID,
28928                    fk: C2RustUnnamed_0 {
28929                        range: C2RustUnnamed_2 {
28930                            lastkey: 0,
28931                            keystep: 0,
28932                            limit: 0,
28933                        },
28934                    },
28935                }; 4],
28936                getkeys_proc: None,
28937                subcommands: 0 as *const redisCommand as *mut redisCommand,
28938                args: 0 as *const redisCommandArg as *mut redisCommandArg,
28939                microseconds: 0,
28940                calls: 0,
28941                rejected_calls: 0,
28942                failed_calls: 0,
28943                id: 0,
28944                fullname: 0 as *const libc::c_char as *mut libc::c_char,
28945                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
28946                key_specs: 0 as *const keySpec as *mut keySpec,
28947                legacy_range_key_spec: keySpec {
28948                    notes: 0 as *const libc::c_char,
28949                    flags: 0,
28950                    begin_search_type: KSPEC_BS_INVALID,
28951                    bs: C2RustUnnamed_3 {
28952                        index: C2RustUnnamed_5 { pos: 0 },
28953                    },
28954                    find_keys_type: KSPEC_FK_INVALID,
28955                    fk: C2RustUnnamed_0 {
28956                        range: C2RustUnnamed_2 {
28957                            lastkey: 0,
28958                            keystep: 0,
28959                            limit: 0,
28960                        },
28961                    },
28962                },
28963                num_args: 0,
28964                num_history: 0,
28965                num_tips: 0,
28966                key_specs_num: 0,
28967                key_specs_max: 0,
28968                subcommands_dict: 0 as *const dict as *mut dict,
28969                parent: 0 as *const redisCommand as *mut redisCommand,
28970                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
28971            };
28972            init
28973        },
28974    ]
28975};
28976#[no_mangle]
28977pub static mut PSYNC_Args: [redisCommandArg; 3] = [
28978    {
28979        let mut init = redisCommandArg {
28980            name: b"replicationid\0" as *const u8 as *const libc::c_char,
28981            type_0: ARG_TYPE_STRING,
28982            key_spec_index: -(1 as libc::c_int),
28983            token: 0 as *const libc::c_char,
28984            summary: 0 as *const libc::c_char,
28985            since: 0 as *const libc::c_char,
28986            flags: 0 as libc::c_int,
28987            deprecated_since: 0 as *const libc::c_char,
28988            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
28989            num_args: 0,
28990        };
28991        init
28992    },
28993    {
28994        let mut init = redisCommandArg {
28995            name: b"offset\0" as *const u8 as *const libc::c_char,
28996            type_0: ARG_TYPE_INTEGER,
28997            key_spec_index: -(1 as libc::c_int),
28998            token: 0 as *const libc::c_char,
28999            summary: 0 as *const libc::c_char,
29000            since: 0 as *const libc::c_char,
29001            flags: 0 as libc::c_int,
29002            deprecated_since: 0 as *const libc::c_char,
29003            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29004            num_args: 0,
29005        };
29006        init
29007    },
29008    {
29009        let mut init = redisCommandArg {
29010            name: 0 as *const libc::c_char,
29011            type_0: ARG_TYPE_STRING,
29012            key_spec_index: 0,
29013            token: 0 as *const libc::c_char,
29014            summary: 0 as *const libc::c_char,
29015            since: 0 as *const libc::c_char,
29016            flags: 0,
29017            deprecated_since: 0 as *const libc::c_char,
29018            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29019            num_args: 0,
29020        };
29021        init
29022    },
29023];
29024#[no_mangle]
29025pub static mut REPLICAOF_Args: [redisCommandArg; 3] = [
29026    {
29027        let mut init = redisCommandArg {
29028            name: b"host\0" as *const u8 as *const libc::c_char,
29029            type_0: ARG_TYPE_STRING,
29030            key_spec_index: -(1 as libc::c_int),
29031            token: 0 as *const libc::c_char,
29032            summary: 0 as *const libc::c_char,
29033            since: 0 as *const libc::c_char,
29034            flags: 0 as libc::c_int,
29035            deprecated_since: 0 as *const libc::c_char,
29036            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29037            num_args: 0,
29038        };
29039        init
29040    },
29041    {
29042        let mut init = redisCommandArg {
29043            name: b"port\0" as *const u8 as *const libc::c_char,
29044            type_0: ARG_TYPE_INTEGER,
29045            key_spec_index: -(1 as libc::c_int),
29046            token: 0 as *const libc::c_char,
29047            summary: 0 as *const libc::c_char,
29048            since: 0 as *const libc::c_char,
29049            flags: 0 as libc::c_int,
29050            deprecated_since: 0 as *const libc::c_char,
29051            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29052            num_args: 0,
29053        };
29054        init
29055    },
29056    {
29057        let mut init = redisCommandArg {
29058            name: 0 as *const libc::c_char,
29059            type_0: ARG_TYPE_STRING,
29060            key_spec_index: 0,
29061            token: 0 as *const libc::c_char,
29062            summary: 0 as *const libc::c_char,
29063            since: 0 as *const libc::c_char,
29064            flags: 0,
29065            deprecated_since: 0 as *const libc::c_char,
29066            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29067            num_args: 0,
29068        };
29069        init
29070    },
29071];
29072#[no_mangle]
29073pub static mut RESTORE_ASKING_History: [commandHistory; 4] = [
29074    {
29075        let mut init = commandHistory {
29076            since: b"3.0.0\0" as *const u8 as *const libc::c_char,
29077            changes: b"Added the `REPLACE` modifier.\0" as *const u8
29078                as *const libc::c_char,
29079        };
29080        init
29081    },
29082    {
29083        let mut init = commandHistory {
29084            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
29085            changes: b"Added the `ABSTTL` modifier.\0" as *const u8
29086                as *const libc::c_char,
29087        };
29088        init
29089    },
29090    {
29091        let mut init = commandHistory {
29092            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
29093            changes: b"Added the `IDLETIME` and `FREQ` options.\0" as *const u8
29094                as *const libc::c_char,
29095        };
29096        init
29097    },
29098    {
29099        let mut init = commandHistory {
29100            since: 0 as *const libc::c_char,
29101            changes: 0 as *const libc::c_char,
29102        };
29103        init
29104    },
29105];
29106#[no_mangle]
29107pub static mut RESTORE_ASKING_Args: [redisCommandArg; 8] = [
29108    {
29109        let mut init = redisCommandArg {
29110            name: b"key\0" as *const u8 as *const libc::c_char,
29111            type_0: ARG_TYPE_KEY,
29112            key_spec_index: 0 as libc::c_int,
29113            token: 0 as *const libc::c_char,
29114            summary: 0 as *const libc::c_char,
29115            since: 0 as *const libc::c_char,
29116            flags: 0 as libc::c_int,
29117            deprecated_since: 0 as *const libc::c_char,
29118            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29119            num_args: 0,
29120        };
29121        init
29122    },
29123    {
29124        let mut init = redisCommandArg {
29125            name: b"ttl\0" as *const u8 as *const libc::c_char,
29126            type_0: ARG_TYPE_INTEGER,
29127            key_spec_index: -(1 as libc::c_int),
29128            token: 0 as *const libc::c_char,
29129            summary: 0 as *const libc::c_char,
29130            since: 0 as *const libc::c_char,
29131            flags: 0 as libc::c_int,
29132            deprecated_since: 0 as *const libc::c_char,
29133            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29134            num_args: 0,
29135        };
29136        init
29137    },
29138    {
29139        let mut init = redisCommandArg {
29140            name: b"serialized-value\0" as *const u8 as *const libc::c_char,
29141            type_0: ARG_TYPE_STRING,
29142            key_spec_index: -(1 as libc::c_int),
29143            token: 0 as *const libc::c_char,
29144            summary: 0 as *const libc::c_char,
29145            since: 0 as *const libc::c_char,
29146            flags: 0 as libc::c_int,
29147            deprecated_since: 0 as *const libc::c_char,
29148            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29149            num_args: 0,
29150        };
29151        init
29152    },
29153    {
29154        let mut init = redisCommandArg {
29155            name: b"replace\0" as *const u8 as *const libc::c_char,
29156            type_0: ARG_TYPE_PURE_TOKEN,
29157            key_spec_index: -(1 as libc::c_int),
29158            token: b"REPLACE\0" as *const u8 as *const libc::c_char,
29159            summary: 0 as *const libc::c_char,
29160            since: b"3.0.0\0" as *const u8 as *const libc::c_char,
29161            flags: (1 as libc::c_int) << 0 as libc::c_int,
29162            deprecated_since: 0 as *const libc::c_char,
29163            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29164            num_args: 0,
29165        };
29166        init
29167    },
29168    {
29169        let mut init = redisCommandArg {
29170            name: b"absttl\0" as *const u8 as *const libc::c_char,
29171            type_0: ARG_TYPE_PURE_TOKEN,
29172            key_spec_index: -(1 as libc::c_int),
29173            token: b"ABSTTL\0" as *const u8 as *const libc::c_char,
29174            summary: 0 as *const libc::c_char,
29175            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
29176            flags: (1 as libc::c_int) << 0 as libc::c_int,
29177            deprecated_since: 0 as *const libc::c_char,
29178            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29179            num_args: 0,
29180        };
29181        init
29182    },
29183    {
29184        let mut init = redisCommandArg {
29185            name: b"seconds\0" as *const u8 as *const libc::c_char,
29186            type_0: ARG_TYPE_INTEGER,
29187            key_spec_index: -(1 as libc::c_int),
29188            token: b"IDLETIME\0" as *const u8 as *const libc::c_char,
29189            summary: 0 as *const libc::c_char,
29190            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
29191            flags: (1 as libc::c_int) << 0 as libc::c_int,
29192            deprecated_since: 0 as *const libc::c_char,
29193            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29194            num_args: 0,
29195        };
29196        init
29197    },
29198    {
29199        let mut init = redisCommandArg {
29200            name: b"frequency\0" as *const u8 as *const libc::c_char,
29201            type_0: ARG_TYPE_INTEGER,
29202            key_spec_index: -(1 as libc::c_int),
29203            token: b"FREQ\0" as *const u8 as *const libc::c_char,
29204            summary: 0 as *const libc::c_char,
29205            since: b"5.0.0\0" as *const u8 as *const libc::c_char,
29206            flags: (1 as libc::c_int) << 0 as libc::c_int,
29207            deprecated_since: 0 as *const libc::c_char,
29208            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29209            num_args: 0,
29210        };
29211        init
29212    },
29213    {
29214        let mut init = redisCommandArg {
29215            name: 0 as *const libc::c_char,
29216            type_0: ARG_TYPE_STRING,
29217            key_spec_index: 0,
29218            token: 0 as *const libc::c_char,
29219            summary: 0 as *const libc::c_char,
29220            since: 0 as *const libc::c_char,
29221            flags: 0,
29222            deprecated_since: 0 as *const libc::c_char,
29223            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29224            num_args: 0,
29225        };
29226        init
29227    },
29228];
29229#[no_mangle]
29230pub static mut SHUTDOWN_History: [commandHistory; 2] = [
29231    {
29232        let mut init = commandHistory {
29233            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
29234            changes: b"Added the `NOW`, `FORCE` and `ABORT` modifiers.\0" as *const u8
29235                as *const libc::c_char,
29236        };
29237        init
29238    },
29239    {
29240        let mut init = commandHistory {
29241            since: 0 as *const libc::c_char,
29242            changes: 0 as *const libc::c_char,
29243        };
29244        init
29245    },
29246];
29247#[no_mangle]
29248pub static mut SHUTDOWN_nosave_save_Subargs: [redisCommandArg; 3] = [
29249    {
29250        let mut init = redisCommandArg {
29251            name: b"nosave\0" as *const u8 as *const libc::c_char,
29252            type_0: ARG_TYPE_PURE_TOKEN,
29253            key_spec_index: -(1 as libc::c_int),
29254            token: b"NOSAVE\0" as *const u8 as *const libc::c_char,
29255            summary: 0 as *const libc::c_char,
29256            since: 0 as *const libc::c_char,
29257            flags: 0 as libc::c_int,
29258            deprecated_since: 0 as *const libc::c_char,
29259            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29260            num_args: 0,
29261        };
29262        init
29263    },
29264    {
29265        let mut init = redisCommandArg {
29266            name: b"save\0" as *const u8 as *const libc::c_char,
29267            type_0: ARG_TYPE_PURE_TOKEN,
29268            key_spec_index: -(1 as libc::c_int),
29269            token: b"SAVE\0" as *const u8 as *const libc::c_char,
29270            summary: 0 as *const libc::c_char,
29271            since: 0 as *const libc::c_char,
29272            flags: 0 as libc::c_int,
29273            deprecated_since: 0 as *const libc::c_char,
29274            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29275            num_args: 0,
29276        };
29277        init
29278    },
29279    {
29280        let mut init = redisCommandArg {
29281            name: 0 as *const libc::c_char,
29282            type_0: ARG_TYPE_STRING,
29283            key_spec_index: 0,
29284            token: 0 as *const libc::c_char,
29285            summary: 0 as *const libc::c_char,
29286            since: 0 as *const libc::c_char,
29287            flags: 0,
29288            deprecated_since: 0 as *const libc::c_char,
29289            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29290            num_args: 0,
29291        };
29292        init
29293    },
29294];
29295#[no_mangle]
29296pub static mut SHUTDOWN_Args: [redisCommandArg; 5] = unsafe {
29297    [
29298        {
29299            let mut init = redisCommandArg {
29300                name: b"nosave_save\0" as *const u8 as *const libc::c_char,
29301                type_0: ARG_TYPE_ONEOF,
29302                key_spec_index: -(1 as libc::c_int),
29303                token: 0 as *const libc::c_char,
29304                summary: 0 as *const libc::c_char,
29305                since: 0 as *const libc::c_char,
29306                flags: (1 as libc::c_int) << 0 as libc::c_int,
29307                deprecated_since: 0 as *const libc::c_char,
29308                subargs: SHUTDOWN_nosave_save_Subargs.as_ptr() as *mut _,
29309                num_args: 0,
29310            };
29311            init
29312        },
29313        {
29314            let mut init = redisCommandArg {
29315                name: b"now\0" as *const u8 as *const libc::c_char,
29316                type_0: ARG_TYPE_PURE_TOKEN,
29317                key_spec_index: -(1 as libc::c_int),
29318                token: b"NOW\0" as *const u8 as *const libc::c_char,
29319                summary: 0 as *const libc::c_char,
29320                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
29321                flags: (1 as libc::c_int) << 0 as libc::c_int,
29322                deprecated_since: 0 as *const libc::c_char,
29323                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29324                num_args: 0,
29325            };
29326            init
29327        },
29328        {
29329            let mut init = redisCommandArg {
29330                name: b"force\0" as *const u8 as *const libc::c_char,
29331                type_0: ARG_TYPE_PURE_TOKEN,
29332                key_spec_index: -(1 as libc::c_int),
29333                token: b"FORCE\0" as *const u8 as *const libc::c_char,
29334                summary: 0 as *const libc::c_char,
29335                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
29336                flags: (1 as libc::c_int) << 0 as libc::c_int,
29337                deprecated_since: 0 as *const libc::c_char,
29338                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29339                num_args: 0,
29340            };
29341            init
29342        },
29343        {
29344            let mut init = redisCommandArg {
29345                name: b"abort\0" as *const u8 as *const libc::c_char,
29346                type_0: ARG_TYPE_PURE_TOKEN,
29347                key_spec_index: -(1 as libc::c_int),
29348                token: b"ABORT\0" as *const u8 as *const libc::c_char,
29349                summary: 0 as *const libc::c_char,
29350                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
29351                flags: (1 as libc::c_int) << 0 as libc::c_int,
29352                deprecated_since: 0 as *const libc::c_char,
29353                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29354                num_args: 0,
29355            };
29356            init
29357        },
29358        {
29359            let mut init = redisCommandArg {
29360                name: 0 as *const libc::c_char,
29361                type_0: ARG_TYPE_STRING,
29362                key_spec_index: 0,
29363                token: 0 as *const libc::c_char,
29364                summary: 0 as *const libc::c_char,
29365                since: 0 as *const libc::c_char,
29366                flags: 0,
29367                deprecated_since: 0 as *const libc::c_char,
29368                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29369                num_args: 0,
29370            };
29371            init
29372        },
29373    ]
29374};
29375#[no_mangle]
29376pub static mut SLAVEOF_Args: [redisCommandArg; 3] = [
29377    {
29378        let mut init = redisCommandArg {
29379            name: b"host\0" as *const u8 as *const libc::c_char,
29380            type_0: ARG_TYPE_STRING,
29381            key_spec_index: -(1 as libc::c_int),
29382            token: 0 as *const libc::c_char,
29383            summary: 0 as *const libc::c_char,
29384            since: 0 as *const libc::c_char,
29385            flags: 0 as libc::c_int,
29386            deprecated_since: 0 as *const libc::c_char,
29387            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29388            num_args: 0,
29389        };
29390        init
29391    },
29392    {
29393        let mut init = redisCommandArg {
29394            name: b"port\0" as *const u8 as *const libc::c_char,
29395            type_0: ARG_TYPE_INTEGER,
29396            key_spec_index: -(1 as libc::c_int),
29397            token: 0 as *const libc::c_char,
29398            summary: 0 as *const libc::c_char,
29399            since: 0 as *const libc::c_char,
29400            flags: 0 as libc::c_int,
29401            deprecated_since: 0 as *const libc::c_char,
29402            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29403            num_args: 0,
29404        };
29405        init
29406    },
29407    {
29408        let mut init = redisCommandArg {
29409            name: 0 as *const libc::c_char,
29410            type_0: ARG_TYPE_STRING,
29411            key_spec_index: 0,
29412            token: 0 as *const libc::c_char,
29413            summary: 0 as *const libc::c_char,
29414            since: 0 as *const libc::c_char,
29415            flags: 0,
29416            deprecated_since: 0 as *const libc::c_char,
29417            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29418            num_args: 0,
29419        };
29420        init
29421    },
29422];
29423#[no_mangle]
29424pub static mut SLOWLOG_GET_History: [commandHistory; 2] = [
29425    {
29426        let mut init = commandHistory {
29427            since: b"4.0.0\0" as *const u8 as *const libc::c_char,
29428            changes: b"Added client IP address, port and name to the reply.\0"
29429                as *const u8 as *const libc::c_char,
29430        };
29431        init
29432    },
29433    {
29434        let mut init = commandHistory {
29435            since: 0 as *const libc::c_char,
29436            changes: 0 as *const libc::c_char,
29437        };
29438        init
29439    },
29440];
29441#[no_mangle]
29442pub static mut SLOWLOG_GET_tips: [*const libc::c_char; 3] = [
29443    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
29444    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
29445    0 as *const libc::c_char,
29446];
29447#[no_mangle]
29448pub static mut SLOWLOG_GET_Args: [redisCommandArg; 2] = [
29449    {
29450        let mut init = redisCommandArg {
29451            name: b"count\0" as *const u8 as *const libc::c_char,
29452            type_0: ARG_TYPE_INTEGER,
29453            key_spec_index: -(1 as libc::c_int),
29454            token: 0 as *const libc::c_char,
29455            summary: 0 as *const libc::c_char,
29456            since: 0 as *const libc::c_char,
29457            flags: (1 as libc::c_int) << 0 as libc::c_int,
29458            deprecated_since: 0 as *const libc::c_char,
29459            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29460            num_args: 0,
29461        };
29462        init
29463    },
29464    {
29465        let mut init = redisCommandArg {
29466            name: 0 as *const libc::c_char,
29467            type_0: ARG_TYPE_STRING,
29468            key_spec_index: 0,
29469            token: 0 as *const libc::c_char,
29470            summary: 0 as *const libc::c_char,
29471            since: 0 as *const libc::c_char,
29472            flags: 0,
29473            deprecated_since: 0 as *const libc::c_char,
29474            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29475            num_args: 0,
29476        };
29477        init
29478    },
29479];
29480#[no_mangle]
29481pub static mut SLOWLOG_LEN_tips: [*const libc::c_char; 4] = [
29482    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
29483    b"response_policy:agg_sum\0" as *const u8 as *const libc::c_char,
29484    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
29485    0 as *const libc::c_char,
29486];
29487#[no_mangle]
29488pub static mut SLOWLOG_RESET_tips: [*const libc::c_char; 3] = [
29489    b"request_policy:all_nodes\0" as *const u8 as *const libc::c_char,
29490    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
29491    0 as *const libc::c_char,
29492];
29493#[no_mangle]
29494pub static mut SLOWLOG_Subcommands: [redisCommand; 5] = unsafe {
29495    [
29496        {
29497            let mut init = redisCommand {
29498                declared_name: b"get\0" as *const u8 as *const libc::c_char,
29499                summary: b"Get the slow log's entries\0" as *const u8
29500                    as *const libc::c_char,
29501                complexity: b"O(N) where N is the number of entries returned\0"
29502                    as *const u8 as *const libc::c_char,
29503                since: b"2.2.12\0" as *const u8 as *const libc::c_char,
29504                doc_flags: 0 as libc::c_int,
29505                replaced_by: 0 as *const libc::c_char,
29506                deprecated_since: 0 as *const libc::c_char,
29507                group: COMMAND_GROUP_SERVER,
29508                history: SLOWLOG_GET_History.as_ptr() as *mut _,
29509                tips: SLOWLOG_GET_tips.as_ptr() as *mut _,
29510                proc_0: Some(slowlogCommand as unsafe extern "C" fn(*mut client) -> ()),
29511                arity: -(2 as libc::c_int),
29512                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
29513                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
29514                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
29515                acl_categories: 0 as libc::c_int as uint64_t,
29516                key_specs_static: [keySpec {
29517                    notes: 0 as *const libc::c_char,
29518                    flags: 0,
29519                    begin_search_type: KSPEC_BS_INVALID,
29520                    bs: C2RustUnnamed_3 {
29521                        index: C2RustUnnamed_5 { pos: 0 },
29522                    },
29523                    find_keys_type: KSPEC_FK_INVALID,
29524                    fk: C2RustUnnamed_0 {
29525                        range: C2RustUnnamed_2 {
29526                            lastkey: 0,
29527                            keystep: 0,
29528                            limit: 0,
29529                        },
29530                    },
29531                }; 4],
29532                getkeys_proc: None,
29533                subcommands: 0 as *const redisCommand as *mut redisCommand,
29534                args: SLOWLOG_GET_Args.as_ptr() as *mut _,
29535                microseconds: 0,
29536                calls: 0,
29537                rejected_calls: 0,
29538                failed_calls: 0,
29539                id: 0,
29540                fullname: 0 as *const libc::c_char as *mut libc::c_char,
29541                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
29542                key_specs: 0 as *const keySpec as *mut keySpec,
29543                legacy_range_key_spec: keySpec {
29544                    notes: 0 as *const libc::c_char,
29545                    flags: 0,
29546                    begin_search_type: KSPEC_BS_INVALID,
29547                    bs: C2RustUnnamed_3 {
29548                        index: C2RustUnnamed_5 { pos: 0 },
29549                    },
29550                    find_keys_type: KSPEC_FK_INVALID,
29551                    fk: C2RustUnnamed_0 {
29552                        range: C2RustUnnamed_2 {
29553                            lastkey: 0,
29554                            keystep: 0,
29555                            limit: 0,
29556                        },
29557                    },
29558                },
29559                num_args: 0,
29560                num_history: 0,
29561                num_tips: 0,
29562                key_specs_num: 0,
29563                key_specs_max: 0,
29564                subcommands_dict: 0 as *const dict as *mut dict,
29565                parent: 0 as *const redisCommand as *mut redisCommand,
29566                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
29567            };
29568            init
29569        },
29570        {
29571            let mut init = redisCommand {
29572                declared_name: b"help\0" as *const u8 as *const libc::c_char,
29573                summary: b"Show helpful text about the different subcommands\0"
29574                    as *const u8 as *const libc::c_char,
29575                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
29576                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
29577                doc_flags: 0 as libc::c_int,
29578                replaced_by: 0 as *const libc::c_char,
29579                deprecated_since: 0 as *const libc::c_char,
29580                group: COMMAND_GROUP_SERVER,
29581                history: 0 as *const commandHistory as *mut commandHistory,
29582                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
29583                proc_0: Some(slowlogCommand as unsafe extern "C" fn(*mut client) -> ()),
29584                arity: 2 as libc::c_int,
29585                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
29586                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
29587                acl_categories: 0 as libc::c_int as uint64_t,
29588                key_specs_static: [keySpec {
29589                    notes: 0 as *const libc::c_char,
29590                    flags: 0,
29591                    begin_search_type: KSPEC_BS_INVALID,
29592                    bs: C2RustUnnamed_3 {
29593                        index: C2RustUnnamed_5 { pos: 0 },
29594                    },
29595                    find_keys_type: KSPEC_FK_INVALID,
29596                    fk: C2RustUnnamed_0 {
29597                        range: C2RustUnnamed_2 {
29598                            lastkey: 0,
29599                            keystep: 0,
29600                            limit: 0,
29601                        },
29602                    },
29603                }; 4],
29604                getkeys_proc: None,
29605                subcommands: 0 as *const redisCommand as *mut redisCommand,
29606                args: 0 as *const redisCommandArg as *mut redisCommandArg,
29607                microseconds: 0,
29608                calls: 0,
29609                rejected_calls: 0,
29610                failed_calls: 0,
29611                id: 0,
29612                fullname: 0 as *const libc::c_char as *mut libc::c_char,
29613                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
29614                key_specs: 0 as *const keySpec as *mut keySpec,
29615                legacy_range_key_spec: keySpec {
29616                    notes: 0 as *const libc::c_char,
29617                    flags: 0,
29618                    begin_search_type: KSPEC_BS_INVALID,
29619                    bs: C2RustUnnamed_3 {
29620                        index: C2RustUnnamed_5 { pos: 0 },
29621                    },
29622                    find_keys_type: KSPEC_FK_INVALID,
29623                    fk: C2RustUnnamed_0 {
29624                        range: C2RustUnnamed_2 {
29625                            lastkey: 0,
29626                            keystep: 0,
29627                            limit: 0,
29628                        },
29629                    },
29630                },
29631                num_args: 0,
29632                num_history: 0,
29633                num_tips: 0,
29634                key_specs_num: 0,
29635                key_specs_max: 0,
29636                subcommands_dict: 0 as *const dict as *mut dict,
29637                parent: 0 as *const redisCommand as *mut redisCommand,
29638                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
29639            };
29640            init
29641        },
29642        {
29643            let mut init = redisCommand {
29644                declared_name: b"len\0" as *const u8 as *const libc::c_char,
29645                summary: b"Get the slow log's length\0" as *const u8
29646                    as *const libc::c_char,
29647                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
29648                since: b"2.2.12\0" as *const u8 as *const libc::c_char,
29649                doc_flags: 0 as libc::c_int,
29650                replaced_by: 0 as *const libc::c_char,
29651                deprecated_since: 0 as *const libc::c_char,
29652                group: COMMAND_GROUP_SERVER,
29653                history: 0 as *const commandHistory as *mut commandHistory,
29654                tips: SLOWLOG_LEN_tips.as_ptr() as *mut _,
29655                proc_0: Some(slowlogCommand as unsafe extern "C" fn(*mut client) -> ()),
29656                arity: 2 as libc::c_int,
29657                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
29658                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
29659                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
29660                acl_categories: 0 as libc::c_int as uint64_t,
29661                key_specs_static: [keySpec {
29662                    notes: 0 as *const libc::c_char,
29663                    flags: 0,
29664                    begin_search_type: KSPEC_BS_INVALID,
29665                    bs: C2RustUnnamed_3 {
29666                        index: C2RustUnnamed_5 { pos: 0 },
29667                    },
29668                    find_keys_type: KSPEC_FK_INVALID,
29669                    fk: C2RustUnnamed_0 {
29670                        range: C2RustUnnamed_2 {
29671                            lastkey: 0,
29672                            keystep: 0,
29673                            limit: 0,
29674                        },
29675                    },
29676                }; 4],
29677                getkeys_proc: None,
29678                subcommands: 0 as *const redisCommand as *mut redisCommand,
29679                args: 0 as *const redisCommandArg as *mut redisCommandArg,
29680                microseconds: 0,
29681                calls: 0,
29682                rejected_calls: 0,
29683                failed_calls: 0,
29684                id: 0,
29685                fullname: 0 as *const libc::c_char as *mut libc::c_char,
29686                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
29687                key_specs: 0 as *const keySpec as *mut keySpec,
29688                legacy_range_key_spec: keySpec {
29689                    notes: 0 as *const libc::c_char,
29690                    flags: 0,
29691                    begin_search_type: KSPEC_BS_INVALID,
29692                    bs: C2RustUnnamed_3 {
29693                        index: C2RustUnnamed_5 { pos: 0 },
29694                    },
29695                    find_keys_type: KSPEC_FK_INVALID,
29696                    fk: C2RustUnnamed_0 {
29697                        range: C2RustUnnamed_2 {
29698                            lastkey: 0,
29699                            keystep: 0,
29700                            limit: 0,
29701                        },
29702                    },
29703                },
29704                num_args: 0,
29705                num_history: 0,
29706                num_tips: 0,
29707                key_specs_num: 0,
29708                key_specs_max: 0,
29709                subcommands_dict: 0 as *const dict as *mut dict,
29710                parent: 0 as *const redisCommand as *mut redisCommand,
29711                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
29712            };
29713            init
29714        },
29715        {
29716            let mut init = redisCommand {
29717                declared_name: b"reset\0" as *const u8 as *const libc::c_char,
29718                summary: b"Clear all entries from the slow log\0" as *const u8
29719                    as *const libc::c_char,
29720                complexity: b"O(N) where N is the number of entries in the slowlog\0"
29721                    as *const u8 as *const libc::c_char,
29722                since: b"2.2.12\0" as *const u8 as *const libc::c_char,
29723                doc_flags: 0 as libc::c_int,
29724                replaced_by: 0 as *const libc::c_char,
29725                deprecated_since: 0 as *const libc::c_char,
29726                group: COMMAND_GROUP_SERVER,
29727                history: 0 as *const commandHistory as *mut commandHistory,
29728                tips: SLOWLOG_RESET_tips.as_ptr() as *mut _,
29729                proc_0: Some(slowlogCommand as unsafe extern "C" fn(*mut client) -> ()),
29730                arity: 2 as libc::c_int,
29731                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
29732                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
29733                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
29734                acl_categories: 0 as libc::c_int as uint64_t,
29735                key_specs_static: [keySpec {
29736                    notes: 0 as *const libc::c_char,
29737                    flags: 0,
29738                    begin_search_type: KSPEC_BS_INVALID,
29739                    bs: C2RustUnnamed_3 {
29740                        index: C2RustUnnamed_5 { pos: 0 },
29741                    },
29742                    find_keys_type: KSPEC_FK_INVALID,
29743                    fk: C2RustUnnamed_0 {
29744                        range: C2RustUnnamed_2 {
29745                            lastkey: 0,
29746                            keystep: 0,
29747                            limit: 0,
29748                        },
29749                    },
29750                }; 4],
29751                getkeys_proc: None,
29752                subcommands: 0 as *const redisCommand as *mut redisCommand,
29753                args: 0 as *const redisCommandArg as *mut redisCommandArg,
29754                microseconds: 0,
29755                calls: 0,
29756                rejected_calls: 0,
29757                failed_calls: 0,
29758                id: 0,
29759                fullname: 0 as *const libc::c_char as *mut libc::c_char,
29760                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
29761                key_specs: 0 as *const keySpec as *mut keySpec,
29762                legacy_range_key_spec: keySpec {
29763                    notes: 0 as *const libc::c_char,
29764                    flags: 0,
29765                    begin_search_type: KSPEC_BS_INVALID,
29766                    bs: C2RustUnnamed_3 {
29767                        index: C2RustUnnamed_5 { pos: 0 },
29768                    },
29769                    find_keys_type: KSPEC_FK_INVALID,
29770                    fk: C2RustUnnamed_0 {
29771                        range: C2RustUnnamed_2 {
29772                            lastkey: 0,
29773                            keystep: 0,
29774                            limit: 0,
29775                        },
29776                    },
29777                },
29778                num_args: 0,
29779                num_history: 0,
29780                num_tips: 0,
29781                key_specs_num: 0,
29782                key_specs_max: 0,
29783                subcommands_dict: 0 as *const dict as *mut dict,
29784                parent: 0 as *const redisCommand as *mut redisCommand,
29785                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
29786            };
29787            init
29788        },
29789        {
29790            let mut init = redisCommand {
29791                declared_name: 0 as *const libc::c_char,
29792                summary: 0 as *const libc::c_char,
29793                complexity: 0 as *const libc::c_char,
29794                since: 0 as *const libc::c_char,
29795                doc_flags: 0,
29796                replaced_by: 0 as *const libc::c_char,
29797                deprecated_since: 0 as *const libc::c_char,
29798                group: COMMAND_GROUP_GENERIC,
29799                history: 0 as *const commandHistory as *mut commandHistory,
29800                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
29801                proc_0: None,
29802                arity: 0,
29803                flags: 0,
29804                acl_categories: 0,
29805                key_specs_static: [keySpec {
29806                    notes: 0 as *const libc::c_char,
29807                    flags: 0,
29808                    begin_search_type: KSPEC_BS_INVALID,
29809                    bs: C2RustUnnamed_3 {
29810                        index: C2RustUnnamed_5 { pos: 0 },
29811                    },
29812                    find_keys_type: KSPEC_FK_INVALID,
29813                    fk: C2RustUnnamed_0 {
29814                        range: C2RustUnnamed_2 {
29815                            lastkey: 0,
29816                            keystep: 0,
29817                            limit: 0,
29818                        },
29819                    },
29820                }; 4],
29821                getkeys_proc: None,
29822                subcommands: 0 as *const redisCommand as *mut redisCommand,
29823                args: 0 as *const redisCommandArg as *mut redisCommandArg,
29824                microseconds: 0,
29825                calls: 0,
29826                rejected_calls: 0,
29827                failed_calls: 0,
29828                id: 0,
29829                fullname: 0 as *const libc::c_char as *mut libc::c_char,
29830                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
29831                key_specs: 0 as *const keySpec as *mut keySpec,
29832                legacy_range_key_spec: keySpec {
29833                    notes: 0 as *const libc::c_char,
29834                    flags: 0,
29835                    begin_search_type: KSPEC_BS_INVALID,
29836                    bs: C2RustUnnamed_3 {
29837                        index: C2RustUnnamed_5 { pos: 0 },
29838                    },
29839                    find_keys_type: KSPEC_FK_INVALID,
29840                    fk: C2RustUnnamed_0 {
29841                        range: C2RustUnnamed_2 {
29842                            lastkey: 0,
29843                            keystep: 0,
29844                            limit: 0,
29845                        },
29846                    },
29847                },
29848                num_args: 0,
29849                num_history: 0,
29850                num_tips: 0,
29851                key_specs_num: 0,
29852                key_specs_max: 0,
29853                subcommands_dict: 0 as *const dict as *mut dict,
29854                parent: 0 as *const redisCommand as *mut redisCommand,
29855                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
29856            };
29857            init
29858        },
29859    ]
29860};
29861#[no_mangle]
29862pub static mut SWAPDB_Args: [redisCommandArg; 3] = [
29863    {
29864        let mut init = redisCommandArg {
29865            name: b"index1\0" as *const u8 as *const libc::c_char,
29866            type_0: ARG_TYPE_INTEGER,
29867            key_spec_index: -(1 as libc::c_int),
29868            token: 0 as *const libc::c_char,
29869            summary: 0 as *const libc::c_char,
29870            since: 0 as *const libc::c_char,
29871            flags: 0 as libc::c_int,
29872            deprecated_since: 0 as *const libc::c_char,
29873            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29874            num_args: 0,
29875        };
29876        init
29877    },
29878    {
29879        let mut init = redisCommandArg {
29880            name: b"index2\0" as *const u8 as *const libc::c_char,
29881            type_0: ARG_TYPE_INTEGER,
29882            key_spec_index: -(1 as libc::c_int),
29883            token: 0 as *const libc::c_char,
29884            summary: 0 as *const libc::c_char,
29885            since: 0 as *const libc::c_char,
29886            flags: 0 as libc::c_int,
29887            deprecated_since: 0 as *const libc::c_char,
29888            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29889            num_args: 0,
29890        };
29891        init
29892    },
29893    {
29894        let mut init = redisCommandArg {
29895            name: 0 as *const libc::c_char,
29896            type_0: ARG_TYPE_STRING,
29897            key_spec_index: 0,
29898            token: 0 as *const libc::c_char,
29899            summary: 0 as *const libc::c_char,
29900            since: 0 as *const libc::c_char,
29901            flags: 0,
29902            deprecated_since: 0 as *const libc::c_char,
29903            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29904            num_args: 0,
29905        };
29906        init
29907    },
29908];
29909#[no_mangle]
29910pub static mut TIME_tips: [*const libc::c_char; 2] = [
29911    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
29912    0 as *const libc::c_char,
29913];
29914#[no_mangle]
29915pub static mut SADD_History: [commandHistory; 2] = [
29916    {
29917        let mut init = commandHistory {
29918            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
29919            changes: b"Accepts multiple `member` arguments.\0" as *const u8
29920                as *const libc::c_char,
29921        };
29922        init
29923    },
29924    {
29925        let mut init = commandHistory {
29926            since: 0 as *const libc::c_char,
29927            changes: 0 as *const libc::c_char,
29928        };
29929        init
29930    },
29931];
29932#[no_mangle]
29933pub static mut SADD_Args: [redisCommandArg; 3] = [
29934    {
29935        let mut init = redisCommandArg {
29936            name: b"key\0" as *const u8 as *const libc::c_char,
29937            type_0: ARG_TYPE_KEY,
29938            key_spec_index: 0 as libc::c_int,
29939            token: 0 as *const libc::c_char,
29940            summary: 0 as *const libc::c_char,
29941            since: 0 as *const libc::c_char,
29942            flags: 0 as libc::c_int,
29943            deprecated_since: 0 as *const libc::c_char,
29944            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29945            num_args: 0,
29946        };
29947        init
29948    },
29949    {
29950        let mut init = redisCommandArg {
29951            name: b"member\0" as *const u8 as *const libc::c_char,
29952            type_0: ARG_TYPE_STRING,
29953            key_spec_index: -(1 as libc::c_int),
29954            token: 0 as *const libc::c_char,
29955            summary: 0 as *const libc::c_char,
29956            since: 0 as *const libc::c_char,
29957            flags: (1 as libc::c_int) << 1 as libc::c_int,
29958            deprecated_since: 0 as *const libc::c_char,
29959            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29960            num_args: 0,
29961        };
29962        init
29963    },
29964    {
29965        let mut init = redisCommandArg {
29966            name: 0 as *const libc::c_char,
29967            type_0: ARG_TYPE_STRING,
29968            key_spec_index: 0,
29969            token: 0 as *const libc::c_char,
29970            summary: 0 as *const libc::c_char,
29971            since: 0 as *const libc::c_char,
29972            flags: 0,
29973            deprecated_since: 0 as *const libc::c_char,
29974            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29975            num_args: 0,
29976        };
29977        init
29978    },
29979];
29980#[no_mangle]
29981pub static mut SCARD_Args: [redisCommandArg; 2] = [
29982    {
29983        let mut init = redisCommandArg {
29984            name: b"key\0" as *const u8 as *const libc::c_char,
29985            type_0: ARG_TYPE_KEY,
29986            key_spec_index: 0 as libc::c_int,
29987            token: 0 as *const libc::c_char,
29988            summary: 0 as *const libc::c_char,
29989            since: 0 as *const libc::c_char,
29990            flags: 0 as libc::c_int,
29991            deprecated_since: 0 as *const libc::c_char,
29992            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
29993            num_args: 0,
29994        };
29995        init
29996    },
29997    {
29998        let mut init = redisCommandArg {
29999            name: 0 as *const libc::c_char,
30000            type_0: ARG_TYPE_STRING,
30001            key_spec_index: 0,
30002            token: 0 as *const libc::c_char,
30003            summary: 0 as *const libc::c_char,
30004            since: 0 as *const libc::c_char,
30005            flags: 0,
30006            deprecated_since: 0 as *const libc::c_char,
30007            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30008            num_args: 0,
30009        };
30010        init
30011    },
30012];
30013#[no_mangle]
30014pub static mut SDIFF_tips: [*const libc::c_char; 2] = [
30015    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
30016    0 as *const libc::c_char,
30017];
30018#[no_mangle]
30019pub static mut SDIFF_Args: [redisCommandArg; 2] = [
30020    {
30021        let mut init = redisCommandArg {
30022            name: b"key\0" as *const u8 as *const libc::c_char,
30023            type_0: ARG_TYPE_KEY,
30024            key_spec_index: 0 as libc::c_int,
30025            token: 0 as *const libc::c_char,
30026            summary: 0 as *const libc::c_char,
30027            since: 0 as *const libc::c_char,
30028            flags: (1 as libc::c_int) << 1 as libc::c_int,
30029            deprecated_since: 0 as *const libc::c_char,
30030            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30031            num_args: 0,
30032        };
30033        init
30034    },
30035    {
30036        let mut init = redisCommandArg {
30037            name: 0 as *const libc::c_char,
30038            type_0: ARG_TYPE_STRING,
30039            key_spec_index: 0,
30040            token: 0 as *const libc::c_char,
30041            summary: 0 as *const libc::c_char,
30042            since: 0 as *const libc::c_char,
30043            flags: 0,
30044            deprecated_since: 0 as *const libc::c_char,
30045            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30046            num_args: 0,
30047        };
30048        init
30049    },
30050];
30051#[no_mangle]
30052pub static mut SDIFFSTORE_Args: [redisCommandArg; 3] = [
30053    {
30054        let mut init = redisCommandArg {
30055            name: b"destination\0" as *const u8 as *const libc::c_char,
30056            type_0: ARG_TYPE_KEY,
30057            key_spec_index: 0 as libc::c_int,
30058            token: 0 as *const libc::c_char,
30059            summary: 0 as *const libc::c_char,
30060            since: 0 as *const libc::c_char,
30061            flags: 0 as libc::c_int,
30062            deprecated_since: 0 as *const libc::c_char,
30063            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30064            num_args: 0,
30065        };
30066        init
30067    },
30068    {
30069        let mut init = redisCommandArg {
30070            name: b"key\0" as *const u8 as *const libc::c_char,
30071            type_0: ARG_TYPE_KEY,
30072            key_spec_index: 1 as libc::c_int,
30073            token: 0 as *const libc::c_char,
30074            summary: 0 as *const libc::c_char,
30075            since: 0 as *const libc::c_char,
30076            flags: (1 as libc::c_int) << 1 as libc::c_int,
30077            deprecated_since: 0 as *const libc::c_char,
30078            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30079            num_args: 0,
30080        };
30081        init
30082    },
30083    {
30084        let mut init = redisCommandArg {
30085            name: 0 as *const libc::c_char,
30086            type_0: ARG_TYPE_STRING,
30087            key_spec_index: 0,
30088            token: 0 as *const libc::c_char,
30089            summary: 0 as *const libc::c_char,
30090            since: 0 as *const libc::c_char,
30091            flags: 0,
30092            deprecated_since: 0 as *const libc::c_char,
30093            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30094            num_args: 0,
30095        };
30096        init
30097    },
30098];
30099#[no_mangle]
30100pub static mut SINTER_tips: [*const libc::c_char; 2] = [
30101    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
30102    0 as *const libc::c_char,
30103];
30104#[no_mangle]
30105pub static mut SINTER_Args: [redisCommandArg; 2] = [
30106    {
30107        let mut init = redisCommandArg {
30108            name: b"key\0" as *const u8 as *const libc::c_char,
30109            type_0: ARG_TYPE_KEY,
30110            key_spec_index: 0 as libc::c_int,
30111            token: 0 as *const libc::c_char,
30112            summary: 0 as *const libc::c_char,
30113            since: 0 as *const libc::c_char,
30114            flags: (1 as libc::c_int) << 1 as libc::c_int,
30115            deprecated_since: 0 as *const libc::c_char,
30116            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30117            num_args: 0,
30118        };
30119        init
30120    },
30121    {
30122        let mut init = redisCommandArg {
30123            name: 0 as *const libc::c_char,
30124            type_0: ARG_TYPE_STRING,
30125            key_spec_index: 0,
30126            token: 0 as *const libc::c_char,
30127            summary: 0 as *const libc::c_char,
30128            since: 0 as *const libc::c_char,
30129            flags: 0,
30130            deprecated_since: 0 as *const libc::c_char,
30131            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30132            num_args: 0,
30133        };
30134        init
30135    },
30136];
30137#[no_mangle]
30138pub static mut SINTERCARD_Args: [redisCommandArg; 4] = [
30139    {
30140        let mut init = redisCommandArg {
30141            name: b"numkeys\0" as *const u8 as *const libc::c_char,
30142            type_0: ARG_TYPE_INTEGER,
30143            key_spec_index: -(1 as libc::c_int),
30144            token: 0 as *const libc::c_char,
30145            summary: 0 as *const libc::c_char,
30146            since: 0 as *const libc::c_char,
30147            flags: 0 as libc::c_int,
30148            deprecated_since: 0 as *const libc::c_char,
30149            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30150            num_args: 0,
30151        };
30152        init
30153    },
30154    {
30155        let mut init = redisCommandArg {
30156            name: b"key\0" as *const u8 as *const libc::c_char,
30157            type_0: ARG_TYPE_KEY,
30158            key_spec_index: 0 as libc::c_int,
30159            token: 0 as *const libc::c_char,
30160            summary: 0 as *const libc::c_char,
30161            since: 0 as *const libc::c_char,
30162            flags: (1 as libc::c_int) << 1 as libc::c_int,
30163            deprecated_since: 0 as *const libc::c_char,
30164            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30165            num_args: 0,
30166        };
30167        init
30168    },
30169    {
30170        let mut init = redisCommandArg {
30171            name: b"limit\0" as *const u8 as *const libc::c_char,
30172            type_0: ARG_TYPE_INTEGER,
30173            key_spec_index: -(1 as libc::c_int),
30174            token: b"LIMIT\0" as *const u8 as *const libc::c_char,
30175            summary: 0 as *const libc::c_char,
30176            since: 0 as *const libc::c_char,
30177            flags: (1 as libc::c_int) << 0 as libc::c_int,
30178            deprecated_since: 0 as *const libc::c_char,
30179            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30180            num_args: 0,
30181        };
30182        init
30183    },
30184    {
30185        let mut init = redisCommandArg {
30186            name: 0 as *const libc::c_char,
30187            type_0: ARG_TYPE_STRING,
30188            key_spec_index: 0,
30189            token: 0 as *const libc::c_char,
30190            summary: 0 as *const libc::c_char,
30191            since: 0 as *const libc::c_char,
30192            flags: 0,
30193            deprecated_since: 0 as *const libc::c_char,
30194            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30195            num_args: 0,
30196        };
30197        init
30198    },
30199];
30200#[no_mangle]
30201pub static mut SINTERSTORE_Args: [redisCommandArg; 3] = [
30202    {
30203        let mut init = redisCommandArg {
30204            name: b"destination\0" as *const u8 as *const libc::c_char,
30205            type_0: ARG_TYPE_KEY,
30206            key_spec_index: 0 as libc::c_int,
30207            token: 0 as *const libc::c_char,
30208            summary: 0 as *const libc::c_char,
30209            since: 0 as *const libc::c_char,
30210            flags: 0 as libc::c_int,
30211            deprecated_since: 0 as *const libc::c_char,
30212            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30213            num_args: 0,
30214        };
30215        init
30216    },
30217    {
30218        let mut init = redisCommandArg {
30219            name: b"key\0" as *const u8 as *const libc::c_char,
30220            type_0: ARG_TYPE_KEY,
30221            key_spec_index: 1 as libc::c_int,
30222            token: 0 as *const libc::c_char,
30223            summary: 0 as *const libc::c_char,
30224            since: 0 as *const libc::c_char,
30225            flags: (1 as libc::c_int) << 1 as libc::c_int,
30226            deprecated_since: 0 as *const libc::c_char,
30227            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30228            num_args: 0,
30229        };
30230        init
30231    },
30232    {
30233        let mut init = redisCommandArg {
30234            name: 0 as *const libc::c_char,
30235            type_0: ARG_TYPE_STRING,
30236            key_spec_index: 0,
30237            token: 0 as *const libc::c_char,
30238            summary: 0 as *const libc::c_char,
30239            since: 0 as *const libc::c_char,
30240            flags: 0,
30241            deprecated_since: 0 as *const libc::c_char,
30242            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30243            num_args: 0,
30244        };
30245        init
30246    },
30247];
30248#[no_mangle]
30249pub static mut SISMEMBER_Args: [redisCommandArg; 3] = [
30250    {
30251        let mut init = redisCommandArg {
30252            name: b"key\0" as *const u8 as *const libc::c_char,
30253            type_0: ARG_TYPE_KEY,
30254            key_spec_index: 0 as libc::c_int,
30255            token: 0 as *const libc::c_char,
30256            summary: 0 as *const libc::c_char,
30257            since: 0 as *const libc::c_char,
30258            flags: 0 as libc::c_int,
30259            deprecated_since: 0 as *const libc::c_char,
30260            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30261            num_args: 0,
30262        };
30263        init
30264    },
30265    {
30266        let mut init = redisCommandArg {
30267            name: b"member\0" as *const u8 as *const libc::c_char,
30268            type_0: ARG_TYPE_STRING,
30269            key_spec_index: -(1 as libc::c_int),
30270            token: 0 as *const libc::c_char,
30271            summary: 0 as *const libc::c_char,
30272            since: 0 as *const libc::c_char,
30273            flags: 0 as libc::c_int,
30274            deprecated_since: 0 as *const libc::c_char,
30275            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30276            num_args: 0,
30277        };
30278        init
30279    },
30280    {
30281        let mut init = redisCommandArg {
30282            name: 0 as *const libc::c_char,
30283            type_0: ARG_TYPE_STRING,
30284            key_spec_index: 0,
30285            token: 0 as *const libc::c_char,
30286            summary: 0 as *const libc::c_char,
30287            since: 0 as *const libc::c_char,
30288            flags: 0,
30289            deprecated_since: 0 as *const libc::c_char,
30290            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30291            num_args: 0,
30292        };
30293        init
30294    },
30295];
30296#[no_mangle]
30297pub static mut SMEMBERS_tips: [*const libc::c_char; 2] = [
30298    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
30299    0 as *const libc::c_char,
30300];
30301#[no_mangle]
30302pub static mut SMEMBERS_Args: [redisCommandArg; 2] = [
30303    {
30304        let mut init = redisCommandArg {
30305            name: b"key\0" as *const u8 as *const libc::c_char,
30306            type_0: ARG_TYPE_KEY,
30307            key_spec_index: 0 as libc::c_int,
30308            token: 0 as *const libc::c_char,
30309            summary: 0 as *const libc::c_char,
30310            since: 0 as *const libc::c_char,
30311            flags: 0 as libc::c_int,
30312            deprecated_since: 0 as *const libc::c_char,
30313            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30314            num_args: 0,
30315        };
30316        init
30317    },
30318    {
30319        let mut init = redisCommandArg {
30320            name: 0 as *const libc::c_char,
30321            type_0: ARG_TYPE_STRING,
30322            key_spec_index: 0,
30323            token: 0 as *const libc::c_char,
30324            summary: 0 as *const libc::c_char,
30325            since: 0 as *const libc::c_char,
30326            flags: 0,
30327            deprecated_since: 0 as *const libc::c_char,
30328            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30329            num_args: 0,
30330        };
30331        init
30332    },
30333];
30334#[no_mangle]
30335pub static mut SMISMEMBER_Args: [redisCommandArg; 3] = [
30336    {
30337        let mut init = redisCommandArg {
30338            name: b"key\0" as *const u8 as *const libc::c_char,
30339            type_0: ARG_TYPE_KEY,
30340            key_spec_index: 0 as libc::c_int,
30341            token: 0 as *const libc::c_char,
30342            summary: 0 as *const libc::c_char,
30343            since: 0 as *const libc::c_char,
30344            flags: 0 as libc::c_int,
30345            deprecated_since: 0 as *const libc::c_char,
30346            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30347            num_args: 0,
30348        };
30349        init
30350    },
30351    {
30352        let mut init = redisCommandArg {
30353            name: b"member\0" as *const u8 as *const libc::c_char,
30354            type_0: ARG_TYPE_STRING,
30355            key_spec_index: -(1 as libc::c_int),
30356            token: 0 as *const libc::c_char,
30357            summary: 0 as *const libc::c_char,
30358            since: 0 as *const libc::c_char,
30359            flags: (1 as libc::c_int) << 1 as libc::c_int,
30360            deprecated_since: 0 as *const libc::c_char,
30361            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30362            num_args: 0,
30363        };
30364        init
30365    },
30366    {
30367        let mut init = redisCommandArg {
30368            name: 0 as *const libc::c_char,
30369            type_0: ARG_TYPE_STRING,
30370            key_spec_index: 0,
30371            token: 0 as *const libc::c_char,
30372            summary: 0 as *const libc::c_char,
30373            since: 0 as *const libc::c_char,
30374            flags: 0,
30375            deprecated_since: 0 as *const libc::c_char,
30376            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30377            num_args: 0,
30378        };
30379        init
30380    },
30381];
30382#[no_mangle]
30383pub static mut SMOVE_Args: [redisCommandArg; 4] = [
30384    {
30385        let mut init = redisCommandArg {
30386            name: b"source\0" as *const u8 as *const libc::c_char,
30387            type_0: ARG_TYPE_KEY,
30388            key_spec_index: 0 as libc::c_int,
30389            token: 0 as *const libc::c_char,
30390            summary: 0 as *const libc::c_char,
30391            since: 0 as *const libc::c_char,
30392            flags: 0 as libc::c_int,
30393            deprecated_since: 0 as *const libc::c_char,
30394            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30395            num_args: 0,
30396        };
30397        init
30398    },
30399    {
30400        let mut init = redisCommandArg {
30401            name: b"destination\0" as *const u8 as *const libc::c_char,
30402            type_0: ARG_TYPE_KEY,
30403            key_spec_index: 1 as libc::c_int,
30404            token: 0 as *const libc::c_char,
30405            summary: 0 as *const libc::c_char,
30406            since: 0 as *const libc::c_char,
30407            flags: 0 as libc::c_int,
30408            deprecated_since: 0 as *const libc::c_char,
30409            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30410            num_args: 0,
30411        };
30412        init
30413    },
30414    {
30415        let mut init = redisCommandArg {
30416            name: b"member\0" as *const u8 as *const libc::c_char,
30417            type_0: ARG_TYPE_STRING,
30418            key_spec_index: -(1 as libc::c_int),
30419            token: 0 as *const libc::c_char,
30420            summary: 0 as *const libc::c_char,
30421            since: 0 as *const libc::c_char,
30422            flags: 0 as libc::c_int,
30423            deprecated_since: 0 as *const libc::c_char,
30424            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30425            num_args: 0,
30426        };
30427        init
30428    },
30429    {
30430        let mut init = redisCommandArg {
30431            name: 0 as *const libc::c_char,
30432            type_0: ARG_TYPE_STRING,
30433            key_spec_index: 0,
30434            token: 0 as *const libc::c_char,
30435            summary: 0 as *const libc::c_char,
30436            since: 0 as *const libc::c_char,
30437            flags: 0,
30438            deprecated_since: 0 as *const libc::c_char,
30439            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30440            num_args: 0,
30441        };
30442        init
30443    },
30444];
30445#[no_mangle]
30446pub static mut SPOP_History: [commandHistory; 2] = [
30447    {
30448        let mut init = commandHistory {
30449            since: b"3.2.0\0" as *const u8 as *const libc::c_char,
30450            changes: b"Added the `count` argument.\0" as *const u8 as *const libc::c_char,
30451        };
30452        init
30453    },
30454    {
30455        let mut init = commandHistory {
30456            since: 0 as *const libc::c_char,
30457            changes: 0 as *const libc::c_char,
30458        };
30459        init
30460    },
30461];
30462#[no_mangle]
30463pub static mut SPOP_tips: [*const libc::c_char; 2] = [
30464    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
30465    0 as *const libc::c_char,
30466];
30467#[no_mangle]
30468pub static mut SPOP_Args: [redisCommandArg; 3] = [
30469    {
30470        let mut init = redisCommandArg {
30471            name: b"key\0" as *const u8 as *const libc::c_char,
30472            type_0: ARG_TYPE_KEY,
30473            key_spec_index: 0 as libc::c_int,
30474            token: 0 as *const libc::c_char,
30475            summary: 0 as *const libc::c_char,
30476            since: 0 as *const libc::c_char,
30477            flags: 0 as libc::c_int,
30478            deprecated_since: 0 as *const libc::c_char,
30479            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30480            num_args: 0,
30481        };
30482        init
30483    },
30484    {
30485        let mut init = redisCommandArg {
30486            name: b"count\0" as *const u8 as *const libc::c_char,
30487            type_0: ARG_TYPE_INTEGER,
30488            key_spec_index: -(1 as libc::c_int),
30489            token: 0 as *const libc::c_char,
30490            summary: 0 as *const libc::c_char,
30491            since: b"3.2.0\0" as *const u8 as *const libc::c_char,
30492            flags: (1 as libc::c_int) << 0 as libc::c_int,
30493            deprecated_since: 0 as *const libc::c_char,
30494            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30495            num_args: 0,
30496        };
30497        init
30498    },
30499    {
30500        let mut init = redisCommandArg {
30501            name: 0 as *const libc::c_char,
30502            type_0: ARG_TYPE_STRING,
30503            key_spec_index: 0,
30504            token: 0 as *const libc::c_char,
30505            summary: 0 as *const libc::c_char,
30506            since: 0 as *const libc::c_char,
30507            flags: 0,
30508            deprecated_since: 0 as *const libc::c_char,
30509            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30510            num_args: 0,
30511        };
30512        init
30513    },
30514];
30515#[no_mangle]
30516pub static mut SRANDMEMBER_History: [commandHistory; 2] = [
30517    {
30518        let mut init = commandHistory {
30519            since: b"2.6.0\0" as *const u8 as *const libc::c_char,
30520            changes: b"Added the optional `count` argument.\0" as *const u8
30521                as *const libc::c_char,
30522        };
30523        init
30524    },
30525    {
30526        let mut init = commandHistory {
30527            since: 0 as *const libc::c_char,
30528            changes: 0 as *const libc::c_char,
30529        };
30530        init
30531    },
30532];
30533#[no_mangle]
30534pub static mut SRANDMEMBER_tips: [*const libc::c_char; 2] = [
30535    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
30536    0 as *const libc::c_char,
30537];
30538#[no_mangle]
30539pub static mut SRANDMEMBER_Args: [redisCommandArg; 3] = [
30540    {
30541        let mut init = redisCommandArg {
30542            name: b"key\0" as *const u8 as *const libc::c_char,
30543            type_0: ARG_TYPE_KEY,
30544            key_spec_index: 0 as libc::c_int,
30545            token: 0 as *const libc::c_char,
30546            summary: 0 as *const libc::c_char,
30547            since: 0 as *const libc::c_char,
30548            flags: 0 as libc::c_int,
30549            deprecated_since: 0 as *const libc::c_char,
30550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30551            num_args: 0,
30552        };
30553        init
30554    },
30555    {
30556        let mut init = redisCommandArg {
30557            name: b"count\0" as *const u8 as *const libc::c_char,
30558            type_0: ARG_TYPE_INTEGER,
30559            key_spec_index: -(1 as libc::c_int),
30560            token: 0 as *const libc::c_char,
30561            summary: 0 as *const libc::c_char,
30562            since: b"2.6.0\0" as *const u8 as *const libc::c_char,
30563            flags: (1 as libc::c_int) << 0 as libc::c_int,
30564            deprecated_since: 0 as *const libc::c_char,
30565            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30566            num_args: 0,
30567        };
30568        init
30569    },
30570    {
30571        let mut init = redisCommandArg {
30572            name: 0 as *const libc::c_char,
30573            type_0: ARG_TYPE_STRING,
30574            key_spec_index: 0,
30575            token: 0 as *const libc::c_char,
30576            summary: 0 as *const libc::c_char,
30577            since: 0 as *const libc::c_char,
30578            flags: 0,
30579            deprecated_since: 0 as *const libc::c_char,
30580            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30581            num_args: 0,
30582        };
30583        init
30584    },
30585];
30586#[no_mangle]
30587pub static mut SREM_History: [commandHistory; 2] = [
30588    {
30589        let mut init = commandHistory {
30590            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
30591            changes: b"Accepts multiple `member` arguments.\0" as *const u8
30592                as *const libc::c_char,
30593        };
30594        init
30595    },
30596    {
30597        let mut init = commandHistory {
30598            since: 0 as *const libc::c_char,
30599            changes: 0 as *const libc::c_char,
30600        };
30601        init
30602    },
30603];
30604#[no_mangle]
30605pub static mut SREM_Args: [redisCommandArg; 3] = [
30606    {
30607        let mut init = redisCommandArg {
30608            name: b"key\0" as *const u8 as *const libc::c_char,
30609            type_0: ARG_TYPE_KEY,
30610            key_spec_index: 0 as libc::c_int,
30611            token: 0 as *const libc::c_char,
30612            summary: 0 as *const libc::c_char,
30613            since: 0 as *const libc::c_char,
30614            flags: 0 as libc::c_int,
30615            deprecated_since: 0 as *const libc::c_char,
30616            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30617            num_args: 0,
30618        };
30619        init
30620    },
30621    {
30622        let mut init = redisCommandArg {
30623            name: b"member\0" as *const u8 as *const libc::c_char,
30624            type_0: ARG_TYPE_STRING,
30625            key_spec_index: -(1 as libc::c_int),
30626            token: 0 as *const libc::c_char,
30627            summary: 0 as *const libc::c_char,
30628            since: 0 as *const libc::c_char,
30629            flags: (1 as libc::c_int) << 1 as libc::c_int,
30630            deprecated_since: 0 as *const libc::c_char,
30631            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30632            num_args: 0,
30633        };
30634        init
30635    },
30636    {
30637        let mut init = redisCommandArg {
30638            name: 0 as *const libc::c_char,
30639            type_0: ARG_TYPE_STRING,
30640            key_spec_index: 0,
30641            token: 0 as *const libc::c_char,
30642            summary: 0 as *const libc::c_char,
30643            since: 0 as *const libc::c_char,
30644            flags: 0,
30645            deprecated_since: 0 as *const libc::c_char,
30646            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30647            num_args: 0,
30648        };
30649        init
30650    },
30651];
30652#[no_mangle]
30653pub static mut SSCAN_tips: [*const libc::c_char; 2] = [
30654    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
30655    0 as *const libc::c_char,
30656];
30657#[no_mangle]
30658pub static mut SSCAN_Args: [redisCommandArg; 5] = [
30659    {
30660        let mut init = redisCommandArg {
30661            name: b"key\0" as *const u8 as *const libc::c_char,
30662            type_0: ARG_TYPE_KEY,
30663            key_spec_index: 0 as libc::c_int,
30664            token: 0 as *const libc::c_char,
30665            summary: 0 as *const libc::c_char,
30666            since: 0 as *const libc::c_char,
30667            flags: 0 as libc::c_int,
30668            deprecated_since: 0 as *const libc::c_char,
30669            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30670            num_args: 0,
30671        };
30672        init
30673    },
30674    {
30675        let mut init = redisCommandArg {
30676            name: b"cursor\0" as *const u8 as *const libc::c_char,
30677            type_0: ARG_TYPE_INTEGER,
30678            key_spec_index: -(1 as libc::c_int),
30679            token: 0 as *const libc::c_char,
30680            summary: 0 as *const libc::c_char,
30681            since: 0 as *const libc::c_char,
30682            flags: 0 as libc::c_int,
30683            deprecated_since: 0 as *const libc::c_char,
30684            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30685            num_args: 0,
30686        };
30687        init
30688    },
30689    {
30690        let mut init = redisCommandArg {
30691            name: b"pattern\0" as *const u8 as *const libc::c_char,
30692            type_0: ARG_TYPE_PATTERN,
30693            key_spec_index: -(1 as libc::c_int),
30694            token: b"MATCH\0" as *const u8 as *const libc::c_char,
30695            summary: 0 as *const libc::c_char,
30696            since: 0 as *const libc::c_char,
30697            flags: (1 as libc::c_int) << 0 as libc::c_int,
30698            deprecated_since: 0 as *const libc::c_char,
30699            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30700            num_args: 0,
30701        };
30702        init
30703    },
30704    {
30705        let mut init = redisCommandArg {
30706            name: b"count\0" as *const u8 as *const libc::c_char,
30707            type_0: ARG_TYPE_INTEGER,
30708            key_spec_index: -(1 as libc::c_int),
30709            token: b"COUNT\0" as *const u8 as *const libc::c_char,
30710            summary: 0 as *const libc::c_char,
30711            since: 0 as *const libc::c_char,
30712            flags: (1 as libc::c_int) << 0 as libc::c_int,
30713            deprecated_since: 0 as *const libc::c_char,
30714            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30715            num_args: 0,
30716        };
30717        init
30718    },
30719    {
30720        let mut init = redisCommandArg {
30721            name: 0 as *const libc::c_char,
30722            type_0: ARG_TYPE_STRING,
30723            key_spec_index: 0,
30724            token: 0 as *const libc::c_char,
30725            summary: 0 as *const libc::c_char,
30726            since: 0 as *const libc::c_char,
30727            flags: 0,
30728            deprecated_since: 0 as *const libc::c_char,
30729            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30730            num_args: 0,
30731        };
30732        init
30733    },
30734];
30735#[no_mangle]
30736pub static mut SUNION_tips: [*const libc::c_char; 2] = [
30737    b"nondeterministic_output_order\0" as *const u8 as *const libc::c_char,
30738    0 as *const libc::c_char,
30739];
30740#[no_mangle]
30741pub static mut SUNION_Args: [redisCommandArg; 2] = [
30742    {
30743        let mut init = redisCommandArg {
30744            name: b"key\0" as *const u8 as *const libc::c_char,
30745            type_0: ARG_TYPE_KEY,
30746            key_spec_index: 0 as libc::c_int,
30747            token: 0 as *const libc::c_char,
30748            summary: 0 as *const libc::c_char,
30749            since: 0 as *const libc::c_char,
30750            flags: (1 as libc::c_int) << 1 as libc::c_int,
30751            deprecated_since: 0 as *const libc::c_char,
30752            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30753            num_args: 0,
30754        };
30755        init
30756    },
30757    {
30758        let mut init = redisCommandArg {
30759            name: 0 as *const libc::c_char,
30760            type_0: ARG_TYPE_STRING,
30761            key_spec_index: 0,
30762            token: 0 as *const libc::c_char,
30763            summary: 0 as *const libc::c_char,
30764            since: 0 as *const libc::c_char,
30765            flags: 0,
30766            deprecated_since: 0 as *const libc::c_char,
30767            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30768            num_args: 0,
30769        };
30770        init
30771    },
30772];
30773#[no_mangle]
30774pub static mut SUNIONSTORE_Args: [redisCommandArg; 3] = [
30775    {
30776        let mut init = redisCommandArg {
30777            name: b"destination\0" as *const u8 as *const libc::c_char,
30778            type_0: ARG_TYPE_KEY,
30779            key_spec_index: 0 as libc::c_int,
30780            token: 0 as *const libc::c_char,
30781            summary: 0 as *const libc::c_char,
30782            since: 0 as *const libc::c_char,
30783            flags: 0 as libc::c_int,
30784            deprecated_since: 0 as *const libc::c_char,
30785            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30786            num_args: 0,
30787        };
30788        init
30789    },
30790    {
30791        let mut init = redisCommandArg {
30792            name: b"key\0" as *const u8 as *const libc::c_char,
30793            type_0: ARG_TYPE_KEY,
30794            key_spec_index: 1 as libc::c_int,
30795            token: 0 as *const libc::c_char,
30796            summary: 0 as *const libc::c_char,
30797            since: 0 as *const libc::c_char,
30798            flags: (1 as libc::c_int) << 1 as libc::c_int,
30799            deprecated_since: 0 as *const libc::c_char,
30800            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30801            num_args: 0,
30802        };
30803        init
30804    },
30805    {
30806        let mut init = redisCommandArg {
30807            name: 0 as *const libc::c_char,
30808            type_0: ARG_TYPE_STRING,
30809            key_spec_index: 0,
30810            token: 0 as *const libc::c_char,
30811            summary: 0 as *const libc::c_char,
30812            since: 0 as *const libc::c_char,
30813            flags: 0,
30814            deprecated_since: 0 as *const libc::c_char,
30815            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30816            num_args: 0,
30817        };
30818        init
30819    },
30820];
30821#[no_mangle]
30822pub static mut BZMPOP_where_Subargs: [redisCommandArg; 3] = [
30823    {
30824        let mut init = redisCommandArg {
30825            name: b"min\0" as *const u8 as *const libc::c_char,
30826            type_0: ARG_TYPE_PURE_TOKEN,
30827            key_spec_index: -(1 as libc::c_int),
30828            token: b"MIN\0" as *const u8 as *const libc::c_char,
30829            summary: 0 as *const libc::c_char,
30830            since: 0 as *const libc::c_char,
30831            flags: 0 as libc::c_int,
30832            deprecated_since: 0 as *const libc::c_char,
30833            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30834            num_args: 0,
30835        };
30836        init
30837    },
30838    {
30839        let mut init = redisCommandArg {
30840            name: b"max\0" as *const u8 as *const libc::c_char,
30841            type_0: ARG_TYPE_PURE_TOKEN,
30842            key_spec_index: -(1 as libc::c_int),
30843            token: b"MAX\0" as *const u8 as *const libc::c_char,
30844            summary: 0 as *const libc::c_char,
30845            since: 0 as *const libc::c_char,
30846            flags: 0 as libc::c_int,
30847            deprecated_since: 0 as *const libc::c_char,
30848            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30849            num_args: 0,
30850        };
30851        init
30852    },
30853    {
30854        let mut init = redisCommandArg {
30855            name: 0 as *const libc::c_char,
30856            type_0: ARG_TYPE_STRING,
30857            key_spec_index: 0,
30858            token: 0 as *const libc::c_char,
30859            summary: 0 as *const libc::c_char,
30860            since: 0 as *const libc::c_char,
30861            flags: 0,
30862            deprecated_since: 0 as *const libc::c_char,
30863            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30864            num_args: 0,
30865        };
30866        init
30867    },
30868];
30869#[no_mangle]
30870pub static mut BZMPOP_Args: [redisCommandArg; 6] = unsafe {
30871    [
30872        {
30873            let mut init = redisCommandArg {
30874                name: b"timeout\0" as *const u8 as *const libc::c_char,
30875                type_0: ARG_TYPE_DOUBLE,
30876                key_spec_index: -(1 as libc::c_int),
30877                token: 0 as *const libc::c_char,
30878                summary: 0 as *const libc::c_char,
30879                since: 0 as *const libc::c_char,
30880                flags: 0 as libc::c_int,
30881                deprecated_since: 0 as *const libc::c_char,
30882                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30883                num_args: 0,
30884            };
30885            init
30886        },
30887        {
30888            let mut init = redisCommandArg {
30889                name: b"numkeys\0" as *const u8 as *const libc::c_char,
30890                type_0: ARG_TYPE_INTEGER,
30891                key_spec_index: -(1 as libc::c_int),
30892                token: 0 as *const libc::c_char,
30893                summary: 0 as *const libc::c_char,
30894                since: 0 as *const libc::c_char,
30895                flags: 0 as libc::c_int,
30896                deprecated_since: 0 as *const libc::c_char,
30897                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30898                num_args: 0,
30899            };
30900            init
30901        },
30902        {
30903            let mut init = redisCommandArg {
30904                name: b"key\0" as *const u8 as *const libc::c_char,
30905                type_0: ARG_TYPE_KEY,
30906                key_spec_index: 0 as libc::c_int,
30907                token: 0 as *const libc::c_char,
30908                summary: 0 as *const libc::c_char,
30909                since: 0 as *const libc::c_char,
30910                flags: (1 as libc::c_int) << 1 as libc::c_int,
30911                deprecated_since: 0 as *const libc::c_char,
30912                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30913                num_args: 0,
30914            };
30915            init
30916        },
30917        {
30918            let mut init = redisCommandArg {
30919                name: b"where\0" as *const u8 as *const libc::c_char,
30920                type_0: ARG_TYPE_ONEOF,
30921                key_spec_index: -(1 as libc::c_int),
30922                token: 0 as *const libc::c_char,
30923                summary: 0 as *const libc::c_char,
30924                since: 0 as *const libc::c_char,
30925                flags: 0 as libc::c_int,
30926                deprecated_since: 0 as *const libc::c_char,
30927                subargs: BZMPOP_where_Subargs.as_ptr() as *mut _,
30928                num_args: 0,
30929            };
30930            init
30931        },
30932        {
30933            let mut init = redisCommandArg {
30934                name: b"count\0" as *const u8 as *const libc::c_char,
30935                type_0: ARG_TYPE_INTEGER,
30936                key_spec_index: -(1 as libc::c_int),
30937                token: b"COUNT\0" as *const u8 as *const libc::c_char,
30938                summary: 0 as *const libc::c_char,
30939                since: 0 as *const libc::c_char,
30940                flags: (1 as libc::c_int) << 0 as libc::c_int,
30941                deprecated_since: 0 as *const libc::c_char,
30942                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30943                num_args: 0,
30944            };
30945            init
30946        },
30947        {
30948            let mut init = redisCommandArg {
30949                name: 0 as *const libc::c_char,
30950                type_0: ARG_TYPE_STRING,
30951                key_spec_index: 0,
30952                token: 0 as *const libc::c_char,
30953                summary: 0 as *const libc::c_char,
30954                since: 0 as *const libc::c_char,
30955                flags: 0,
30956                deprecated_since: 0 as *const libc::c_char,
30957                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30958                num_args: 0,
30959            };
30960            init
30961        },
30962    ]
30963};
30964#[no_mangle]
30965pub static mut BZPOPMAX_History: [commandHistory; 2] = [
30966    {
30967        let mut init = commandHistory {
30968            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
30969            changes: b"`timeout` is interpreted as a double instead of an integer.\0"
30970                as *const u8 as *const libc::c_char,
30971        };
30972        init
30973    },
30974    {
30975        let mut init = commandHistory {
30976            since: 0 as *const libc::c_char,
30977            changes: 0 as *const libc::c_char,
30978        };
30979        init
30980    },
30981];
30982#[no_mangle]
30983pub static mut BZPOPMAX_Args: [redisCommandArg; 3] = [
30984    {
30985        let mut init = redisCommandArg {
30986            name: b"key\0" as *const u8 as *const libc::c_char,
30987            type_0: ARG_TYPE_KEY,
30988            key_spec_index: 0 as libc::c_int,
30989            token: 0 as *const libc::c_char,
30990            summary: 0 as *const libc::c_char,
30991            since: 0 as *const libc::c_char,
30992            flags: (1 as libc::c_int) << 1 as libc::c_int,
30993            deprecated_since: 0 as *const libc::c_char,
30994            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
30995            num_args: 0,
30996        };
30997        init
30998    },
30999    {
31000        let mut init = redisCommandArg {
31001            name: b"timeout\0" as *const u8 as *const libc::c_char,
31002            type_0: ARG_TYPE_DOUBLE,
31003            key_spec_index: -(1 as libc::c_int),
31004            token: 0 as *const libc::c_char,
31005            summary: 0 as *const libc::c_char,
31006            since: 0 as *const libc::c_char,
31007            flags: 0 as libc::c_int,
31008            deprecated_since: 0 as *const libc::c_char,
31009            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31010            num_args: 0,
31011        };
31012        init
31013    },
31014    {
31015        let mut init = redisCommandArg {
31016            name: 0 as *const libc::c_char,
31017            type_0: ARG_TYPE_STRING,
31018            key_spec_index: 0,
31019            token: 0 as *const libc::c_char,
31020            summary: 0 as *const libc::c_char,
31021            since: 0 as *const libc::c_char,
31022            flags: 0,
31023            deprecated_since: 0 as *const libc::c_char,
31024            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31025            num_args: 0,
31026        };
31027        init
31028    },
31029];
31030#[no_mangle]
31031pub static mut BZPOPMIN_History: [commandHistory; 2] = [
31032    {
31033        let mut init = commandHistory {
31034            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
31035            changes: b"`timeout` is interpreted as a double instead of an integer.\0"
31036                as *const u8 as *const libc::c_char,
31037        };
31038        init
31039    },
31040    {
31041        let mut init = commandHistory {
31042            since: 0 as *const libc::c_char,
31043            changes: 0 as *const libc::c_char,
31044        };
31045        init
31046    },
31047];
31048#[no_mangle]
31049pub static mut BZPOPMIN_Args: [redisCommandArg; 3] = [
31050    {
31051        let mut init = redisCommandArg {
31052            name: b"key\0" as *const u8 as *const libc::c_char,
31053            type_0: ARG_TYPE_KEY,
31054            key_spec_index: 0 as libc::c_int,
31055            token: 0 as *const libc::c_char,
31056            summary: 0 as *const libc::c_char,
31057            since: 0 as *const libc::c_char,
31058            flags: (1 as libc::c_int) << 1 as libc::c_int,
31059            deprecated_since: 0 as *const libc::c_char,
31060            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31061            num_args: 0,
31062        };
31063        init
31064    },
31065    {
31066        let mut init = redisCommandArg {
31067            name: b"timeout\0" as *const u8 as *const libc::c_char,
31068            type_0: ARG_TYPE_DOUBLE,
31069            key_spec_index: -(1 as libc::c_int),
31070            token: 0 as *const libc::c_char,
31071            summary: 0 as *const libc::c_char,
31072            since: 0 as *const libc::c_char,
31073            flags: 0 as libc::c_int,
31074            deprecated_since: 0 as *const libc::c_char,
31075            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31076            num_args: 0,
31077        };
31078        init
31079    },
31080    {
31081        let mut init = redisCommandArg {
31082            name: 0 as *const libc::c_char,
31083            type_0: ARG_TYPE_STRING,
31084            key_spec_index: 0,
31085            token: 0 as *const libc::c_char,
31086            summary: 0 as *const libc::c_char,
31087            since: 0 as *const libc::c_char,
31088            flags: 0,
31089            deprecated_since: 0 as *const libc::c_char,
31090            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31091            num_args: 0,
31092        };
31093        init
31094    },
31095];
31096#[no_mangle]
31097pub static mut ZADD_History: [commandHistory; 4] = [
31098    {
31099        let mut init = commandHistory {
31100            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
31101            changes: b"Accepts multiple elements.\0" as *const u8 as *const libc::c_char,
31102        };
31103        init
31104    },
31105    {
31106        let mut init = commandHistory {
31107            since: b"3.0.2\0" as *const u8 as *const libc::c_char,
31108            changes: b"Added the `XX`, `NX`, `CH` and `INCR` options.\0" as *const u8
31109                as *const libc::c_char,
31110        };
31111        init
31112    },
31113    {
31114        let mut init = commandHistory {
31115            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
31116            changes: b"Added the `GT` and `LT` options.\0" as *const u8
31117                as *const libc::c_char,
31118        };
31119        init
31120    },
31121    {
31122        let mut init = commandHistory {
31123            since: 0 as *const libc::c_char,
31124            changes: 0 as *const libc::c_char,
31125        };
31126        init
31127    },
31128];
31129#[no_mangle]
31130pub static mut ZADD_condition_Subargs: [redisCommandArg; 3] = [
31131    {
31132        let mut init = redisCommandArg {
31133            name: b"nx\0" as *const u8 as *const libc::c_char,
31134            type_0: ARG_TYPE_PURE_TOKEN,
31135            key_spec_index: -(1 as libc::c_int),
31136            token: b"NX\0" as *const u8 as *const libc::c_char,
31137            summary: 0 as *const libc::c_char,
31138            since: 0 as *const libc::c_char,
31139            flags: 0 as libc::c_int,
31140            deprecated_since: 0 as *const libc::c_char,
31141            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31142            num_args: 0,
31143        };
31144        init
31145    },
31146    {
31147        let mut init = redisCommandArg {
31148            name: b"xx\0" as *const u8 as *const libc::c_char,
31149            type_0: ARG_TYPE_PURE_TOKEN,
31150            key_spec_index: -(1 as libc::c_int),
31151            token: b"XX\0" as *const u8 as *const libc::c_char,
31152            summary: 0 as *const libc::c_char,
31153            since: 0 as *const libc::c_char,
31154            flags: 0 as libc::c_int,
31155            deprecated_since: 0 as *const libc::c_char,
31156            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31157            num_args: 0,
31158        };
31159        init
31160    },
31161    {
31162        let mut init = redisCommandArg {
31163            name: 0 as *const libc::c_char,
31164            type_0: ARG_TYPE_STRING,
31165            key_spec_index: 0,
31166            token: 0 as *const libc::c_char,
31167            summary: 0 as *const libc::c_char,
31168            since: 0 as *const libc::c_char,
31169            flags: 0,
31170            deprecated_since: 0 as *const libc::c_char,
31171            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31172            num_args: 0,
31173        };
31174        init
31175    },
31176];
31177#[no_mangle]
31178pub static mut ZADD_comparison_Subargs: [redisCommandArg; 3] = [
31179    {
31180        let mut init = redisCommandArg {
31181            name: b"gt\0" as *const u8 as *const libc::c_char,
31182            type_0: ARG_TYPE_PURE_TOKEN,
31183            key_spec_index: -(1 as libc::c_int),
31184            token: b"GT\0" as *const u8 as *const libc::c_char,
31185            summary: 0 as *const libc::c_char,
31186            since: 0 as *const libc::c_char,
31187            flags: 0 as libc::c_int,
31188            deprecated_since: 0 as *const libc::c_char,
31189            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31190            num_args: 0,
31191        };
31192        init
31193    },
31194    {
31195        let mut init = redisCommandArg {
31196            name: b"lt\0" as *const u8 as *const libc::c_char,
31197            type_0: ARG_TYPE_PURE_TOKEN,
31198            key_spec_index: -(1 as libc::c_int),
31199            token: b"LT\0" as *const u8 as *const libc::c_char,
31200            summary: 0 as *const libc::c_char,
31201            since: 0 as *const libc::c_char,
31202            flags: 0 as libc::c_int,
31203            deprecated_since: 0 as *const libc::c_char,
31204            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31205            num_args: 0,
31206        };
31207        init
31208    },
31209    {
31210        let mut init = redisCommandArg {
31211            name: 0 as *const libc::c_char,
31212            type_0: ARG_TYPE_STRING,
31213            key_spec_index: 0,
31214            token: 0 as *const libc::c_char,
31215            summary: 0 as *const libc::c_char,
31216            since: 0 as *const libc::c_char,
31217            flags: 0,
31218            deprecated_since: 0 as *const libc::c_char,
31219            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31220            num_args: 0,
31221        };
31222        init
31223    },
31224];
31225#[no_mangle]
31226pub static mut ZADD_score_member_Subargs: [redisCommandArg; 3] = [
31227    {
31228        let mut init = redisCommandArg {
31229            name: b"score\0" as *const u8 as *const libc::c_char,
31230            type_0: ARG_TYPE_DOUBLE,
31231            key_spec_index: -(1 as libc::c_int),
31232            token: 0 as *const libc::c_char,
31233            summary: 0 as *const libc::c_char,
31234            since: 0 as *const libc::c_char,
31235            flags: 0 as libc::c_int,
31236            deprecated_since: 0 as *const libc::c_char,
31237            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31238            num_args: 0,
31239        };
31240        init
31241    },
31242    {
31243        let mut init = redisCommandArg {
31244            name: b"member\0" as *const u8 as *const libc::c_char,
31245            type_0: ARG_TYPE_STRING,
31246            key_spec_index: -(1 as libc::c_int),
31247            token: 0 as *const libc::c_char,
31248            summary: 0 as *const libc::c_char,
31249            since: 0 as *const libc::c_char,
31250            flags: 0 as libc::c_int,
31251            deprecated_since: 0 as *const libc::c_char,
31252            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31253            num_args: 0,
31254        };
31255        init
31256    },
31257    {
31258        let mut init = redisCommandArg {
31259            name: 0 as *const libc::c_char,
31260            type_0: ARG_TYPE_STRING,
31261            key_spec_index: 0,
31262            token: 0 as *const libc::c_char,
31263            summary: 0 as *const libc::c_char,
31264            since: 0 as *const libc::c_char,
31265            flags: 0,
31266            deprecated_since: 0 as *const libc::c_char,
31267            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31268            num_args: 0,
31269        };
31270        init
31271    },
31272];
31273#[no_mangle]
31274pub static mut ZADD_Args: [redisCommandArg; 7] = unsafe {
31275    [
31276        {
31277            let mut init = redisCommandArg {
31278                name: b"key\0" as *const u8 as *const libc::c_char,
31279                type_0: ARG_TYPE_KEY,
31280                key_spec_index: 0 as libc::c_int,
31281                token: 0 as *const libc::c_char,
31282                summary: 0 as *const libc::c_char,
31283                since: 0 as *const libc::c_char,
31284                flags: 0 as libc::c_int,
31285                deprecated_since: 0 as *const libc::c_char,
31286                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31287                num_args: 0,
31288            };
31289            init
31290        },
31291        {
31292            let mut init = redisCommandArg {
31293                name: b"condition\0" as *const u8 as *const libc::c_char,
31294                type_0: ARG_TYPE_ONEOF,
31295                key_spec_index: -(1 as libc::c_int),
31296                token: 0 as *const libc::c_char,
31297                summary: 0 as *const libc::c_char,
31298                since: b"3.0.2\0" as *const u8 as *const libc::c_char,
31299                flags: (1 as libc::c_int) << 0 as libc::c_int,
31300                deprecated_since: 0 as *const libc::c_char,
31301                subargs: ZADD_condition_Subargs.as_ptr() as *mut _,
31302                num_args: 0,
31303            };
31304            init
31305        },
31306        {
31307            let mut init = redisCommandArg {
31308                name: b"comparison\0" as *const u8 as *const libc::c_char,
31309                type_0: ARG_TYPE_ONEOF,
31310                key_spec_index: -(1 as libc::c_int),
31311                token: 0 as *const libc::c_char,
31312                summary: 0 as *const libc::c_char,
31313                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
31314                flags: (1 as libc::c_int) << 0 as libc::c_int,
31315                deprecated_since: 0 as *const libc::c_char,
31316                subargs: ZADD_comparison_Subargs.as_ptr() as *mut _,
31317                num_args: 0,
31318            };
31319            init
31320        },
31321        {
31322            let mut init = redisCommandArg {
31323                name: b"change\0" as *const u8 as *const libc::c_char,
31324                type_0: ARG_TYPE_PURE_TOKEN,
31325                key_spec_index: -(1 as libc::c_int),
31326                token: b"CH\0" as *const u8 as *const libc::c_char,
31327                summary: 0 as *const libc::c_char,
31328                since: b"3.0.2\0" as *const u8 as *const libc::c_char,
31329                flags: (1 as libc::c_int) << 0 as libc::c_int,
31330                deprecated_since: 0 as *const libc::c_char,
31331                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31332                num_args: 0,
31333            };
31334            init
31335        },
31336        {
31337            let mut init = redisCommandArg {
31338                name: b"increment\0" as *const u8 as *const libc::c_char,
31339                type_0: ARG_TYPE_PURE_TOKEN,
31340                key_spec_index: -(1 as libc::c_int),
31341                token: b"INCR\0" as *const u8 as *const libc::c_char,
31342                summary: 0 as *const libc::c_char,
31343                since: b"3.0.2\0" as *const u8 as *const libc::c_char,
31344                flags: (1 as libc::c_int) << 0 as libc::c_int,
31345                deprecated_since: 0 as *const libc::c_char,
31346                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31347                num_args: 0,
31348            };
31349            init
31350        },
31351        {
31352            let mut init = redisCommandArg {
31353                name: b"score_member\0" as *const u8 as *const libc::c_char,
31354                type_0: ARG_TYPE_BLOCK,
31355                key_spec_index: -(1 as libc::c_int),
31356                token: 0 as *const libc::c_char,
31357                summary: 0 as *const libc::c_char,
31358                since: 0 as *const libc::c_char,
31359                flags: (1 as libc::c_int) << 1 as libc::c_int,
31360                deprecated_since: 0 as *const libc::c_char,
31361                subargs: ZADD_score_member_Subargs.as_ptr() as *mut _,
31362                num_args: 0,
31363            };
31364            init
31365        },
31366        {
31367            let mut init = redisCommandArg {
31368                name: 0 as *const libc::c_char,
31369                type_0: ARG_TYPE_STRING,
31370                key_spec_index: 0,
31371                token: 0 as *const libc::c_char,
31372                summary: 0 as *const libc::c_char,
31373                since: 0 as *const libc::c_char,
31374                flags: 0,
31375                deprecated_since: 0 as *const libc::c_char,
31376                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31377                num_args: 0,
31378            };
31379            init
31380        },
31381    ]
31382};
31383#[no_mangle]
31384pub static mut ZCARD_Args: [redisCommandArg; 2] = [
31385    {
31386        let mut init = redisCommandArg {
31387            name: b"key\0" as *const u8 as *const libc::c_char,
31388            type_0: ARG_TYPE_KEY,
31389            key_spec_index: 0 as libc::c_int,
31390            token: 0 as *const libc::c_char,
31391            summary: 0 as *const libc::c_char,
31392            since: 0 as *const libc::c_char,
31393            flags: 0 as libc::c_int,
31394            deprecated_since: 0 as *const libc::c_char,
31395            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31396            num_args: 0,
31397        };
31398        init
31399    },
31400    {
31401        let mut init = redisCommandArg {
31402            name: 0 as *const libc::c_char,
31403            type_0: ARG_TYPE_STRING,
31404            key_spec_index: 0,
31405            token: 0 as *const libc::c_char,
31406            summary: 0 as *const libc::c_char,
31407            since: 0 as *const libc::c_char,
31408            flags: 0,
31409            deprecated_since: 0 as *const libc::c_char,
31410            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31411            num_args: 0,
31412        };
31413        init
31414    },
31415];
31416#[no_mangle]
31417pub static mut ZCOUNT_Args: [redisCommandArg; 4] = [
31418    {
31419        let mut init = redisCommandArg {
31420            name: b"key\0" as *const u8 as *const libc::c_char,
31421            type_0: ARG_TYPE_KEY,
31422            key_spec_index: 0 as libc::c_int,
31423            token: 0 as *const libc::c_char,
31424            summary: 0 as *const libc::c_char,
31425            since: 0 as *const libc::c_char,
31426            flags: 0 as libc::c_int,
31427            deprecated_since: 0 as *const libc::c_char,
31428            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31429            num_args: 0,
31430        };
31431        init
31432    },
31433    {
31434        let mut init = redisCommandArg {
31435            name: b"min\0" as *const u8 as *const libc::c_char,
31436            type_0: ARG_TYPE_DOUBLE,
31437            key_spec_index: -(1 as libc::c_int),
31438            token: 0 as *const libc::c_char,
31439            summary: 0 as *const libc::c_char,
31440            since: 0 as *const libc::c_char,
31441            flags: 0 as libc::c_int,
31442            deprecated_since: 0 as *const libc::c_char,
31443            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31444            num_args: 0,
31445        };
31446        init
31447    },
31448    {
31449        let mut init = redisCommandArg {
31450            name: b"max\0" as *const u8 as *const libc::c_char,
31451            type_0: ARG_TYPE_DOUBLE,
31452            key_spec_index: -(1 as libc::c_int),
31453            token: 0 as *const libc::c_char,
31454            summary: 0 as *const libc::c_char,
31455            since: 0 as *const libc::c_char,
31456            flags: 0 as libc::c_int,
31457            deprecated_since: 0 as *const libc::c_char,
31458            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31459            num_args: 0,
31460        };
31461        init
31462    },
31463    {
31464        let mut init = redisCommandArg {
31465            name: 0 as *const libc::c_char,
31466            type_0: ARG_TYPE_STRING,
31467            key_spec_index: 0,
31468            token: 0 as *const libc::c_char,
31469            summary: 0 as *const libc::c_char,
31470            since: 0 as *const libc::c_char,
31471            flags: 0,
31472            deprecated_since: 0 as *const libc::c_char,
31473            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31474            num_args: 0,
31475        };
31476        init
31477    },
31478];
31479#[no_mangle]
31480pub static mut ZDIFF_Args: [redisCommandArg; 4] = [
31481    {
31482        let mut init = redisCommandArg {
31483            name: b"numkeys\0" as *const u8 as *const libc::c_char,
31484            type_0: ARG_TYPE_INTEGER,
31485            key_spec_index: -(1 as libc::c_int),
31486            token: 0 as *const libc::c_char,
31487            summary: 0 as *const libc::c_char,
31488            since: 0 as *const libc::c_char,
31489            flags: 0 as libc::c_int,
31490            deprecated_since: 0 as *const libc::c_char,
31491            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31492            num_args: 0,
31493        };
31494        init
31495    },
31496    {
31497        let mut init = redisCommandArg {
31498            name: b"key\0" as *const u8 as *const libc::c_char,
31499            type_0: ARG_TYPE_KEY,
31500            key_spec_index: 0 as libc::c_int,
31501            token: 0 as *const libc::c_char,
31502            summary: 0 as *const libc::c_char,
31503            since: 0 as *const libc::c_char,
31504            flags: (1 as libc::c_int) << 1 as libc::c_int,
31505            deprecated_since: 0 as *const libc::c_char,
31506            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31507            num_args: 0,
31508        };
31509        init
31510    },
31511    {
31512        let mut init = redisCommandArg {
31513            name: b"withscores\0" as *const u8 as *const libc::c_char,
31514            type_0: ARG_TYPE_PURE_TOKEN,
31515            key_spec_index: -(1 as libc::c_int),
31516            token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
31517            summary: 0 as *const libc::c_char,
31518            since: 0 as *const libc::c_char,
31519            flags: (1 as libc::c_int) << 0 as libc::c_int,
31520            deprecated_since: 0 as *const libc::c_char,
31521            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31522            num_args: 0,
31523        };
31524        init
31525    },
31526    {
31527        let mut init = redisCommandArg {
31528            name: 0 as *const libc::c_char,
31529            type_0: ARG_TYPE_STRING,
31530            key_spec_index: 0,
31531            token: 0 as *const libc::c_char,
31532            summary: 0 as *const libc::c_char,
31533            since: 0 as *const libc::c_char,
31534            flags: 0,
31535            deprecated_since: 0 as *const libc::c_char,
31536            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31537            num_args: 0,
31538        };
31539        init
31540    },
31541];
31542#[no_mangle]
31543pub static mut ZDIFFSTORE_Args: [redisCommandArg; 4] = [
31544    {
31545        let mut init = redisCommandArg {
31546            name: b"destination\0" as *const u8 as *const libc::c_char,
31547            type_0: ARG_TYPE_KEY,
31548            key_spec_index: 0 as libc::c_int,
31549            token: 0 as *const libc::c_char,
31550            summary: 0 as *const libc::c_char,
31551            since: 0 as *const libc::c_char,
31552            flags: 0 as libc::c_int,
31553            deprecated_since: 0 as *const libc::c_char,
31554            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31555            num_args: 0,
31556        };
31557        init
31558    },
31559    {
31560        let mut init = redisCommandArg {
31561            name: b"numkeys\0" as *const u8 as *const libc::c_char,
31562            type_0: ARG_TYPE_INTEGER,
31563            key_spec_index: -(1 as libc::c_int),
31564            token: 0 as *const libc::c_char,
31565            summary: 0 as *const libc::c_char,
31566            since: 0 as *const libc::c_char,
31567            flags: 0 as libc::c_int,
31568            deprecated_since: 0 as *const libc::c_char,
31569            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31570            num_args: 0,
31571        };
31572        init
31573    },
31574    {
31575        let mut init = redisCommandArg {
31576            name: b"key\0" as *const u8 as *const libc::c_char,
31577            type_0: ARG_TYPE_KEY,
31578            key_spec_index: 1 as libc::c_int,
31579            token: 0 as *const libc::c_char,
31580            summary: 0 as *const libc::c_char,
31581            since: 0 as *const libc::c_char,
31582            flags: (1 as libc::c_int) << 1 as libc::c_int,
31583            deprecated_since: 0 as *const libc::c_char,
31584            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31585            num_args: 0,
31586        };
31587        init
31588    },
31589    {
31590        let mut init = redisCommandArg {
31591            name: 0 as *const libc::c_char,
31592            type_0: ARG_TYPE_STRING,
31593            key_spec_index: 0,
31594            token: 0 as *const libc::c_char,
31595            summary: 0 as *const libc::c_char,
31596            since: 0 as *const libc::c_char,
31597            flags: 0,
31598            deprecated_since: 0 as *const libc::c_char,
31599            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31600            num_args: 0,
31601        };
31602        init
31603    },
31604];
31605#[no_mangle]
31606pub static mut ZINCRBY_Args: [redisCommandArg; 4] = [
31607    {
31608        let mut init = redisCommandArg {
31609            name: b"key\0" as *const u8 as *const libc::c_char,
31610            type_0: ARG_TYPE_KEY,
31611            key_spec_index: 0 as libc::c_int,
31612            token: 0 as *const libc::c_char,
31613            summary: 0 as *const libc::c_char,
31614            since: 0 as *const libc::c_char,
31615            flags: 0 as libc::c_int,
31616            deprecated_since: 0 as *const libc::c_char,
31617            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31618            num_args: 0,
31619        };
31620        init
31621    },
31622    {
31623        let mut init = redisCommandArg {
31624            name: b"increment\0" as *const u8 as *const libc::c_char,
31625            type_0: ARG_TYPE_INTEGER,
31626            key_spec_index: -(1 as libc::c_int),
31627            token: 0 as *const libc::c_char,
31628            summary: 0 as *const libc::c_char,
31629            since: 0 as *const libc::c_char,
31630            flags: 0 as libc::c_int,
31631            deprecated_since: 0 as *const libc::c_char,
31632            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31633            num_args: 0,
31634        };
31635        init
31636    },
31637    {
31638        let mut init = redisCommandArg {
31639            name: b"member\0" as *const u8 as *const libc::c_char,
31640            type_0: ARG_TYPE_STRING,
31641            key_spec_index: -(1 as libc::c_int),
31642            token: 0 as *const libc::c_char,
31643            summary: 0 as *const libc::c_char,
31644            since: 0 as *const libc::c_char,
31645            flags: 0 as libc::c_int,
31646            deprecated_since: 0 as *const libc::c_char,
31647            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31648            num_args: 0,
31649        };
31650        init
31651    },
31652    {
31653        let mut init = redisCommandArg {
31654            name: 0 as *const libc::c_char,
31655            type_0: ARG_TYPE_STRING,
31656            key_spec_index: 0,
31657            token: 0 as *const libc::c_char,
31658            summary: 0 as *const libc::c_char,
31659            since: 0 as *const libc::c_char,
31660            flags: 0,
31661            deprecated_since: 0 as *const libc::c_char,
31662            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31663            num_args: 0,
31664        };
31665        init
31666    },
31667];
31668#[no_mangle]
31669pub static mut ZINTER_aggregate_Subargs: [redisCommandArg; 4] = [
31670    {
31671        let mut init = redisCommandArg {
31672            name: b"sum\0" as *const u8 as *const libc::c_char,
31673            type_0: ARG_TYPE_PURE_TOKEN,
31674            key_spec_index: -(1 as libc::c_int),
31675            token: b"SUM\0" as *const u8 as *const libc::c_char,
31676            summary: 0 as *const libc::c_char,
31677            since: 0 as *const libc::c_char,
31678            flags: 0 as libc::c_int,
31679            deprecated_since: 0 as *const libc::c_char,
31680            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31681            num_args: 0,
31682        };
31683        init
31684    },
31685    {
31686        let mut init = redisCommandArg {
31687            name: b"min\0" as *const u8 as *const libc::c_char,
31688            type_0: ARG_TYPE_PURE_TOKEN,
31689            key_spec_index: -(1 as libc::c_int),
31690            token: b"MIN\0" as *const u8 as *const libc::c_char,
31691            summary: 0 as *const libc::c_char,
31692            since: 0 as *const libc::c_char,
31693            flags: 0 as libc::c_int,
31694            deprecated_since: 0 as *const libc::c_char,
31695            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31696            num_args: 0,
31697        };
31698        init
31699    },
31700    {
31701        let mut init = redisCommandArg {
31702            name: b"max\0" as *const u8 as *const libc::c_char,
31703            type_0: ARG_TYPE_PURE_TOKEN,
31704            key_spec_index: -(1 as libc::c_int),
31705            token: b"MAX\0" as *const u8 as *const libc::c_char,
31706            summary: 0 as *const libc::c_char,
31707            since: 0 as *const libc::c_char,
31708            flags: 0 as libc::c_int,
31709            deprecated_since: 0 as *const libc::c_char,
31710            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31711            num_args: 0,
31712        };
31713        init
31714    },
31715    {
31716        let mut init = redisCommandArg {
31717            name: 0 as *const libc::c_char,
31718            type_0: ARG_TYPE_STRING,
31719            key_spec_index: 0,
31720            token: 0 as *const libc::c_char,
31721            summary: 0 as *const libc::c_char,
31722            since: 0 as *const libc::c_char,
31723            flags: 0,
31724            deprecated_since: 0 as *const libc::c_char,
31725            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31726            num_args: 0,
31727        };
31728        init
31729    },
31730];
31731#[no_mangle]
31732pub static mut ZINTER_Args: [redisCommandArg; 6] = unsafe {
31733    [
31734        {
31735            let mut init = redisCommandArg {
31736                name: b"numkeys\0" as *const u8 as *const libc::c_char,
31737                type_0: ARG_TYPE_INTEGER,
31738                key_spec_index: -(1 as libc::c_int),
31739                token: 0 as *const libc::c_char,
31740                summary: 0 as *const libc::c_char,
31741                since: 0 as *const libc::c_char,
31742                flags: 0 as libc::c_int,
31743                deprecated_since: 0 as *const libc::c_char,
31744                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31745                num_args: 0,
31746            };
31747            init
31748        },
31749        {
31750            let mut init = redisCommandArg {
31751                name: b"key\0" as *const u8 as *const libc::c_char,
31752                type_0: ARG_TYPE_KEY,
31753                key_spec_index: 0 as libc::c_int,
31754                token: 0 as *const libc::c_char,
31755                summary: 0 as *const libc::c_char,
31756                since: 0 as *const libc::c_char,
31757                flags: (1 as libc::c_int) << 1 as libc::c_int,
31758                deprecated_since: 0 as *const libc::c_char,
31759                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31760                num_args: 0,
31761            };
31762            init
31763        },
31764        {
31765            let mut init = redisCommandArg {
31766                name: b"weight\0" as *const u8 as *const libc::c_char,
31767                type_0: ARG_TYPE_INTEGER,
31768                key_spec_index: -(1 as libc::c_int),
31769                token: b"WEIGHTS\0" as *const u8 as *const libc::c_char,
31770                summary: 0 as *const libc::c_char,
31771                since: 0 as *const libc::c_char,
31772                flags: (1 as libc::c_int) << 0 as libc::c_int
31773                    | (1 as libc::c_int) << 1 as libc::c_int,
31774                deprecated_since: 0 as *const libc::c_char,
31775                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31776                num_args: 0,
31777            };
31778            init
31779        },
31780        {
31781            let mut init = redisCommandArg {
31782                name: b"aggregate\0" as *const u8 as *const libc::c_char,
31783                type_0: ARG_TYPE_ONEOF,
31784                key_spec_index: -(1 as libc::c_int),
31785                token: b"AGGREGATE\0" as *const u8 as *const libc::c_char,
31786                summary: 0 as *const libc::c_char,
31787                since: 0 as *const libc::c_char,
31788                flags: (1 as libc::c_int) << 0 as libc::c_int,
31789                deprecated_since: 0 as *const libc::c_char,
31790                subargs: ZINTER_aggregate_Subargs.as_ptr() as *mut _,
31791                num_args: 0,
31792            };
31793            init
31794        },
31795        {
31796            let mut init = redisCommandArg {
31797                name: b"withscores\0" as *const u8 as *const libc::c_char,
31798                type_0: ARG_TYPE_PURE_TOKEN,
31799                key_spec_index: -(1 as libc::c_int),
31800                token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
31801                summary: 0 as *const libc::c_char,
31802                since: 0 as *const libc::c_char,
31803                flags: (1 as libc::c_int) << 0 as libc::c_int,
31804                deprecated_since: 0 as *const libc::c_char,
31805                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31806                num_args: 0,
31807            };
31808            init
31809        },
31810        {
31811            let mut init = redisCommandArg {
31812                name: 0 as *const libc::c_char,
31813                type_0: ARG_TYPE_STRING,
31814                key_spec_index: 0,
31815                token: 0 as *const libc::c_char,
31816                summary: 0 as *const libc::c_char,
31817                since: 0 as *const libc::c_char,
31818                flags: 0,
31819                deprecated_since: 0 as *const libc::c_char,
31820                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31821                num_args: 0,
31822            };
31823            init
31824        },
31825    ]
31826};
31827#[no_mangle]
31828pub static mut ZINTERCARD_Args: [redisCommandArg; 4] = [
31829    {
31830        let mut init = redisCommandArg {
31831            name: b"numkeys\0" as *const u8 as *const libc::c_char,
31832            type_0: ARG_TYPE_INTEGER,
31833            key_spec_index: -(1 as libc::c_int),
31834            token: 0 as *const libc::c_char,
31835            summary: 0 as *const libc::c_char,
31836            since: 0 as *const libc::c_char,
31837            flags: 0 as libc::c_int,
31838            deprecated_since: 0 as *const libc::c_char,
31839            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31840            num_args: 0,
31841        };
31842        init
31843    },
31844    {
31845        let mut init = redisCommandArg {
31846            name: b"key\0" as *const u8 as *const libc::c_char,
31847            type_0: ARG_TYPE_KEY,
31848            key_spec_index: 0 as libc::c_int,
31849            token: 0 as *const libc::c_char,
31850            summary: 0 as *const libc::c_char,
31851            since: 0 as *const libc::c_char,
31852            flags: (1 as libc::c_int) << 1 as libc::c_int,
31853            deprecated_since: 0 as *const libc::c_char,
31854            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31855            num_args: 0,
31856        };
31857        init
31858    },
31859    {
31860        let mut init = redisCommandArg {
31861            name: b"limit\0" as *const u8 as *const libc::c_char,
31862            type_0: ARG_TYPE_INTEGER,
31863            key_spec_index: -(1 as libc::c_int),
31864            token: b"LIMIT\0" as *const u8 as *const libc::c_char,
31865            summary: 0 as *const libc::c_char,
31866            since: 0 as *const libc::c_char,
31867            flags: (1 as libc::c_int) << 0 as libc::c_int,
31868            deprecated_since: 0 as *const libc::c_char,
31869            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31870            num_args: 0,
31871        };
31872        init
31873    },
31874    {
31875        let mut init = redisCommandArg {
31876            name: 0 as *const libc::c_char,
31877            type_0: ARG_TYPE_STRING,
31878            key_spec_index: 0,
31879            token: 0 as *const libc::c_char,
31880            summary: 0 as *const libc::c_char,
31881            since: 0 as *const libc::c_char,
31882            flags: 0,
31883            deprecated_since: 0 as *const libc::c_char,
31884            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31885            num_args: 0,
31886        };
31887        init
31888    },
31889];
31890#[no_mangle]
31891pub static mut ZINTERSTORE_aggregate_Subargs: [redisCommandArg; 4] = [
31892    {
31893        let mut init = redisCommandArg {
31894            name: b"sum\0" as *const u8 as *const libc::c_char,
31895            type_0: ARG_TYPE_PURE_TOKEN,
31896            key_spec_index: -(1 as libc::c_int),
31897            token: b"SUM\0" as *const u8 as *const libc::c_char,
31898            summary: 0 as *const libc::c_char,
31899            since: 0 as *const libc::c_char,
31900            flags: 0 as libc::c_int,
31901            deprecated_since: 0 as *const libc::c_char,
31902            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31903            num_args: 0,
31904        };
31905        init
31906    },
31907    {
31908        let mut init = redisCommandArg {
31909            name: b"min\0" as *const u8 as *const libc::c_char,
31910            type_0: ARG_TYPE_PURE_TOKEN,
31911            key_spec_index: -(1 as libc::c_int),
31912            token: b"MIN\0" as *const u8 as *const libc::c_char,
31913            summary: 0 as *const libc::c_char,
31914            since: 0 as *const libc::c_char,
31915            flags: 0 as libc::c_int,
31916            deprecated_since: 0 as *const libc::c_char,
31917            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31918            num_args: 0,
31919        };
31920        init
31921    },
31922    {
31923        let mut init = redisCommandArg {
31924            name: b"max\0" as *const u8 as *const libc::c_char,
31925            type_0: ARG_TYPE_PURE_TOKEN,
31926            key_spec_index: -(1 as libc::c_int),
31927            token: b"MAX\0" as *const u8 as *const libc::c_char,
31928            summary: 0 as *const libc::c_char,
31929            since: 0 as *const libc::c_char,
31930            flags: 0 as libc::c_int,
31931            deprecated_since: 0 as *const libc::c_char,
31932            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31933            num_args: 0,
31934        };
31935        init
31936    },
31937    {
31938        let mut init = redisCommandArg {
31939            name: 0 as *const libc::c_char,
31940            type_0: ARG_TYPE_STRING,
31941            key_spec_index: 0,
31942            token: 0 as *const libc::c_char,
31943            summary: 0 as *const libc::c_char,
31944            since: 0 as *const libc::c_char,
31945            flags: 0,
31946            deprecated_since: 0 as *const libc::c_char,
31947            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31948            num_args: 0,
31949        };
31950        init
31951    },
31952];
31953#[no_mangle]
31954pub static mut ZINTERSTORE_Args: [redisCommandArg; 6] = unsafe {
31955    [
31956        {
31957            let mut init = redisCommandArg {
31958                name: b"destination\0" as *const u8 as *const libc::c_char,
31959                type_0: ARG_TYPE_KEY,
31960                key_spec_index: 0 as libc::c_int,
31961                token: 0 as *const libc::c_char,
31962                summary: 0 as *const libc::c_char,
31963                since: 0 as *const libc::c_char,
31964                flags: 0 as libc::c_int,
31965                deprecated_since: 0 as *const libc::c_char,
31966                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31967                num_args: 0,
31968            };
31969            init
31970        },
31971        {
31972            let mut init = redisCommandArg {
31973                name: b"numkeys\0" as *const u8 as *const libc::c_char,
31974                type_0: ARG_TYPE_INTEGER,
31975                key_spec_index: -(1 as libc::c_int),
31976                token: 0 as *const libc::c_char,
31977                summary: 0 as *const libc::c_char,
31978                since: 0 as *const libc::c_char,
31979                flags: 0 as libc::c_int,
31980                deprecated_since: 0 as *const libc::c_char,
31981                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31982                num_args: 0,
31983            };
31984            init
31985        },
31986        {
31987            let mut init = redisCommandArg {
31988                name: b"key\0" as *const u8 as *const libc::c_char,
31989                type_0: ARG_TYPE_KEY,
31990                key_spec_index: 1 as libc::c_int,
31991                token: 0 as *const libc::c_char,
31992                summary: 0 as *const libc::c_char,
31993                since: 0 as *const libc::c_char,
31994                flags: (1 as libc::c_int) << 1 as libc::c_int,
31995                deprecated_since: 0 as *const libc::c_char,
31996                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
31997                num_args: 0,
31998            };
31999            init
32000        },
32001        {
32002            let mut init = redisCommandArg {
32003                name: b"weight\0" as *const u8 as *const libc::c_char,
32004                type_0: ARG_TYPE_INTEGER,
32005                key_spec_index: -(1 as libc::c_int),
32006                token: b"WEIGHTS\0" as *const u8 as *const libc::c_char,
32007                summary: 0 as *const libc::c_char,
32008                since: 0 as *const libc::c_char,
32009                flags: (1 as libc::c_int) << 0 as libc::c_int
32010                    | (1 as libc::c_int) << 1 as libc::c_int,
32011                deprecated_since: 0 as *const libc::c_char,
32012                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32013                num_args: 0,
32014            };
32015            init
32016        },
32017        {
32018            let mut init = redisCommandArg {
32019                name: b"aggregate\0" as *const u8 as *const libc::c_char,
32020                type_0: ARG_TYPE_ONEOF,
32021                key_spec_index: -(1 as libc::c_int),
32022                token: b"AGGREGATE\0" as *const u8 as *const libc::c_char,
32023                summary: 0 as *const libc::c_char,
32024                since: 0 as *const libc::c_char,
32025                flags: (1 as libc::c_int) << 0 as libc::c_int,
32026                deprecated_since: 0 as *const libc::c_char,
32027                subargs: ZINTERSTORE_aggregate_Subargs.as_ptr() as *mut _,
32028                num_args: 0,
32029            };
32030            init
32031        },
32032        {
32033            let mut init = redisCommandArg {
32034                name: 0 as *const libc::c_char,
32035                type_0: ARG_TYPE_STRING,
32036                key_spec_index: 0,
32037                token: 0 as *const libc::c_char,
32038                summary: 0 as *const libc::c_char,
32039                since: 0 as *const libc::c_char,
32040                flags: 0,
32041                deprecated_since: 0 as *const libc::c_char,
32042                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32043                num_args: 0,
32044            };
32045            init
32046        },
32047    ]
32048};
32049#[no_mangle]
32050pub static mut ZLEXCOUNT_Args: [redisCommandArg; 4] = [
32051    {
32052        let mut init = redisCommandArg {
32053            name: b"key\0" as *const u8 as *const libc::c_char,
32054            type_0: ARG_TYPE_KEY,
32055            key_spec_index: 0 as libc::c_int,
32056            token: 0 as *const libc::c_char,
32057            summary: 0 as *const libc::c_char,
32058            since: 0 as *const libc::c_char,
32059            flags: 0 as libc::c_int,
32060            deprecated_since: 0 as *const libc::c_char,
32061            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32062            num_args: 0,
32063        };
32064        init
32065    },
32066    {
32067        let mut init = redisCommandArg {
32068            name: b"min\0" as *const u8 as *const libc::c_char,
32069            type_0: ARG_TYPE_STRING,
32070            key_spec_index: -(1 as libc::c_int),
32071            token: 0 as *const libc::c_char,
32072            summary: 0 as *const libc::c_char,
32073            since: 0 as *const libc::c_char,
32074            flags: 0 as libc::c_int,
32075            deprecated_since: 0 as *const libc::c_char,
32076            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32077            num_args: 0,
32078        };
32079        init
32080    },
32081    {
32082        let mut init = redisCommandArg {
32083            name: b"max\0" as *const u8 as *const libc::c_char,
32084            type_0: ARG_TYPE_STRING,
32085            key_spec_index: -(1 as libc::c_int),
32086            token: 0 as *const libc::c_char,
32087            summary: 0 as *const libc::c_char,
32088            since: 0 as *const libc::c_char,
32089            flags: 0 as libc::c_int,
32090            deprecated_since: 0 as *const libc::c_char,
32091            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32092            num_args: 0,
32093        };
32094        init
32095    },
32096    {
32097        let mut init = redisCommandArg {
32098            name: 0 as *const libc::c_char,
32099            type_0: ARG_TYPE_STRING,
32100            key_spec_index: 0,
32101            token: 0 as *const libc::c_char,
32102            summary: 0 as *const libc::c_char,
32103            since: 0 as *const libc::c_char,
32104            flags: 0,
32105            deprecated_since: 0 as *const libc::c_char,
32106            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32107            num_args: 0,
32108        };
32109        init
32110    },
32111];
32112#[no_mangle]
32113pub static mut ZMPOP_where_Subargs: [redisCommandArg; 3] = [
32114    {
32115        let mut init = redisCommandArg {
32116            name: b"min\0" as *const u8 as *const libc::c_char,
32117            type_0: ARG_TYPE_PURE_TOKEN,
32118            key_spec_index: -(1 as libc::c_int),
32119            token: b"MIN\0" as *const u8 as *const libc::c_char,
32120            summary: 0 as *const libc::c_char,
32121            since: 0 as *const libc::c_char,
32122            flags: 0 as libc::c_int,
32123            deprecated_since: 0 as *const libc::c_char,
32124            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32125            num_args: 0,
32126        };
32127        init
32128    },
32129    {
32130        let mut init = redisCommandArg {
32131            name: b"max\0" as *const u8 as *const libc::c_char,
32132            type_0: ARG_TYPE_PURE_TOKEN,
32133            key_spec_index: -(1 as libc::c_int),
32134            token: b"MAX\0" as *const u8 as *const libc::c_char,
32135            summary: 0 as *const libc::c_char,
32136            since: 0 as *const libc::c_char,
32137            flags: 0 as libc::c_int,
32138            deprecated_since: 0 as *const libc::c_char,
32139            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32140            num_args: 0,
32141        };
32142        init
32143    },
32144    {
32145        let mut init = redisCommandArg {
32146            name: 0 as *const libc::c_char,
32147            type_0: ARG_TYPE_STRING,
32148            key_spec_index: 0,
32149            token: 0 as *const libc::c_char,
32150            summary: 0 as *const libc::c_char,
32151            since: 0 as *const libc::c_char,
32152            flags: 0,
32153            deprecated_since: 0 as *const libc::c_char,
32154            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32155            num_args: 0,
32156        };
32157        init
32158    },
32159];
32160#[no_mangle]
32161pub static mut ZMPOP_Args: [redisCommandArg; 5] = unsafe {
32162    [
32163        {
32164            let mut init = redisCommandArg {
32165                name: b"numkeys\0" as *const u8 as *const libc::c_char,
32166                type_0: ARG_TYPE_INTEGER,
32167                key_spec_index: -(1 as libc::c_int),
32168                token: 0 as *const libc::c_char,
32169                summary: 0 as *const libc::c_char,
32170                since: 0 as *const libc::c_char,
32171                flags: 0 as libc::c_int,
32172                deprecated_since: 0 as *const libc::c_char,
32173                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32174                num_args: 0,
32175            };
32176            init
32177        },
32178        {
32179            let mut init = redisCommandArg {
32180                name: b"key\0" as *const u8 as *const libc::c_char,
32181                type_0: ARG_TYPE_KEY,
32182                key_spec_index: 0 as libc::c_int,
32183                token: 0 as *const libc::c_char,
32184                summary: 0 as *const libc::c_char,
32185                since: 0 as *const libc::c_char,
32186                flags: (1 as libc::c_int) << 1 as libc::c_int,
32187                deprecated_since: 0 as *const libc::c_char,
32188                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32189                num_args: 0,
32190            };
32191            init
32192        },
32193        {
32194            let mut init = redisCommandArg {
32195                name: b"where\0" as *const u8 as *const libc::c_char,
32196                type_0: ARG_TYPE_ONEOF,
32197                key_spec_index: -(1 as libc::c_int),
32198                token: 0 as *const libc::c_char,
32199                summary: 0 as *const libc::c_char,
32200                since: 0 as *const libc::c_char,
32201                flags: 0 as libc::c_int,
32202                deprecated_since: 0 as *const libc::c_char,
32203                subargs: ZMPOP_where_Subargs.as_ptr() as *mut _,
32204                num_args: 0,
32205            };
32206            init
32207        },
32208        {
32209            let mut init = redisCommandArg {
32210                name: b"count\0" as *const u8 as *const libc::c_char,
32211                type_0: ARG_TYPE_INTEGER,
32212                key_spec_index: -(1 as libc::c_int),
32213                token: b"COUNT\0" as *const u8 as *const libc::c_char,
32214                summary: 0 as *const libc::c_char,
32215                since: 0 as *const libc::c_char,
32216                flags: (1 as libc::c_int) << 0 as libc::c_int,
32217                deprecated_since: 0 as *const libc::c_char,
32218                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32219                num_args: 0,
32220            };
32221            init
32222        },
32223        {
32224            let mut init = redisCommandArg {
32225                name: 0 as *const libc::c_char,
32226                type_0: ARG_TYPE_STRING,
32227                key_spec_index: 0,
32228                token: 0 as *const libc::c_char,
32229                summary: 0 as *const libc::c_char,
32230                since: 0 as *const libc::c_char,
32231                flags: 0,
32232                deprecated_since: 0 as *const libc::c_char,
32233                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32234                num_args: 0,
32235            };
32236            init
32237        },
32238    ]
32239};
32240#[no_mangle]
32241pub static mut ZMSCORE_Args: [redisCommandArg; 3] = [
32242    {
32243        let mut init = redisCommandArg {
32244            name: b"key\0" as *const u8 as *const libc::c_char,
32245            type_0: ARG_TYPE_KEY,
32246            key_spec_index: 0 as libc::c_int,
32247            token: 0 as *const libc::c_char,
32248            summary: 0 as *const libc::c_char,
32249            since: 0 as *const libc::c_char,
32250            flags: 0 as libc::c_int,
32251            deprecated_since: 0 as *const libc::c_char,
32252            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32253            num_args: 0,
32254        };
32255        init
32256    },
32257    {
32258        let mut init = redisCommandArg {
32259            name: b"member\0" as *const u8 as *const libc::c_char,
32260            type_0: ARG_TYPE_STRING,
32261            key_spec_index: -(1 as libc::c_int),
32262            token: 0 as *const libc::c_char,
32263            summary: 0 as *const libc::c_char,
32264            since: 0 as *const libc::c_char,
32265            flags: (1 as libc::c_int) << 1 as libc::c_int,
32266            deprecated_since: 0 as *const libc::c_char,
32267            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32268            num_args: 0,
32269        };
32270        init
32271    },
32272    {
32273        let mut init = redisCommandArg {
32274            name: 0 as *const libc::c_char,
32275            type_0: ARG_TYPE_STRING,
32276            key_spec_index: 0,
32277            token: 0 as *const libc::c_char,
32278            summary: 0 as *const libc::c_char,
32279            since: 0 as *const libc::c_char,
32280            flags: 0,
32281            deprecated_since: 0 as *const libc::c_char,
32282            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32283            num_args: 0,
32284        };
32285        init
32286    },
32287];
32288#[no_mangle]
32289pub static mut ZPOPMAX_Args: [redisCommandArg; 3] = [
32290    {
32291        let mut init = redisCommandArg {
32292            name: b"key\0" as *const u8 as *const libc::c_char,
32293            type_0: ARG_TYPE_KEY,
32294            key_spec_index: 0 as libc::c_int,
32295            token: 0 as *const libc::c_char,
32296            summary: 0 as *const libc::c_char,
32297            since: 0 as *const libc::c_char,
32298            flags: 0 as libc::c_int,
32299            deprecated_since: 0 as *const libc::c_char,
32300            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32301            num_args: 0,
32302        };
32303        init
32304    },
32305    {
32306        let mut init = redisCommandArg {
32307            name: b"count\0" as *const u8 as *const libc::c_char,
32308            type_0: ARG_TYPE_INTEGER,
32309            key_spec_index: -(1 as libc::c_int),
32310            token: 0 as *const libc::c_char,
32311            summary: 0 as *const libc::c_char,
32312            since: 0 as *const libc::c_char,
32313            flags: (1 as libc::c_int) << 0 as libc::c_int,
32314            deprecated_since: 0 as *const libc::c_char,
32315            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32316            num_args: 0,
32317        };
32318        init
32319    },
32320    {
32321        let mut init = redisCommandArg {
32322            name: 0 as *const libc::c_char,
32323            type_0: ARG_TYPE_STRING,
32324            key_spec_index: 0,
32325            token: 0 as *const libc::c_char,
32326            summary: 0 as *const libc::c_char,
32327            since: 0 as *const libc::c_char,
32328            flags: 0,
32329            deprecated_since: 0 as *const libc::c_char,
32330            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32331            num_args: 0,
32332        };
32333        init
32334    },
32335];
32336#[no_mangle]
32337pub static mut ZPOPMIN_Args: [redisCommandArg; 3] = [
32338    {
32339        let mut init = redisCommandArg {
32340            name: b"key\0" as *const u8 as *const libc::c_char,
32341            type_0: ARG_TYPE_KEY,
32342            key_spec_index: 0 as libc::c_int,
32343            token: 0 as *const libc::c_char,
32344            summary: 0 as *const libc::c_char,
32345            since: 0 as *const libc::c_char,
32346            flags: 0 as libc::c_int,
32347            deprecated_since: 0 as *const libc::c_char,
32348            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32349            num_args: 0,
32350        };
32351        init
32352    },
32353    {
32354        let mut init = redisCommandArg {
32355            name: b"count\0" as *const u8 as *const libc::c_char,
32356            type_0: ARG_TYPE_INTEGER,
32357            key_spec_index: -(1 as libc::c_int),
32358            token: 0 as *const libc::c_char,
32359            summary: 0 as *const libc::c_char,
32360            since: 0 as *const libc::c_char,
32361            flags: (1 as libc::c_int) << 0 as libc::c_int,
32362            deprecated_since: 0 as *const libc::c_char,
32363            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32364            num_args: 0,
32365        };
32366        init
32367    },
32368    {
32369        let mut init = redisCommandArg {
32370            name: 0 as *const libc::c_char,
32371            type_0: ARG_TYPE_STRING,
32372            key_spec_index: 0,
32373            token: 0 as *const libc::c_char,
32374            summary: 0 as *const libc::c_char,
32375            since: 0 as *const libc::c_char,
32376            flags: 0,
32377            deprecated_since: 0 as *const libc::c_char,
32378            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32379            num_args: 0,
32380        };
32381        init
32382    },
32383];
32384#[no_mangle]
32385pub static mut ZRANDMEMBER_tips: [*const libc::c_char; 2] = [
32386    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
32387    0 as *const libc::c_char,
32388];
32389#[no_mangle]
32390pub static mut ZRANDMEMBER_options_Subargs: [redisCommandArg; 3] = [
32391    {
32392        let mut init = redisCommandArg {
32393            name: b"count\0" as *const u8 as *const libc::c_char,
32394            type_0: ARG_TYPE_INTEGER,
32395            key_spec_index: -(1 as libc::c_int),
32396            token: 0 as *const libc::c_char,
32397            summary: 0 as *const libc::c_char,
32398            since: 0 as *const libc::c_char,
32399            flags: 0 as libc::c_int,
32400            deprecated_since: 0 as *const libc::c_char,
32401            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32402            num_args: 0,
32403        };
32404        init
32405    },
32406    {
32407        let mut init = redisCommandArg {
32408            name: b"withscores\0" as *const u8 as *const libc::c_char,
32409            type_0: ARG_TYPE_PURE_TOKEN,
32410            key_spec_index: -(1 as libc::c_int),
32411            token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
32412            summary: 0 as *const libc::c_char,
32413            since: 0 as *const libc::c_char,
32414            flags: (1 as libc::c_int) << 0 as libc::c_int,
32415            deprecated_since: 0 as *const libc::c_char,
32416            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32417            num_args: 0,
32418        };
32419        init
32420    },
32421    {
32422        let mut init = redisCommandArg {
32423            name: 0 as *const libc::c_char,
32424            type_0: ARG_TYPE_STRING,
32425            key_spec_index: 0,
32426            token: 0 as *const libc::c_char,
32427            summary: 0 as *const libc::c_char,
32428            since: 0 as *const libc::c_char,
32429            flags: 0,
32430            deprecated_since: 0 as *const libc::c_char,
32431            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32432            num_args: 0,
32433        };
32434        init
32435    },
32436];
32437#[no_mangle]
32438pub static mut ZRANDMEMBER_Args: [redisCommandArg; 3] = unsafe {
32439    [
32440        {
32441            let mut init = redisCommandArg {
32442                name: b"key\0" as *const u8 as *const libc::c_char,
32443                type_0: ARG_TYPE_KEY,
32444                key_spec_index: 0 as libc::c_int,
32445                token: 0 as *const libc::c_char,
32446                summary: 0 as *const libc::c_char,
32447                since: 0 as *const libc::c_char,
32448                flags: 0 as libc::c_int,
32449                deprecated_since: 0 as *const libc::c_char,
32450                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32451                num_args: 0,
32452            };
32453            init
32454        },
32455        {
32456            let mut init = redisCommandArg {
32457                name: b"options\0" as *const u8 as *const libc::c_char,
32458                type_0: ARG_TYPE_BLOCK,
32459                key_spec_index: -(1 as libc::c_int),
32460                token: 0 as *const libc::c_char,
32461                summary: 0 as *const libc::c_char,
32462                since: 0 as *const libc::c_char,
32463                flags: (1 as libc::c_int) << 0 as libc::c_int,
32464                deprecated_since: 0 as *const libc::c_char,
32465                subargs: ZRANDMEMBER_options_Subargs.as_ptr() as *mut _,
32466                num_args: 0,
32467            };
32468            init
32469        },
32470        {
32471            let mut init = redisCommandArg {
32472                name: 0 as *const libc::c_char,
32473                type_0: ARG_TYPE_STRING,
32474                key_spec_index: 0,
32475                token: 0 as *const libc::c_char,
32476                summary: 0 as *const libc::c_char,
32477                since: 0 as *const libc::c_char,
32478                flags: 0,
32479                deprecated_since: 0 as *const libc::c_char,
32480                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32481                num_args: 0,
32482            };
32483            init
32484        },
32485    ]
32486};
32487#[no_mangle]
32488pub static mut ZRANGE_History: [commandHistory; 2] = [
32489    {
32490        let mut init = commandHistory {
32491            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
32492            changes: b"Added the `REV`, `BYSCORE`, `BYLEX` and `LIMIT` options.\0"
32493                as *const u8 as *const libc::c_char,
32494        };
32495        init
32496    },
32497    {
32498        let mut init = commandHistory {
32499            since: 0 as *const libc::c_char,
32500            changes: 0 as *const libc::c_char,
32501        };
32502        init
32503    },
32504];
32505#[no_mangle]
32506pub static mut ZRANGE_sortby_Subargs: [redisCommandArg; 3] = [
32507    {
32508        let mut init = redisCommandArg {
32509            name: b"byscore\0" as *const u8 as *const libc::c_char,
32510            type_0: ARG_TYPE_PURE_TOKEN,
32511            key_spec_index: -(1 as libc::c_int),
32512            token: b"BYSCORE\0" as *const u8 as *const libc::c_char,
32513            summary: 0 as *const libc::c_char,
32514            since: 0 as *const libc::c_char,
32515            flags: 0 as libc::c_int,
32516            deprecated_since: 0 as *const libc::c_char,
32517            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32518            num_args: 0,
32519        };
32520        init
32521    },
32522    {
32523        let mut init = redisCommandArg {
32524            name: b"bylex\0" as *const u8 as *const libc::c_char,
32525            type_0: ARG_TYPE_PURE_TOKEN,
32526            key_spec_index: -(1 as libc::c_int),
32527            token: b"BYLEX\0" as *const u8 as *const libc::c_char,
32528            summary: 0 as *const libc::c_char,
32529            since: 0 as *const libc::c_char,
32530            flags: 0 as libc::c_int,
32531            deprecated_since: 0 as *const libc::c_char,
32532            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32533            num_args: 0,
32534        };
32535        init
32536    },
32537    {
32538        let mut init = redisCommandArg {
32539            name: 0 as *const libc::c_char,
32540            type_0: ARG_TYPE_STRING,
32541            key_spec_index: 0,
32542            token: 0 as *const libc::c_char,
32543            summary: 0 as *const libc::c_char,
32544            since: 0 as *const libc::c_char,
32545            flags: 0,
32546            deprecated_since: 0 as *const libc::c_char,
32547            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32548            num_args: 0,
32549        };
32550        init
32551    },
32552];
32553#[no_mangle]
32554pub static mut ZRANGE_offset_count_Subargs: [redisCommandArg; 3] = [
32555    {
32556        let mut init = redisCommandArg {
32557            name: b"offset\0" as *const u8 as *const libc::c_char,
32558            type_0: ARG_TYPE_INTEGER,
32559            key_spec_index: -(1 as libc::c_int),
32560            token: 0 as *const libc::c_char,
32561            summary: 0 as *const libc::c_char,
32562            since: 0 as *const libc::c_char,
32563            flags: 0 as libc::c_int,
32564            deprecated_since: 0 as *const libc::c_char,
32565            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32566            num_args: 0,
32567        };
32568        init
32569    },
32570    {
32571        let mut init = redisCommandArg {
32572            name: b"count\0" as *const u8 as *const libc::c_char,
32573            type_0: ARG_TYPE_INTEGER,
32574            key_spec_index: -(1 as libc::c_int),
32575            token: 0 as *const libc::c_char,
32576            summary: 0 as *const libc::c_char,
32577            since: 0 as *const libc::c_char,
32578            flags: 0 as libc::c_int,
32579            deprecated_since: 0 as *const libc::c_char,
32580            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32581            num_args: 0,
32582        };
32583        init
32584    },
32585    {
32586        let mut init = redisCommandArg {
32587            name: 0 as *const libc::c_char,
32588            type_0: ARG_TYPE_STRING,
32589            key_spec_index: 0,
32590            token: 0 as *const libc::c_char,
32591            summary: 0 as *const libc::c_char,
32592            since: 0 as *const libc::c_char,
32593            flags: 0,
32594            deprecated_since: 0 as *const libc::c_char,
32595            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32596            num_args: 0,
32597        };
32598        init
32599    },
32600];
32601#[no_mangle]
32602pub static mut ZRANGE_Args: [redisCommandArg; 8] = unsafe {
32603    [
32604        {
32605            let mut init = redisCommandArg {
32606                name: b"key\0" as *const u8 as *const libc::c_char,
32607                type_0: ARG_TYPE_KEY,
32608                key_spec_index: 0 as libc::c_int,
32609                token: 0 as *const libc::c_char,
32610                summary: 0 as *const libc::c_char,
32611                since: 0 as *const libc::c_char,
32612                flags: 0 as libc::c_int,
32613                deprecated_since: 0 as *const libc::c_char,
32614                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32615                num_args: 0,
32616            };
32617            init
32618        },
32619        {
32620            let mut init = redisCommandArg {
32621                name: b"start\0" as *const u8 as *const libc::c_char,
32622                type_0: ARG_TYPE_STRING,
32623                key_spec_index: -(1 as libc::c_int),
32624                token: 0 as *const libc::c_char,
32625                summary: 0 as *const libc::c_char,
32626                since: 0 as *const libc::c_char,
32627                flags: 0 as libc::c_int,
32628                deprecated_since: 0 as *const libc::c_char,
32629                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32630                num_args: 0,
32631            };
32632            init
32633        },
32634        {
32635            let mut init = redisCommandArg {
32636                name: b"stop\0" as *const u8 as *const libc::c_char,
32637                type_0: ARG_TYPE_STRING,
32638                key_spec_index: -(1 as libc::c_int),
32639                token: 0 as *const libc::c_char,
32640                summary: 0 as *const libc::c_char,
32641                since: 0 as *const libc::c_char,
32642                flags: 0 as libc::c_int,
32643                deprecated_since: 0 as *const libc::c_char,
32644                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32645                num_args: 0,
32646            };
32647            init
32648        },
32649        {
32650            let mut init = redisCommandArg {
32651                name: b"sortby\0" as *const u8 as *const libc::c_char,
32652                type_0: ARG_TYPE_ONEOF,
32653                key_spec_index: -(1 as libc::c_int),
32654                token: 0 as *const libc::c_char,
32655                summary: 0 as *const libc::c_char,
32656                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
32657                flags: (1 as libc::c_int) << 0 as libc::c_int,
32658                deprecated_since: 0 as *const libc::c_char,
32659                subargs: ZRANGE_sortby_Subargs.as_ptr() as *mut _,
32660                num_args: 0,
32661            };
32662            init
32663        },
32664        {
32665            let mut init = redisCommandArg {
32666                name: b"rev\0" as *const u8 as *const libc::c_char,
32667                type_0: ARG_TYPE_PURE_TOKEN,
32668                key_spec_index: -(1 as libc::c_int),
32669                token: b"REV\0" as *const u8 as *const libc::c_char,
32670                summary: 0 as *const libc::c_char,
32671                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
32672                flags: (1 as libc::c_int) << 0 as libc::c_int,
32673                deprecated_since: 0 as *const libc::c_char,
32674                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32675                num_args: 0,
32676            };
32677            init
32678        },
32679        {
32680            let mut init = redisCommandArg {
32681                name: b"offset_count\0" as *const u8 as *const libc::c_char,
32682                type_0: ARG_TYPE_BLOCK,
32683                key_spec_index: -(1 as libc::c_int),
32684                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
32685                summary: 0 as *const libc::c_char,
32686                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
32687                flags: (1 as libc::c_int) << 0 as libc::c_int,
32688                deprecated_since: 0 as *const libc::c_char,
32689                subargs: ZRANGE_offset_count_Subargs.as_ptr() as *mut _,
32690                num_args: 0,
32691            };
32692            init
32693        },
32694        {
32695            let mut init = redisCommandArg {
32696                name: b"withscores\0" as *const u8 as *const libc::c_char,
32697                type_0: ARG_TYPE_PURE_TOKEN,
32698                key_spec_index: -(1 as libc::c_int),
32699                token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
32700                summary: 0 as *const libc::c_char,
32701                since: 0 as *const libc::c_char,
32702                flags: (1 as libc::c_int) << 0 as libc::c_int,
32703                deprecated_since: 0 as *const libc::c_char,
32704                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32705                num_args: 0,
32706            };
32707            init
32708        },
32709        {
32710            let mut init = redisCommandArg {
32711                name: 0 as *const libc::c_char,
32712                type_0: ARG_TYPE_STRING,
32713                key_spec_index: 0,
32714                token: 0 as *const libc::c_char,
32715                summary: 0 as *const libc::c_char,
32716                since: 0 as *const libc::c_char,
32717                flags: 0,
32718                deprecated_since: 0 as *const libc::c_char,
32719                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32720                num_args: 0,
32721            };
32722            init
32723        },
32724    ]
32725};
32726#[no_mangle]
32727pub static mut ZRANGEBYLEX_offset_count_Subargs: [redisCommandArg; 3] = [
32728    {
32729        let mut init = redisCommandArg {
32730            name: b"offset\0" as *const u8 as *const libc::c_char,
32731            type_0: ARG_TYPE_INTEGER,
32732            key_spec_index: -(1 as libc::c_int),
32733            token: 0 as *const libc::c_char,
32734            summary: 0 as *const libc::c_char,
32735            since: 0 as *const libc::c_char,
32736            flags: 0 as libc::c_int,
32737            deprecated_since: 0 as *const libc::c_char,
32738            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32739            num_args: 0,
32740        };
32741        init
32742    },
32743    {
32744        let mut init = redisCommandArg {
32745            name: b"count\0" as *const u8 as *const libc::c_char,
32746            type_0: ARG_TYPE_INTEGER,
32747            key_spec_index: -(1 as libc::c_int),
32748            token: 0 as *const libc::c_char,
32749            summary: 0 as *const libc::c_char,
32750            since: 0 as *const libc::c_char,
32751            flags: 0 as libc::c_int,
32752            deprecated_since: 0 as *const libc::c_char,
32753            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32754            num_args: 0,
32755        };
32756        init
32757    },
32758    {
32759        let mut init = redisCommandArg {
32760            name: 0 as *const libc::c_char,
32761            type_0: ARG_TYPE_STRING,
32762            key_spec_index: 0,
32763            token: 0 as *const libc::c_char,
32764            summary: 0 as *const libc::c_char,
32765            since: 0 as *const libc::c_char,
32766            flags: 0,
32767            deprecated_since: 0 as *const libc::c_char,
32768            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32769            num_args: 0,
32770        };
32771        init
32772    },
32773];
32774#[no_mangle]
32775pub static mut ZRANGEBYLEX_Args: [redisCommandArg; 5] = unsafe {
32776    [
32777        {
32778            let mut init = redisCommandArg {
32779                name: b"key\0" as *const u8 as *const libc::c_char,
32780                type_0: ARG_TYPE_KEY,
32781                key_spec_index: 0 as libc::c_int,
32782                token: 0 as *const libc::c_char,
32783                summary: 0 as *const libc::c_char,
32784                since: 0 as *const libc::c_char,
32785                flags: 0 as libc::c_int,
32786                deprecated_since: 0 as *const libc::c_char,
32787                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32788                num_args: 0,
32789            };
32790            init
32791        },
32792        {
32793            let mut init = redisCommandArg {
32794                name: b"min\0" as *const u8 as *const libc::c_char,
32795                type_0: ARG_TYPE_STRING,
32796                key_spec_index: -(1 as libc::c_int),
32797                token: 0 as *const libc::c_char,
32798                summary: 0 as *const libc::c_char,
32799                since: 0 as *const libc::c_char,
32800                flags: 0 as libc::c_int,
32801                deprecated_since: 0 as *const libc::c_char,
32802                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32803                num_args: 0,
32804            };
32805            init
32806        },
32807        {
32808            let mut init = redisCommandArg {
32809                name: b"max\0" as *const u8 as *const libc::c_char,
32810                type_0: ARG_TYPE_STRING,
32811                key_spec_index: -(1 as libc::c_int),
32812                token: 0 as *const libc::c_char,
32813                summary: 0 as *const libc::c_char,
32814                since: 0 as *const libc::c_char,
32815                flags: 0 as libc::c_int,
32816                deprecated_since: 0 as *const libc::c_char,
32817                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32818                num_args: 0,
32819            };
32820            init
32821        },
32822        {
32823            let mut init = redisCommandArg {
32824                name: b"offset_count\0" as *const u8 as *const libc::c_char,
32825                type_0: ARG_TYPE_BLOCK,
32826                key_spec_index: -(1 as libc::c_int),
32827                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
32828                summary: 0 as *const libc::c_char,
32829                since: 0 as *const libc::c_char,
32830                flags: (1 as libc::c_int) << 0 as libc::c_int,
32831                deprecated_since: 0 as *const libc::c_char,
32832                subargs: ZRANGEBYLEX_offset_count_Subargs.as_ptr() as *mut _,
32833                num_args: 0,
32834            };
32835            init
32836        },
32837        {
32838            let mut init = redisCommandArg {
32839                name: 0 as *const libc::c_char,
32840                type_0: ARG_TYPE_STRING,
32841                key_spec_index: 0,
32842                token: 0 as *const libc::c_char,
32843                summary: 0 as *const libc::c_char,
32844                since: 0 as *const libc::c_char,
32845                flags: 0,
32846                deprecated_since: 0 as *const libc::c_char,
32847                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32848                num_args: 0,
32849            };
32850            init
32851        },
32852    ]
32853};
32854#[no_mangle]
32855pub static mut ZRANGEBYSCORE_History: [commandHistory; 2] = [
32856    {
32857        let mut init = commandHistory {
32858            since: b"2.0.0\0" as *const u8 as *const libc::c_char,
32859            changes: b"Added the `WITHSCORES` modifier.\0" as *const u8
32860                as *const libc::c_char,
32861        };
32862        init
32863    },
32864    {
32865        let mut init = commandHistory {
32866            since: 0 as *const libc::c_char,
32867            changes: 0 as *const libc::c_char,
32868        };
32869        init
32870    },
32871];
32872#[no_mangle]
32873pub static mut ZRANGEBYSCORE_offset_count_Subargs: [redisCommandArg; 3] = [
32874    {
32875        let mut init = redisCommandArg {
32876            name: b"offset\0" as *const u8 as *const libc::c_char,
32877            type_0: ARG_TYPE_INTEGER,
32878            key_spec_index: -(1 as libc::c_int),
32879            token: 0 as *const libc::c_char,
32880            summary: 0 as *const libc::c_char,
32881            since: 0 as *const libc::c_char,
32882            flags: 0 as libc::c_int,
32883            deprecated_since: 0 as *const libc::c_char,
32884            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32885            num_args: 0,
32886        };
32887        init
32888    },
32889    {
32890        let mut init = redisCommandArg {
32891            name: b"count\0" as *const u8 as *const libc::c_char,
32892            type_0: ARG_TYPE_INTEGER,
32893            key_spec_index: -(1 as libc::c_int),
32894            token: 0 as *const libc::c_char,
32895            summary: 0 as *const libc::c_char,
32896            since: 0 as *const libc::c_char,
32897            flags: 0 as libc::c_int,
32898            deprecated_since: 0 as *const libc::c_char,
32899            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32900            num_args: 0,
32901        };
32902        init
32903    },
32904    {
32905        let mut init = redisCommandArg {
32906            name: 0 as *const libc::c_char,
32907            type_0: ARG_TYPE_STRING,
32908            key_spec_index: 0,
32909            token: 0 as *const libc::c_char,
32910            summary: 0 as *const libc::c_char,
32911            since: 0 as *const libc::c_char,
32912            flags: 0,
32913            deprecated_since: 0 as *const libc::c_char,
32914            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32915            num_args: 0,
32916        };
32917        init
32918    },
32919];
32920#[no_mangle]
32921pub static mut ZRANGEBYSCORE_Args: [redisCommandArg; 6] = unsafe {
32922    [
32923        {
32924            let mut init = redisCommandArg {
32925                name: b"key\0" as *const u8 as *const libc::c_char,
32926                type_0: ARG_TYPE_KEY,
32927                key_spec_index: 0 as libc::c_int,
32928                token: 0 as *const libc::c_char,
32929                summary: 0 as *const libc::c_char,
32930                since: 0 as *const libc::c_char,
32931                flags: 0 as libc::c_int,
32932                deprecated_since: 0 as *const libc::c_char,
32933                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32934                num_args: 0,
32935            };
32936            init
32937        },
32938        {
32939            let mut init = redisCommandArg {
32940                name: b"min\0" as *const u8 as *const libc::c_char,
32941                type_0: ARG_TYPE_DOUBLE,
32942                key_spec_index: -(1 as libc::c_int),
32943                token: 0 as *const libc::c_char,
32944                summary: 0 as *const libc::c_char,
32945                since: 0 as *const libc::c_char,
32946                flags: 0 as libc::c_int,
32947                deprecated_since: 0 as *const libc::c_char,
32948                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32949                num_args: 0,
32950            };
32951            init
32952        },
32953        {
32954            let mut init = redisCommandArg {
32955                name: b"max\0" as *const u8 as *const libc::c_char,
32956                type_0: ARG_TYPE_DOUBLE,
32957                key_spec_index: -(1 as libc::c_int),
32958                token: 0 as *const libc::c_char,
32959                summary: 0 as *const libc::c_char,
32960                since: 0 as *const libc::c_char,
32961                flags: 0 as libc::c_int,
32962                deprecated_since: 0 as *const libc::c_char,
32963                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32964                num_args: 0,
32965            };
32966            init
32967        },
32968        {
32969            let mut init = redisCommandArg {
32970                name: b"withscores\0" as *const u8 as *const libc::c_char,
32971                type_0: ARG_TYPE_PURE_TOKEN,
32972                key_spec_index: -(1 as libc::c_int),
32973                token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
32974                summary: 0 as *const libc::c_char,
32975                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
32976                flags: (1 as libc::c_int) << 0 as libc::c_int,
32977                deprecated_since: 0 as *const libc::c_char,
32978                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
32979                num_args: 0,
32980            };
32981            init
32982        },
32983        {
32984            let mut init = redisCommandArg {
32985                name: b"offset_count\0" as *const u8 as *const libc::c_char,
32986                type_0: ARG_TYPE_BLOCK,
32987                key_spec_index: -(1 as libc::c_int),
32988                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
32989                summary: 0 as *const libc::c_char,
32990                since: 0 as *const libc::c_char,
32991                flags: (1 as libc::c_int) << 0 as libc::c_int,
32992                deprecated_since: 0 as *const libc::c_char,
32993                subargs: ZRANGEBYSCORE_offset_count_Subargs.as_ptr() as *mut _,
32994                num_args: 0,
32995            };
32996            init
32997        },
32998        {
32999            let mut init = redisCommandArg {
33000                name: 0 as *const libc::c_char,
33001                type_0: ARG_TYPE_STRING,
33002                key_spec_index: 0,
33003                token: 0 as *const libc::c_char,
33004                summary: 0 as *const libc::c_char,
33005                since: 0 as *const libc::c_char,
33006                flags: 0,
33007                deprecated_since: 0 as *const libc::c_char,
33008                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33009                num_args: 0,
33010            };
33011            init
33012        },
33013    ]
33014};
33015#[no_mangle]
33016pub static mut ZRANGESTORE_sortby_Subargs: [redisCommandArg; 3] = [
33017    {
33018        let mut init = redisCommandArg {
33019            name: b"byscore\0" as *const u8 as *const libc::c_char,
33020            type_0: ARG_TYPE_PURE_TOKEN,
33021            key_spec_index: -(1 as libc::c_int),
33022            token: b"BYSCORE\0" as *const u8 as *const libc::c_char,
33023            summary: 0 as *const libc::c_char,
33024            since: 0 as *const libc::c_char,
33025            flags: 0 as libc::c_int,
33026            deprecated_since: 0 as *const libc::c_char,
33027            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33028            num_args: 0,
33029        };
33030        init
33031    },
33032    {
33033        let mut init = redisCommandArg {
33034            name: b"bylex\0" as *const u8 as *const libc::c_char,
33035            type_0: ARG_TYPE_PURE_TOKEN,
33036            key_spec_index: -(1 as libc::c_int),
33037            token: b"BYLEX\0" as *const u8 as *const libc::c_char,
33038            summary: 0 as *const libc::c_char,
33039            since: 0 as *const libc::c_char,
33040            flags: 0 as libc::c_int,
33041            deprecated_since: 0 as *const libc::c_char,
33042            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33043            num_args: 0,
33044        };
33045        init
33046    },
33047    {
33048        let mut init = redisCommandArg {
33049            name: 0 as *const libc::c_char,
33050            type_0: ARG_TYPE_STRING,
33051            key_spec_index: 0,
33052            token: 0 as *const libc::c_char,
33053            summary: 0 as *const libc::c_char,
33054            since: 0 as *const libc::c_char,
33055            flags: 0,
33056            deprecated_since: 0 as *const libc::c_char,
33057            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33058            num_args: 0,
33059        };
33060        init
33061    },
33062];
33063#[no_mangle]
33064pub static mut ZRANGESTORE_offset_count_Subargs: [redisCommandArg; 3] = [
33065    {
33066        let mut init = redisCommandArg {
33067            name: b"offset\0" as *const u8 as *const libc::c_char,
33068            type_0: ARG_TYPE_INTEGER,
33069            key_spec_index: -(1 as libc::c_int),
33070            token: 0 as *const libc::c_char,
33071            summary: 0 as *const libc::c_char,
33072            since: 0 as *const libc::c_char,
33073            flags: 0 as libc::c_int,
33074            deprecated_since: 0 as *const libc::c_char,
33075            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33076            num_args: 0,
33077        };
33078        init
33079    },
33080    {
33081        let mut init = redisCommandArg {
33082            name: b"count\0" as *const u8 as *const libc::c_char,
33083            type_0: ARG_TYPE_INTEGER,
33084            key_spec_index: -(1 as libc::c_int),
33085            token: 0 as *const libc::c_char,
33086            summary: 0 as *const libc::c_char,
33087            since: 0 as *const libc::c_char,
33088            flags: 0 as libc::c_int,
33089            deprecated_since: 0 as *const libc::c_char,
33090            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33091            num_args: 0,
33092        };
33093        init
33094    },
33095    {
33096        let mut init = redisCommandArg {
33097            name: 0 as *const libc::c_char,
33098            type_0: ARG_TYPE_STRING,
33099            key_spec_index: 0,
33100            token: 0 as *const libc::c_char,
33101            summary: 0 as *const libc::c_char,
33102            since: 0 as *const libc::c_char,
33103            flags: 0,
33104            deprecated_since: 0 as *const libc::c_char,
33105            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33106            num_args: 0,
33107        };
33108        init
33109    },
33110];
33111#[no_mangle]
33112pub static mut ZRANGESTORE_Args: [redisCommandArg; 8] = unsafe {
33113    [
33114        {
33115            let mut init = redisCommandArg {
33116                name: b"dst\0" as *const u8 as *const libc::c_char,
33117                type_0: ARG_TYPE_KEY,
33118                key_spec_index: 0 as libc::c_int,
33119                token: 0 as *const libc::c_char,
33120                summary: 0 as *const libc::c_char,
33121                since: 0 as *const libc::c_char,
33122                flags: 0 as libc::c_int,
33123                deprecated_since: 0 as *const libc::c_char,
33124                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33125                num_args: 0,
33126            };
33127            init
33128        },
33129        {
33130            let mut init = redisCommandArg {
33131                name: b"src\0" as *const u8 as *const libc::c_char,
33132                type_0: ARG_TYPE_KEY,
33133                key_spec_index: 1 as libc::c_int,
33134                token: 0 as *const libc::c_char,
33135                summary: 0 as *const libc::c_char,
33136                since: 0 as *const libc::c_char,
33137                flags: 0 as libc::c_int,
33138                deprecated_since: 0 as *const libc::c_char,
33139                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33140                num_args: 0,
33141            };
33142            init
33143        },
33144        {
33145            let mut init = redisCommandArg {
33146                name: b"min\0" as *const u8 as *const libc::c_char,
33147                type_0: ARG_TYPE_STRING,
33148                key_spec_index: -(1 as libc::c_int),
33149                token: 0 as *const libc::c_char,
33150                summary: 0 as *const libc::c_char,
33151                since: 0 as *const libc::c_char,
33152                flags: 0 as libc::c_int,
33153                deprecated_since: 0 as *const libc::c_char,
33154                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33155                num_args: 0,
33156            };
33157            init
33158        },
33159        {
33160            let mut init = redisCommandArg {
33161                name: b"max\0" as *const u8 as *const libc::c_char,
33162                type_0: ARG_TYPE_STRING,
33163                key_spec_index: -(1 as libc::c_int),
33164                token: 0 as *const libc::c_char,
33165                summary: 0 as *const libc::c_char,
33166                since: 0 as *const libc::c_char,
33167                flags: 0 as libc::c_int,
33168                deprecated_since: 0 as *const libc::c_char,
33169                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33170                num_args: 0,
33171            };
33172            init
33173        },
33174        {
33175            let mut init = redisCommandArg {
33176                name: b"sortby\0" as *const u8 as *const libc::c_char,
33177                type_0: ARG_TYPE_ONEOF,
33178                key_spec_index: -(1 as libc::c_int),
33179                token: 0 as *const libc::c_char,
33180                summary: 0 as *const libc::c_char,
33181                since: 0 as *const libc::c_char,
33182                flags: (1 as libc::c_int) << 0 as libc::c_int,
33183                deprecated_since: 0 as *const libc::c_char,
33184                subargs: ZRANGESTORE_sortby_Subargs.as_ptr() as *mut _,
33185                num_args: 0,
33186            };
33187            init
33188        },
33189        {
33190            let mut init = redisCommandArg {
33191                name: b"rev\0" as *const u8 as *const libc::c_char,
33192                type_0: ARG_TYPE_PURE_TOKEN,
33193                key_spec_index: -(1 as libc::c_int),
33194                token: b"REV\0" as *const u8 as *const libc::c_char,
33195                summary: 0 as *const libc::c_char,
33196                since: 0 as *const libc::c_char,
33197                flags: (1 as libc::c_int) << 0 as libc::c_int,
33198                deprecated_since: 0 as *const libc::c_char,
33199                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33200                num_args: 0,
33201            };
33202            init
33203        },
33204        {
33205            let mut init = redisCommandArg {
33206                name: b"offset_count\0" as *const u8 as *const libc::c_char,
33207                type_0: ARG_TYPE_BLOCK,
33208                key_spec_index: -(1 as libc::c_int),
33209                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
33210                summary: 0 as *const libc::c_char,
33211                since: 0 as *const libc::c_char,
33212                flags: (1 as libc::c_int) << 0 as libc::c_int,
33213                deprecated_since: 0 as *const libc::c_char,
33214                subargs: ZRANGESTORE_offset_count_Subargs.as_ptr() as *mut _,
33215                num_args: 0,
33216            };
33217            init
33218        },
33219        {
33220            let mut init = redisCommandArg {
33221                name: 0 as *const libc::c_char,
33222                type_0: ARG_TYPE_STRING,
33223                key_spec_index: 0,
33224                token: 0 as *const libc::c_char,
33225                summary: 0 as *const libc::c_char,
33226                since: 0 as *const libc::c_char,
33227                flags: 0,
33228                deprecated_since: 0 as *const libc::c_char,
33229                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33230                num_args: 0,
33231            };
33232            init
33233        },
33234    ]
33235};
33236#[no_mangle]
33237pub static mut ZRANK_Args: [redisCommandArg; 3] = [
33238    {
33239        let mut init = redisCommandArg {
33240            name: b"key\0" as *const u8 as *const libc::c_char,
33241            type_0: ARG_TYPE_KEY,
33242            key_spec_index: 0 as libc::c_int,
33243            token: 0 as *const libc::c_char,
33244            summary: 0 as *const libc::c_char,
33245            since: 0 as *const libc::c_char,
33246            flags: 0 as libc::c_int,
33247            deprecated_since: 0 as *const libc::c_char,
33248            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33249            num_args: 0,
33250        };
33251        init
33252    },
33253    {
33254        let mut init = redisCommandArg {
33255            name: b"member\0" as *const u8 as *const libc::c_char,
33256            type_0: ARG_TYPE_STRING,
33257            key_spec_index: -(1 as libc::c_int),
33258            token: 0 as *const libc::c_char,
33259            summary: 0 as *const libc::c_char,
33260            since: 0 as *const libc::c_char,
33261            flags: 0 as libc::c_int,
33262            deprecated_since: 0 as *const libc::c_char,
33263            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33264            num_args: 0,
33265        };
33266        init
33267    },
33268    {
33269        let mut init = redisCommandArg {
33270            name: 0 as *const libc::c_char,
33271            type_0: ARG_TYPE_STRING,
33272            key_spec_index: 0,
33273            token: 0 as *const libc::c_char,
33274            summary: 0 as *const libc::c_char,
33275            since: 0 as *const libc::c_char,
33276            flags: 0,
33277            deprecated_since: 0 as *const libc::c_char,
33278            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33279            num_args: 0,
33280        };
33281        init
33282    },
33283];
33284#[no_mangle]
33285pub static mut ZREM_History: [commandHistory; 2] = [
33286    {
33287        let mut init = commandHistory {
33288            since: b"2.4.0\0" as *const u8 as *const libc::c_char,
33289            changes: b"Accepts multiple elements.\0" as *const u8 as *const libc::c_char,
33290        };
33291        init
33292    },
33293    {
33294        let mut init = commandHistory {
33295            since: 0 as *const libc::c_char,
33296            changes: 0 as *const libc::c_char,
33297        };
33298        init
33299    },
33300];
33301#[no_mangle]
33302pub static mut ZREM_Args: [redisCommandArg; 3] = [
33303    {
33304        let mut init = redisCommandArg {
33305            name: b"key\0" as *const u8 as *const libc::c_char,
33306            type_0: ARG_TYPE_KEY,
33307            key_spec_index: 0 as libc::c_int,
33308            token: 0 as *const libc::c_char,
33309            summary: 0 as *const libc::c_char,
33310            since: 0 as *const libc::c_char,
33311            flags: 0 as libc::c_int,
33312            deprecated_since: 0 as *const libc::c_char,
33313            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33314            num_args: 0,
33315        };
33316        init
33317    },
33318    {
33319        let mut init = redisCommandArg {
33320            name: b"member\0" as *const u8 as *const libc::c_char,
33321            type_0: ARG_TYPE_STRING,
33322            key_spec_index: -(1 as libc::c_int),
33323            token: 0 as *const libc::c_char,
33324            summary: 0 as *const libc::c_char,
33325            since: 0 as *const libc::c_char,
33326            flags: (1 as libc::c_int) << 1 as libc::c_int,
33327            deprecated_since: 0 as *const libc::c_char,
33328            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33329            num_args: 0,
33330        };
33331        init
33332    },
33333    {
33334        let mut init = redisCommandArg {
33335            name: 0 as *const libc::c_char,
33336            type_0: ARG_TYPE_STRING,
33337            key_spec_index: 0,
33338            token: 0 as *const libc::c_char,
33339            summary: 0 as *const libc::c_char,
33340            since: 0 as *const libc::c_char,
33341            flags: 0,
33342            deprecated_since: 0 as *const libc::c_char,
33343            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33344            num_args: 0,
33345        };
33346        init
33347    },
33348];
33349#[no_mangle]
33350pub static mut ZREMRANGEBYLEX_Args: [redisCommandArg; 4] = [
33351    {
33352        let mut init = redisCommandArg {
33353            name: b"key\0" as *const u8 as *const libc::c_char,
33354            type_0: ARG_TYPE_KEY,
33355            key_spec_index: 0 as libc::c_int,
33356            token: 0 as *const libc::c_char,
33357            summary: 0 as *const libc::c_char,
33358            since: 0 as *const libc::c_char,
33359            flags: 0 as libc::c_int,
33360            deprecated_since: 0 as *const libc::c_char,
33361            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33362            num_args: 0,
33363        };
33364        init
33365    },
33366    {
33367        let mut init = redisCommandArg {
33368            name: b"min\0" as *const u8 as *const libc::c_char,
33369            type_0: ARG_TYPE_STRING,
33370            key_spec_index: -(1 as libc::c_int),
33371            token: 0 as *const libc::c_char,
33372            summary: 0 as *const libc::c_char,
33373            since: 0 as *const libc::c_char,
33374            flags: 0 as libc::c_int,
33375            deprecated_since: 0 as *const libc::c_char,
33376            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33377            num_args: 0,
33378        };
33379        init
33380    },
33381    {
33382        let mut init = redisCommandArg {
33383            name: b"max\0" as *const u8 as *const libc::c_char,
33384            type_0: ARG_TYPE_STRING,
33385            key_spec_index: -(1 as libc::c_int),
33386            token: 0 as *const libc::c_char,
33387            summary: 0 as *const libc::c_char,
33388            since: 0 as *const libc::c_char,
33389            flags: 0 as libc::c_int,
33390            deprecated_since: 0 as *const libc::c_char,
33391            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33392            num_args: 0,
33393        };
33394        init
33395    },
33396    {
33397        let mut init = redisCommandArg {
33398            name: 0 as *const libc::c_char,
33399            type_0: ARG_TYPE_STRING,
33400            key_spec_index: 0,
33401            token: 0 as *const libc::c_char,
33402            summary: 0 as *const libc::c_char,
33403            since: 0 as *const libc::c_char,
33404            flags: 0,
33405            deprecated_since: 0 as *const libc::c_char,
33406            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33407            num_args: 0,
33408        };
33409        init
33410    },
33411];
33412#[no_mangle]
33413pub static mut ZREMRANGEBYRANK_Args: [redisCommandArg; 4] = [
33414    {
33415        let mut init = redisCommandArg {
33416            name: b"key\0" as *const u8 as *const libc::c_char,
33417            type_0: ARG_TYPE_KEY,
33418            key_spec_index: 0 as libc::c_int,
33419            token: 0 as *const libc::c_char,
33420            summary: 0 as *const libc::c_char,
33421            since: 0 as *const libc::c_char,
33422            flags: 0 as libc::c_int,
33423            deprecated_since: 0 as *const libc::c_char,
33424            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33425            num_args: 0,
33426        };
33427        init
33428    },
33429    {
33430        let mut init = redisCommandArg {
33431            name: b"start\0" as *const u8 as *const libc::c_char,
33432            type_0: ARG_TYPE_INTEGER,
33433            key_spec_index: -(1 as libc::c_int),
33434            token: 0 as *const libc::c_char,
33435            summary: 0 as *const libc::c_char,
33436            since: 0 as *const libc::c_char,
33437            flags: 0 as libc::c_int,
33438            deprecated_since: 0 as *const libc::c_char,
33439            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33440            num_args: 0,
33441        };
33442        init
33443    },
33444    {
33445        let mut init = redisCommandArg {
33446            name: b"stop\0" as *const u8 as *const libc::c_char,
33447            type_0: ARG_TYPE_INTEGER,
33448            key_spec_index: -(1 as libc::c_int),
33449            token: 0 as *const libc::c_char,
33450            summary: 0 as *const libc::c_char,
33451            since: 0 as *const libc::c_char,
33452            flags: 0 as libc::c_int,
33453            deprecated_since: 0 as *const libc::c_char,
33454            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33455            num_args: 0,
33456        };
33457        init
33458    },
33459    {
33460        let mut init = redisCommandArg {
33461            name: 0 as *const libc::c_char,
33462            type_0: ARG_TYPE_STRING,
33463            key_spec_index: 0,
33464            token: 0 as *const libc::c_char,
33465            summary: 0 as *const libc::c_char,
33466            since: 0 as *const libc::c_char,
33467            flags: 0,
33468            deprecated_since: 0 as *const libc::c_char,
33469            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33470            num_args: 0,
33471        };
33472        init
33473    },
33474];
33475#[no_mangle]
33476pub static mut ZREMRANGEBYSCORE_Args: [redisCommandArg; 4] = [
33477    {
33478        let mut init = redisCommandArg {
33479            name: b"key\0" as *const u8 as *const libc::c_char,
33480            type_0: ARG_TYPE_KEY,
33481            key_spec_index: 0 as libc::c_int,
33482            token: 0 as *const libc::c_char,
33483            summary: 0 as *const libc::c_char,
33484            since: 0 as *const libc::c_char,
33485            flags: 0 as libc::c_int,
33486            deprecated_since: 0 as *const libc::c_char,
33487            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33488            num_args: 0,
33489        };
33490        init
33491    },
33492    {
33493        let mut init = redisCommandArg {
33494            name: b"min\0" as *const u8 as *const libc::c_char,
33495            type_0: ARG_TYPE_DOUBLE,
33496            key_spec_index: -(1 as libc::c_int),
33497            token: 0 as *const libc::c_char,
33498            summary: 0 as *const libc::c_char,
33499            since: 0 as *const libc::c_char,
33500            flags: 0 as libc::c_int,
33501            deprecated_since: 0 as *const libc::c_char,
33502            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33503            num_args: 0,
33504        };
33505        init
33506    },
33507    {
33508        let mut init = redisCommandArg {
33509            name: b"max\0" as *const u8 as *const libc::c_char,
33510            type_0: ARG_TYPE_DOUBLE,
33511            key_spec_index: -(1 as libc::c_int),
33512            token: 0 as *const libc::c_char,
33513            summary: 0 as *const libc::c_char,
33514            since: 0 as *const libc::c_char,
33515            flags: 0 as libc::c_int,
33516            deprecated_since: 0 as *const libc::c_char,
33517            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33518            num_args: 0,
33519        };
33520        init
33521    },
33522    {
33523        let mut init = redisCommandArg {
33524            name: 0 as *const libc::c_char,
33525            type_0: ARG_TYPE_STRING,
33526            key_spec_index: 0,
33527            token: 0 as *const libc::c_char,
33528            summary: 0 as *const libc::c_char,
33529            since: 0 as *const libc::c_char,
33530            flags: 0,
33531            deprecated_since: 0 as *const libc::c_char,
33532            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33533            num_args: 0,
33534        };
33535        init
33536    },
33537];
33538#[no_mangle]
33539pub static mut ZREVRANGE_Args: [redisCommandArg; 5] = [
33540    {
33541        let mut init = redisCommandArg {
33542            name: b"key\0" as *const u8 as *const libc::c_char,
33543            type_0: ARG_TYPE_KEY,
33544            key_spec_index: 0 as libc::c_int,
33545            token: 0 as *const libc::c_char,
33546            summary: 0 as *const libc::c_char,
33547            since: 0 as *const libc::c_char,
33548            flags: 0 as libc::c_int,
33549            deprecated_since: 0 as *const libc::c_char,
33550            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33551            num_args: 0,
33552        };
33553        init
33554    },
33555    {
33556        let mut init = redisCommandArg {
33557            name: b"start\0" as *const u8 as *const libc::c_char,
33558            type_0: ARG_TYPE_INTEGER,
33559            key_spec_index: -(1 as libc::c_int),
33560            token: 0 as *const libc::c_char,
33561            summary: 0 as *const libc::c_char,
33562            since: 0 as *const libc::c_char,
33563            flags: 0 as libc::c_int,
33564            deprecated_since: 0 as *const libc::c_char,
33565            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33566            num_args: 0,
33567        };
33568        init
33569    },
33570    {
33571        let mut init = redisCommandArg {
33572            name: b"stop\0" as *const u8 as *const libc::c_char,
33573            type_0: ARG_TYPE_INTEGER,
33574            key_spec_index: -(1 as libc::c_int),
33575            token: 0 as *const libc::c_char,
33576            summary: 0 as *const libc::c_char,
33577            since: 0 as *const libc::c_char,
33578            flags: 0 as libc::c_int,
33579            deprecated_since: 0 as *const libc::c_char,
33580            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33581            num_args: 0,
33582        };
33583        init
33584    },
33585    {
33586        let mut init = redisCommandArg {
33587            name: b"withscores\0" as *const u8 as *const libc::c_char,
33588            type_0: ARG_TYPE_PURE_TOKEN,
33589            key_spec_index: -(1 as libc::c_int),
33590            token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
33591            summary: 0 as *const libc::c_char,
33592            since: 0 as *const libc::c_char,
33593            flags: (1 as libc::c_int) << 0 as libc::c_int,
33594            deprecated_since: 0 as *const libc::c_char,
33595            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33596            num_args: 0,
33597        };
33598        init
33599    },
33600    {
33601        let mut init = redisCommandArg {
33602            name: 0 as *const libc::c_char,
33603            type_0: ARG_TYPE_STRING,
33604            key_spec_index: 0,
33605            token: 0 as *const libc::c_char,
33606            summary: 0 as *const libc::c_char,
33607            since: 0 as *const libc::c_char,
33608            flags: 0,
33609            deprecated_since: 0 as *const libc::c_char,
33610            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33611            num_args: 0,
33612        };
33613        init
33614    },
33615];
33616#[no_mangle]
33617pub static mut ZREVRANGEBYLEX_offset_count_Subargs: [redisCommandArg; 3] = [
33618    {
33619        let mut init = redisCommandArg {
33620            name: b"offset\0" as *const u8 as *const libc::c_char,
33621            type_0: ARG_TYPE_INTEGER,
33622            key_spec_index: -(1 as libc::c_int),
33623            token: 0 as *const libc::c_char,
33624            summary: 0 as *const libc::c_char,
33625            since: 0 as *const libc::c_char,
33626            flags: 0 as libc::c_int,
33627            deprecated_since: 0 as *const libc::c_char,
33628            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33629            num_args: 0,
33630        };
33631        init
33632    },
33633    {
33634        let mut init = redisCommandArg {
33635            name: b"count\0" as *const u8 as *const libc::c_char,
33636            type_0: ARG_TYPE_INTEGER,
33637            key_spec_index: -(1 as libc::c_int),
33638            token: 0 as *const libc::c_char,
33639            summary: 0 as *const libc::c_char,
33640            since: 0 as *const libc::c_char,
33641            flags: 0 as libc::c_int,
33642            deprecated_since: 0 as *const libc::c_char,
33643            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33644            num_args: 0,
33645        };
33646        init
33647    },
33648    {
33649        let mut init = redisCommandArg {
33650            name: 0 as *const libc::c_char,
33651            type_0: ARG_TYPE_STRING,
33652            key_spec_index: 0,
33653            token: 0 as *const libc::c_char,
33654            summary: 0 as *const libc::c_char,
33655            since: 0 as *const libc::c_char,
33656            flags: 0,
33657            deprecated_since: 0 as *const libc::c_char,
33658            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33659            num_args: 0,
33660        };
33661        init
33662    },
33663];
33664#[no_mangle]
33665pub static mut ZREVRANGEBYLEX_Args: [redisCommandArg; 5] = unsafe {
33666    [
33667        {
33668            let mut init = redisCommandArg {
33669                name: b"key\0" as *const u8 as *const libc::c_char,
33670                type_0: ARG_TYPE_KEY,
33671                key_spec_index: 0 as libc::c_int,
33672                token: 0 as *const libc::c_char,
33673                summary: 0 as *const libc::c_char,
33674                since: 0 as *const libc::c_char,
33675                flags: 0 as libc::c_int,
33676                deprecated_since: 0 as *const libc::c_char,
33677                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33678                num_args: 0,
33679            };
33680            init
33681        },
33682        {
33683            let mut init = redisCommandArg {
33684                name: b"max\0" as *const u8 as *const libc::c_char,
33685                type_0: ARG_TYPE_STRING,
33686                key_spec_index: -(1 as libc::c_int),
33687                token: 0 as *const libc::c_char,
33688                summary: 0 as *const libc::c_char,
33689                since: 0 as *const libc::c_char,
33690                flags: 0 as libc::c_int,
33691                deprecated_since: 0 as *const libc::c_char,
33692                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33693                num_args: 0,
33694            };
33695            init
33696        },
33697        {
33698            let mut init = redisCommandArg {
33699                name: b"min\0" as *const u8 as *const libc::c_char,
33700                type_0: ARG_TYPE_STRING,
33701                key_spec_index: -(1 as libc::c_int),
33702                token: 0 as *const libc::c_char,
33703                summary: 0 as *const libc::c_char,
33704                since: 0 as *const libc::c_char,
33705                flags: 0 as libc::c_int,
33706                deprecated_since: 0 as *const libc::c_char,
33707                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33708                num_args: 0,
33709            };
33710            init
33711        },
33712        {
33713            let mut init = redisCommandArg {
33714                name: b"offset_count\0" as *const u8 as *const libc::c_char,
33715                type_0: ARG_TYPE_BLOCK,
33716                key_spec_index: -(1 as libc::c_int),
33717                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
33718                summary: 0 as *const libc::c_char,
33719                since: 0 as *const libc::c_char,
33720                flags: (1 as libc::c_int) << 0 as libc::c_int,
33721                deprecated_since: 0 as *const libc::c_char,
33722                subargs: ZREVRANGEBYLEX_offset_count_Subargs.as_ptr() as *mut _,
33723                num_args: 0,
33724            };
33725            init
33726        },
33727        {
33728            let mut init = redisCommandArg {
33729                name: 0 as *const libc::c_char,
33730                type_0: ARG_TYPE_STRING,
33731                key_spec_index: 0,
33732                token: 0 as *const libc::c_char,
33733                summary: 0 as *const libc::c_char,
33734                since: 0 as *const libc::c_char,
33735                flags: 0,
33736                deprecated_since: 0 as *const libc::c_char,
33737                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33738                num_args: 0,
33739            };
33740            init
33741        },
33742    ]
33743};
33744#[no_mangle]
33745pub static mut ZREVRANGEBYSCORE_History: [commandHistory; 2] = [
33746    {
33747        let mut init = commandHistory {
33748            since: b"2.1.6\0" as *const u8 as *const libc::c_char,
33749            changes: b"`min` and `max` can be exclusive.\0" as *const u8
33750                as *const libc::c_char,
33751        };
33752        init
33753    },
33754    {
33755        let mut init = commandHistory {
33756            since: 0 as *const libc::c_char,
33757            changes: 0 as *const libc::c_char,
33758        };
33759        init
33760    },
33761];
33762#[no_mangle]
33763pub static mut ZREVRANGEBYSCORE_offset_count_Subargs: [redisCommandArg; 3] = [
33764    {
33765        let mut init = redisCommandArg {
33766            name: b"offset\0" as *const u8 as *const libc::c_char,
33767            type_0: ARG_TYPE_INTEGER,
33768            key_spec_index: -(1 as libc::c_int),
33769            token: 0 as *const libc::c_char,
33770            summary: 0 as *const libc::c_char,
33771            since: 0 as *const libc::c_char,
33772            flags: 0 as libc::c_int,
33773            deprecated_since: 0 as *const libc::c_char,
33774            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33775            num_args: 0,
33776        };
33777        init
33778    },
33779    {
33780        let mut init = redisCommandArg {
33781            name: b"count\0" as *const u8 as *const libc::c_char,
33782            type_0: ARG_TYPE_INTEGER,
33783            key_spec_index: -(1 as libc::c_int),
33784            token: 0 as *const libc::c_char,
33785            summary: 0 as *const libc::c_char,
33786            since: 0 as *const libc::c_char,
33787            flags: 0 as libc::c_int,
33788            deprecated_since: 0 as *const libc::c_char,
33789            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33790            num_args: 0,
33791        };
33792        init
33793    },
33794    {
33795        let mut init = redisCommandArg {
33796            name: 0 as *const libc::c_char,
33797            type_0: ARG_TYPE_STRING,
33798            key_spec_index: 0,
33799            token: 0 as *const libc::c_char,
33800            summary: 0 as *const libc::c_char,
33801            since: 0 as *const libc::c_char,
33802            flags: 0,
33803            deprecated_since: 0 as *const libc::c_char,
33804            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33805            num_args: 0,
33806        };
33807        init
33808    },
33809];
33810#[no_mangle]
33811pub static mut ZREVRANGEBYSCORE_Args: [redisCommandArg; 6] = unsafe {
33812    [
33813        {
33814            let mut init = redisCommandArg {
33815                name: b"key\0" as *const u8 as *const libc::c_char,
33816                type_0: ARG_TYPE_KEY,
33817                key_spec_index: 0 as libc::c_int,
33818                token: 0 as *const libc::c_char,
33819                summary: 0 as *const libc::c_char,
33820                since: 0 as *const libc::c_char,
33821                flags: 0 as libc::c_int,
33822                deprecated_since: 0 as *const libc::c_char,
33823                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33824                num_args: 0,
33825            };
33826            init
33827        },
33828        {
33829            let mut init = redisCommandArg {
33830                name: b"max\0" as *const u8 as *const libc::c_char,
33831                type_0: ARG_TYPE_DOUBLE,
33832                key_spec_index: -(1 as libc::c_int),
33833                token: 0 as *const libc::c_char,
33834                summary: 0 as *const libc::c_char,
33835                since: 0 as *const libc::c_char,
33836                flags: 0 as libc::c_int,
33837                deprecated_since: 0 as *const libc::c_char,
33838                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33839                num_args: 0,
33840            };
33841            init
33842        },
33843        {
33844            let mut init = redisCommandArg {
33845                name: b"min\0" as *const u8 as *const libc::c_char,
33846                type_0: ARG_TYPE_DOUBLE,
33847                key_spec_index: -(1 as libc::c_int),
33848                token: 0 as *const libc::c_char,
33849                summary: 0 as *const libc::c_char,
33850                since: 0 as *const libc::c_char,
33851                flags: 0 as libc::c_int,
33852                deprecated_since: 0 as *const libc::c_char,
33853                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33854                num_args: 0,
33855            };
33856            init
33857        },
33858        {
33859            let mut init = redisCommandArg {
33860                name: b"withscores\0" as *const u8 as *const libc::c_char,
33861                type_0: ARG_TYPE_PURE_TOKEN,
33862                key_spec_index: -(1 as libc::c_int),
33863                token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
33864                summary: 0 as *const libc::c_char,
33865                since: 0 as *const libc::c_char,
33866                flags: (1 as libc::c_int) << 0 as libc::c_int,
33867                deprecated_since: 0 as *const libc::c_char,
33868                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33869                num_args: 0,
33870            };
33871            init
33872        },
33873        {
33874            let mut init = redisCommandArg {
33875                name: b"offset_count\0" as *const u8 as *const libc::c_char,
33876                type_0: ARG_TYPE_BLOCK,
33877                key_spec_index: -(1 as libc::c_int),
33878                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
33879                summary: 0 as *const libc::c_char,
33880                since: 0 as *const libc::c_char,
33881                flags: (1 as libc::c_int) << 0 as libc::c_int,
33882                deprecated_since: 0 as *const libc::c_char,
33883                subargs: ZREVRANGEBYSCORE_offset_count_Subargs.as_ptr() as *mut _,
33884                num_args: 0,
33885            };
33886            init
33887        },
33888        {
33889            let mut init = redisCommandArg {
33890                name: 0 as *const libc::c_char,
33891                type_0: ARG_TYPE_STRING,
33892                key_spec_index: 0,
33893                token: 0 as *const libc::c_char,
33894                summary: 0 as *const libc::c_char,
33895                since: 0 as *const libc::c_char,
33896                flags: 0,
33897                deprecated_since: 0 as *const libc::c_char,
33898                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33899                num_args: 0,
33900            };
33901            init
33902        },
33903    ]
33904};
33905#[no_mangle]
33906pub static mut ZREVRANK_Args: [redisCommandArg; 3] = [
33907    {
33908        let mut init = redisCommandArg {
33909            name: b"key\0" as *const u8 as *const libc::c_char,
33910            type_0: ARG_TYPE_KEY,
33911            key_spec_index: 0 as libc::c_int,
33912            token: 0 as *const libc::c_char,
33913            summary: 0 as *const libc::c_char,
33914            since: 0 as *const libc::c_char,
33915            flags: 0 as libc::c_int,
33916            deprecated_since: 0 as *const libc::c_char,
33917            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33918            num_args: 0,
33919        };
33920        init
33921    },
33922    {
33923        let mut init = redisCommandArg {
33924            name: b"member\0" as *const u8 as *const libc::c_char,
33925            type_0: ARG_TYPE_STRING,
33926            key_spec_index: -(1 as libc::c_int),
33927            token: 0 as *const libc::c_char,
33928            summary: 0 as *const libc::c_char,
33929            since: 0 as *const libc::c_char,
33930            flags: 0 as libc::c_int,
33931            deprecated_since: 0 as *const libc::c_char,
33932            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33933            num_args: 0,
33934        };
33935        init
33936    },
33937    {
33938        let mut init = redisCommandArg {
33939            name: 0 as *const libc::c_char,
33940            type_0: ARG_TYPE_STRING,
33941            key_spec_index: 0,
33942            token: 0 as *const libc::c_char,
33943            summary: 0 as *const libc::c_char,
33944            since: 0 as *const libc::c_char,
33945            flags: 0,
33946            deprecated_since: 0 as *const libc::c_char,
33947            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33948            num_args: 0,
33949        };
33950        init
33951    },
33952];
33953#[no_mangle]
33954pub static mut ZSCAN_tips: [*const libc::c_char; 2] = [
33955    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
33956    0 as *const libc::c_char,
33957];
33958#[no_mangle]
33959pub static mut ZSCAN_Args: [redisCommandArg; 5] = [
33960    {
33961        let mut init = redisCommandArg {
33962            name: b"key\0" as *const u8 as *const libc::c_char,
33963            type_0: ARG_TYPE_KEY,
33964            key_spec_index: 0 as libc::c_int,
33965            token: 0 as *const libc::c_char,
33966            summary: 0 as *const libc::c_char,
33967            since: 0 as *const libc::c_char,
33968            flags: 0 as libc::c_int,
33969            deprecated_since: 0 as *const libc::c_char,
33970            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33971            num_args: 0,
33972        };
33973        init
33974    },
33975    {
33976        let mut init = redisCommandArg {
33977            name: b"cursor\0" as *const u8 as *const libc::c_char,
33978            type_0: ARG_TYPE_INTEGER,
33979            key_spec_index: -(1 as libc::c_int),
33980            token: 0 as *const libc::c_char,
33981            summary: 0 as *const libc::c_char,
33982            since: 0 as *const libc::c_char,
33983            flags: 0 as libc::c_int,
33984            deprecated_since: 0 as *const libc::c_char,
33985            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
33986            num_args: 0,
33987        };
33988        init
33989    },
33990    {
33991        let mut init = redisCommandArg {
33992            name: b"pattern\0" as *const u8 as *const libc::c_char,
33993            type_0: ARG_TYPE_PATTERN,
33994            key_spec_index: -(1 as libc::c_int),
33995            token: b"MATCH\0" as *const u8 as *const libc::c_char,
33996            summary: 0 as *const libc::c_char,
33997            since: 0 as *const libc::c_char,
33998            flags: (1 as libc::c_int) << 0 as libc::c_int,
33999            deprecated_since: 0 as *const libc::c_char,
34000            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34001            num_args: 0,
34002        };
34003        init
34004    },
34005    {
34006        let mut init = redisCommandArg {
34007            name: b"count\0" as *const u8 as *const libc::c_char,
34008            type_0: ARG_TYPE_INTEGER,
34009            key_spec_index: -(1 as libc::c_int),
34010            token: b"COUNT\0" as *const u8 as *const libc::c_char,
34011            summary: 0 as *const libc::c_char,
34012            since: 0 as *const libc::c_char,
34013            flags: (1 as libc::c_int) << 0 as libc::c_int,
34014            deprecated_since: 0 as *const libc::c_char,
34015            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34016            num_args: 0,
34017        };
34018        init
34019    },
34020    {
34021        let mut init = redisCommandArg {
34022            name: 0 as *const libc::c_char,
34023            type_0: ARG_TYPE_STRING,
34024            key_spec_index: 0,
34025            token: 0 as *const libc::c_char,
34026            summary: 0 as *const libc::c_char,
34027            since: 0 as *const libc::c_char,
34028            flags: 0,
34029            deprecated_since: 0 as *const libc::c_char,
34030            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34031            num_args: 0,
34032        };
34033        init
34034    },
34035];
34036#[no_mangle]
34037pub static mut ZSCORE_Args: [redisCommandArg; 3] = [
34038    {
34039        let mut init = redisCommandArg {
34040            name: b"key\0" as *const u8 as *const libc::c_char,
34041            type_0: ARG_TYPE_KEY,
34042            key_spec_index: 0 as libc::c_int,
34043            token: 0 as *const libc::c_char,
34044            summary: 0 as *const libc::c_char,
34045            since: 0 as *const libc::c_char,
34046            flags: 0 as libc::c_int,
34047            deprecated_since: 0 as *const libc::c_char,
34048            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34049            num_args: 0,
34050        };
34051        init
34052    },
34053    {
34054        let mut init = redisCommandArg {
34055            name: b"member\0" as *const u8 as *const libc::c_char,
34056            type_0: ARG_TYPE_STRING,
34057            key_spec_index: -(1 as libc::c_int),
34058            token: 0 as *const libc::c_char,
34059            summary: 0 as *const libc::c_char,
34060            since: 0 as *const libc::c_char,
34061            flags: 0 as libc::c_int,
34062            deprecated_since: 0 as *const libc::c_char,
34063            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34064            num_args: 0,
34065        };
34066        init
34067    },
34068    {
34069        let mut init = redisCommandArg {
34070            name: 0 as *const libc::c_char,
34071            type_0: ARG_TYPE_STRING,
34072            key_spec_index: 0,
34073            token: 0 as *const libc::c_char,
34074            summary: 0 as *const libc::c_char,
34075            since: 0 as *const libc::c_char,
34076            flags: 0,
34077            deprecated_since: 0 as *const libc::c_char,
34078            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34079            num_args: 0,
34080        };
34081        init
34082    },
34083];
34084#[no_mangle]
34085pub static mut ZUNION_aggregate_Subargs: [redisCommandArg; 4] = [
34086    {
34087        let mut init = redisCommandArg {
34088            name: b"sum\0" as *const u8 as *const libc::c_char,
34089            type_0: ARG_TYPE_PURE_TOKEN,
34090            key_spec_index: -(1 as libc::c_int),
34091            token: b"SUM\0" as *const u8 as *const libc::c_char,
34092            summary: 0 as *const libc::c_char,
34093            since: 0 as *const libc::c_char,
34094            flags: 0 as libc::c_int,
34095            deprecated_since: 0 as *const libc::c_char,
34096            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34097            num_args: 0,
34098        };
34099        init
34100    },
34101    {
34102        let mut init = redisCommandArg {
34103            name: b"min\0" as *const u8 as *const libc::c_char,
34104            type_0: ARG_TYPE_PURE_TOKEN,
34105            key_spec_index: -(1 as libc::c_int),
34106            token: b"MIN\0" as *const u8 as *const libc::c_char,
34107            summary: 0 as *const libc::c_char,
34108            since: 0 as *const libc::c_char,
34109            flags: 0 as libc::c_int,
34110            deprecated_since: 0 as *const libc::c_char,
34111            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34112            num_args: 0,
34113        };
34114        init
34115    },
34116    {
34117        let mut init = redisCommandArg {
34118            name: b"max\0" as *const u8 as *const libc::c_char,
34119            type_0: ARG_TYPE_PURE_TOKEN,
34120            key_spec_index: -(1 as libc::c_int),
34121            token: b"MAX\0" as *const u8 as *const libc::c_char,
34122            summary: 0 as *const libc::c_char,
34123            since: 0 as *const libc::c_char,
34124            flags: 0 as libc::c_int,
34125            deprecated_since: 0 as *const libc::c_char,
34126            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34127            num_args: 0,
34128        };
34129        init
34130    },
34131    {
34132        let mut init = redisCommandArg {
34133            name: 0 as *const libc::c_char,
34134            type_0: ARG_TYPE_STRING,
34135            key_spec_index: 0,
34136            token: 0 as *const libc::c_char,
34137            summary: 0 as *const libc::c_char,
34138            since: 0 as *const libc::c_char,
34139            flags: 0,
34140            deprecated_since: 0 as *const libc::c_char,
34141            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34142            num_args: 0,
34143        };
34144        init
34145    },
34146];
34147#[no_mangle]
34148pub static mut ZUNION_Args: [redisCommandArg; 6] = unsafe {
34149    [
34150        {
34151            let mut init = redisCommandArg {
34152                name: b"numkeys\0" as *const u8 as *const libc::c_char,
34153                type_0: ARG_TYPE_INTEGER,
34154                key_spec_index: -(1 as libc::c_int),
34155                token: 0 as *const libc::c_char,
34156                summary: 0 as *const libc::c_char,
34157                since: 0 as *const libc::c_char,
34158                flags: 0 as libc::c_int,
34159                deprecated_since: 0 as *const libc::c_char,
34160                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34161                num_args: 0,
34162            };
34163            init
34164        },
34165        {
34166            let mut init = redisCommandArg {
34167                name: b"key\0" as *const u8 as *const libc::c_char,
34168                type_0: ARG_TYPE_KEY,
34169                key_spec_index: 0 as libc::c_int,
34170                token: 0 as *const libc::c_char,
34171                summary: 0 as *const libc::c_char,
34172                since: 0 as *const libc::c_char,
34173                flags: (1 as libc::c_int) << 1 as libc::c_int,
34174                deprecated_since: 0 as *const libc::c_char,
34175                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34176                num_args: 0,
34177            };
34178            init
34179        },
34180        {
34181            let mut init = redisCommandArg {
34182                name: b"weight\0" as *const u8 as *const libc::c_char,
34183                type_0: ARG_TYPE_INTEGER,
34184                key_spec_index: -(1 as libc::c_int),
34185                token: b"WEIGHTS\0" as *const u8 as *const libc::c_char,
34186                summary: 0 as *const libc::c_char,
34187                since: 0 as *const libc::c_char,
34188                flags: (1 as libc::c_int) << 0 as libc::c_int
34189                    | (1 as libc::c_int) << 1 as libc::c_int,
34190                deprecated_since: 0 as *const libc::c_char,
34191                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34192                num_args: 0,
34193            };
34194            init
34195        },
34196        {
34197            let mut init = redisCommandArg {
34198                name: b"aggregate\0" as *const u8 as *const libc::c_char,
34199                type_0: ARG_TYPE_ONEOF,
34200                key_spec_index: -(1 as libc::c_int),
34201                token: b"AGGREGATE\0" as *const u8 as *const libc::c_char,
34202                summary: 0 as *const libc::c_char,
34203                since: 0 as *const libc::c_char,
34204                flags: (1 as libc::c_int) << 0 as libc::c_int,
34205                deprecated_since: 0 as *const libc::c_char,
34206                subargs: ZUNION_aggregate_Subargs.as_ptr() as *mut _,
34207                num_args: 0,
34208            };
34209            init
34210        },
34211        {
34212            let mut init = redisCommandArg {
34213                name: b"withscores\0" as *const u8 as *const libc::c_char,
34214                type_0: ARG_TYPE_PURE_TOKEN,
34215                key_spec_index: -(1 as libc::c_int),
34216                token: b"WITHSCORES\0" as *const u8 as *const libc::c_char,
34217                summary: 0 as *const libc::c_char,
34218                since: 0 as *const libc::c_char,
34219                flags: (1 as libc::c_int) << 0 as libc::c_int,
34220                deprecated_since: 0 as *const libc::c_char,
34221                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34222                num_args: 0,
34223            };
34224            init
34225        },
34226        {
34227            let mut init = redisCommandArg {
34228                name: 0 as *const libc::c_char,
34229                type_0: ARG_TYPE_STRING,
34230                key_spec_index: 0,
34231                token: 0 as *const libc::c_char,
34232                summary: 0 as *const libc::c_char,
34233                since: 0 as *const libc::c_char,
34234                flags: 0,
34235                deprecated_since: 0 as *const libc::c_char,
34236                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34237                num_args: 0,
34238            };
34239            init
34240        },
34241    ]
34242};
34243#[no_mangle]
34244pub static mut ZUNIONSTORE_aggregate_Subargs: [redisCommandArg; 4] = [
34245    {
34246        let mut init = redisCommandArg {
34247            name: b"sum\0" as *const u8 as *const libc::c_char,
34248            type_0: ARG_TYPE_PURE_TOKEN,
34249            key_spec_index: -(1 as libc::c_int),
34250            token: b"SUM\0" as *const u8 as *const libc::c_char,
34251            summary: 0 as *const libc::c_char,
34252            since: 0 as *const libc::c_char,
34253            flags: 0 as libc::c_int,
34254            deprecated_since: 0 as *const libc::c_char,
34255            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34256            num_args: 0,
34257        };
34258        init
34259    },
34260    {
34261        let mut init = redisCommandArg {
34262            name: b"min\0" as *const u8 as *const libc::c_char,
34263            type_0: ARG_TYPE_PURE_TOKEN,
34264            key_spec_index: -(1 as libc::c_int),
34265            token: b"MIN\0" as *const u8 as *const libc::c_char,
34266            summary: 0 as *const libc::c_char,
34267            since: 0 as *const libc::c_char,
34268            flags: 0 as libc::c_int,
34269            deprecated_since: 0 as *const libc::c_char,
34270            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34271            num_args: 0,
34272        };
34273        init
34274    },
34275    {
34276        let mut init = redisCommandArg {
34277            name: b"max\0" as *const u8 as *const libc::c_char,
34278            type_0: ARG_TYPE_PURE_TOKEN,
34279            key_spec_index: -(1 as libc::c_int),
34280            token: b"MAX\0" as *const u8 as *const libc::c_char,
34281            summary: 0 as *const libc::c_char,
34282            since: 0 as *const libc::c_char,
34283            flags: 0 as libc::c_int,
34284            deprecated_since: 0 as *const libc::c_char,
34285            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34286            num_args: 0,
34287        };
34288        init
34289    },
34290    {
34291        let mut init = redisCommandArg {
34292            name: 0 as *const libc::c_char,
34293            type_0: ARG_TYPE_STRING,
34294            key_spec_index: 0,
34295            token: 0 as *const libc::c_char,
34296            summary: 0 as *const libc::c_char,
34297            since: 0 as *const libc::c_char,
34298            flags: 0,
34299            deprecated_since: 0 as *const libc::c_char,
34300            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34301            num_args: 0,
34302        };
34303        init
34304    },
34305];
34306#[no_mangle]
34307pub static mut ZUNIONSTORE_Args: [redisCommandArg; 6] = unsafe {
34308    [
34309        {
34310            let mut init = redisCommandArg {
34311                name: b"destination\0" as *const u8 as *const libc::c_char,
34312                type_0: ARG_TYPE_KEY,
34313                key_spec_index: 0 as libc::c_int,
34314                token: 0 as *const libc::c_char,
34315                summary: 0 as *const libc::c_char,
34316                since: 0 as *const libc::c_char,
34317                flags: 0 as libc::c_int,
34318                deprecated_since: 0 as *const libc::c_char,
34319                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34320                num_args: 0,
34321            };
34322            init
34323        },
34324        {
34325            let mut init = redisCommandArg {
34326                name: b"numkeys\0" as *const u8 as *const libc::c_char,
34327                type_0: ARG_TYPE_INTEGER,
34328                key_spec_index: -(1 as libc::c_int),
34329                token: 0 as *const libc::c_char,
34330                summary: 0 as *const libc::c_char,
34331                since: 0 as *const libc::c_char,
34332                flags: 0 as libc::c_int,
34333                deprecated_since: 0 as *const libc::c_char,
34334                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34335                num_args: 0,
34336            };
34337            init
34338        },
34339        {
34340            let mut init = redisCommandArg {
34341                name: b"key\0" as *const u8 as *const libc::c_char,
34342                type_0: ARG_TYPE_KEY,
34343                key_spec_index: 1 as libc::c_int,
34344                token: 0 as *const libc::c_char,
34345                summary: 0 as *const libc::c_char,
34346                since: 0 as *const libc::c_char,
34347                flags: (1 as libc::c_int) << 1 as libc::c_int,
34348                deprecated_since: 0 as *const libc::c_char,
34349                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34350                num_args: 0,
34351            };
34352            init
34353        },
34354        {
34355            let mut init = redisCommandArg {
34356                name: b"weight\0" as *const u8 as *const libc::c_char,
34357                type_0: ARG_TYPE_INTEGER,
34358                key_spec_index: -(1 as libc::c_int),
34359                token: b"WEIGHTS\0" as *const u8 as *const libc::c_char,
34360                summary: 0 as *const libc::c_char,
34361                since: 0 as *const libc::c_char,
34362                flags: (1 as libc::c_int) << 0 as libc::c_int
34363                    | (1 as libc::c_int) << 1 as libc::c_int,
34364                deprecated_since: 0 as *const libc::c_char,
34365                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34366                num_args: 0,
34367            };
34368            init
34369        },
34370        {
34371            let mut init = redisCommandArg {
34372                name: b"aggregate\0" as *const u8 as *const libc::c_char,
34373                type_0: ARG_TYPE_ONEOF,
34374                key_spec_index: -(1 as libc::c_int),
34375                token: b"AGGREGATE\0" as *const u8 as *const libc::c_char,
34376                summary: 0 as *const libc::c_char,
34377                since: 0 as *const libc::c_char,
34378                flags: (1 as libc::c_int) << 0 as libc::c_int,
34379                deprecated_since: 0 as *const libc::c_char,
34380                subargs: ZUNIONSTORE_aggregate_Subargs.as_ptr() as *mut _,
34381                num_args: 0,
34382            };
34383            init
34384        },
34385        {
34386            let mut init = redisCommandArg {
34387                name: 0 as *const libc::c_char,
34388                type_0: ARG_TYPE_STRING,
34389                key_spec_index: 0,
34390                token: 0 as *const libc::c_char,
34391                summary: 0 as *const libc::c_char,
34392                since: 0 as *const libc::c_char,
34393                flags: 0,
34394                deprecated_since: 0 as *const libc::c_char,
34395                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34396                num_args: 0,
34397            };
34398            init
34399        },
34400    ]
34401};
34402#[no_mangle]
34403pub static mut XACK_Args: [redisCommandArg; 4] = [
34404    {
34405        let mut init = redisCommandArg {
34406            name: b"key\0" as *const u8 as *const libc::c_char,
34407            type_0: ARG_TYPE_KEY,
34408            key_spec_index: 0 as libc::c_int,
34409            token: 0 as *const libc::c_char,
34410            summary: 0 as *const libc::c_char,
34411            since: 0 as *const libc::c_char,
34412            flags: 0 as libc::c_int,
34413            deprecated_since: 0 as *const libc::c_char,
34414            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34415            num_args: 0,
34416        };
34417        init
34418    },
34419    {
34420        let mut init = redisCommandArg {
34421            name: b"group\0" as *const u8 as *const libc::c_char,
34422            type_0: ARG_TYPE_STRING,
34423            key_spec_index: -(1 as libc::c_int),
34424            token: 0 as *const libc::c_char,
34425            summary: 0 as *const libc::c_char,
34426            since: 0 as *const libc::c_char,
34427            flags: 0 as libc::c_int,
34428            deprecated_since: 0 as *const libc::c_char,
34429            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34430            num_args: 0,
34431        };
34432        init
34433    },
34434    {
34435        let mut init = redisCommandArg {
34436            name: b"id\0" as *const u8 as *const libc::c_char,
34437            type_0: ARG_TYPE_STRING,
34438            key_spec_index: -(1 as libc::c_int),
34439            token: 0 as *const libc::c_char,
34440            summary: 0 as *const libc::c_char,
34441            since: 0 as *const libc::c_char,
34442            flags: (1 as libc::c_int) << 1 as libc::c_int,
34443            deprecated_since: 0 as *const libc::c_char,
34444            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34445            num_args: 0,
34446        };
34447        init
34448    },
34449    {
34450        let mut init = redisCommandArg {
34451            name: 0 as *const libc::c_char,
34452            type_0: ARG_TYPE_STRING,
34453            key_spec_index: 0,
34454            token: 0 as *const libc::c_char,
34455            summary: 0 as *const libc::c_char,
34456            since: 0 as *const libc::c_char,
34457            flags: 0,
34458            deprecated_since: 0 as *const libc::c_char,
34459            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34460            num_args: 0,
34461        };
34462        init
34463    },
34464];
34465#[no_mangle]
34466pub static mut XADD_History: [commandHistory; 3] = [
34467    {
34468        let mut init = commandHistory {
34469            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
34470            changes: b"Added the `NOMKSTREAM` option, `MINID` trimming strategy and the `LIMIT` option.\0"
34471                as *const u8 as *const libc::c_char,
34472        };
34473        init
34474    },
34475    {
34476        let mut init = commandHistory {
34477            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
34478            changes: b"Added support for the `<ms>-*` explicit ID form.\0" as *const u8
34479                as *const libc::c_char,
34480        };
34481        init
34482    },
34483    {
34484        let mut init = commandHistory {
34485            since: 0 as *const libc::c_char,
34486            changes: 0 as *const libc::c_char,
34487        };
34488        init
34489    },
34490];
34491#[no_mangle]
34492pub static mut XADD_tips: [*const libc::c_char; 2] = [
34493    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
34494    0 as *const libc::c_char,
34495];
34496#[no_mangle]
34497pub static mut XADD_trim_strategy_Subargs: [redisCommandArg; 3] = [
34498    {
34499        let mut init = redisCommandArg {
34500            name: b"maxlen\0" as *const u8 as *const libc::c_char,
34501            type_0: ARG_TYPE_PURE_TOKEN,
34502            key_spec_index: -(1 as libc::c_int),
34503            token: b"MAXLEN\0" as *const u8 as *const libc::c_char,
34504            summary: 0 as *const libc::c_char,
34505            since: 0 as *const libc::c_char,
34506            flags: 0 as libc::c_int,
34507            deprecated_since: 0 as *const libc::c_char,
34508            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34509            num_args: 0,
34510        };
34511        init
34512    },
34513    {
34514        let mut init = redisCommandArg {
34515            name: b"minid\0" as *const u8 as *const libc::c_char,
34516            type_0: ARG_TYPE_PURE_TOKEN,
34517            key_spec_index: -(1 as libc::c_int),
34518            token: b"MINID\0" as *const u8 as *const libc::c_char,
34519            summary: 0 as *const libc::c_char,
34520            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
34521            flags: 0 as libc::c_int,
34522            deprecated_since: 0 as *const libc::c_char,
34523            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34524            num_args: 0,
34525        };
34526        init
34527    },
34528    {
34529        let mut init = redisCommandArg {
34530            name: 0 as *const libc::c_char,
34531            type_0: ARG_TYPE_STRING,
34532            key_spec_index: 0,
34533            token: 0 as *const libc::c_char,
34534            summary: 0 as *const libc::c_char,
34535            since: 0 as *const libc::c_char,
34536            flags: 0,
34537            deprecated_since: 0 as *const libc::c_char,
34538            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34539            num_args: 0,
34540        };
34541        init
34542    },
34543];
34544#[no_mangle]
34545pub static mut XADD_trim_operator_Subargs: [redisCommandArg; 3] = [
34546    {
34547        let mut init = redisCommandArg {
34548            name: b"equal\0" as *const u8 as *const libc::c_char,
34549            type_0: ARG_TYPE_PURE_TOKEN,
34550            key_spec_index: -(1 as libc::c_int),
34551            token: b"=\0" as *const u8 as *const libc::c_char,
34552            summary: 0 as *const libc::c_char,
34553            since: 0 as *const libc::c_char,
34554            flags: 0 as libc::c_int,
34555            deprecated_since: 0 as *const libc::c_char,
34556            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34557            num_args: 0,
34558        };
34559        init
34560    },
34561    {
34562        let mut init = redisCommandArg {
34563            name: b"approximately\0" as *const u8 as *const libc::c_char,
34564            type_0: ARG_TYPE_PURE_TOKEN,
34565            key_spec_index: -(1 as libc::c_int),
34566            token: b"~\0" as *const u8 as *const libc::c_char,
34567            summary: 0 as *const libc::c_char,
34568            since: 0 as *const libc::c_char,
34569            flags: 0 as libc::c_int,
34570            deprecated_since: 0 as *const libc::c_char,
34571            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34572            num_args: 0,
34573        };
34574        init
34575    },
34576    {
34577        let mut init = redisCommandArg {
34578            name: 0 as *const libc::c_char,
34579            type_0: ARG_TYPE_STRING,
34580            key_spec_index: 0,
34581            token: 0 as *const libc::c_char,
34582            summary: 0 as *const libc::c_char,
34583            since: 0 as *const libc::c_char,
34584            flags: 0,
34585            deprecated_since: 0 as *const libc::c_char,
34586            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34587            num_args: 0,
34588        };
34589        init
34590    },
34591];
34592#[no_mangle]
34593pub static mut XADD_trim_Subargs: [redisCommandArg; 5] = unsafe {
34594    [
34595        {
34596            let mut init = redisCommandArg {
34597                name: b"strategy\0" as *const u8 as *const libc::c_char,
34598                type_0: ARG_TYPE_ONEOF,
34599                key_spec_index: -(1 as libc::c_int),
34600                token: 0 as *const libc::c_char,
34601                summary: 0 as *const libc::c_char,
34602                since: 0 as *const libc::c_char,
34603                flags: 0 as libc::c_int,
34604                deprecated_since: 0 as *const libc::c_char,
34605                subargs: XADD_trim_strategy_Subargs.as_ptr() as *mut _,
34606                num_args: 0,
34607            };
34608            init
34609        },
34610        {
34611            let mut init = redisCommandArg {
34612                name: b"operator\0" as *const u8 as *const libc::c_char,
34613                type_0: ARG_TYPE_ONEOF,
34614                key_spec_index: -(1 as libc::c_int),
34615                token: 0 as *const libc::c_char,
34616                summary: 0 as *const libc::c_char,
34617                since: 0 as *const libc::c_char,
34618                flags: (1 as libc::c_int) << 0 as libc::c_int,
34619                deprecated_since: 0 as *const libc::c_char,
34620                subargs: XADD_trim_operator_Subargs.as_ptr() as *mut _,
34621                num_args: 0,
34622            };
34623            init
34624        },
34625        {
34626            let mut init = redisCommandArg {
34627                name: b"threshold\0" as *const u8 as *const libc::c_char,
34628                type_0: ARG_TYPE_STRING,
34629                key_spec_index: -(1 as libc::c_int),
34630                token: 0 as *const libc::c_char,
34631                summary: 0 as *const libc::c_char,
34632                since: 0 as *const libc::c_char,
34633                flags: 0 as libc::c_int,
34634                deprecated_since: 0 as *const libc::c_char,
34635                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34636                num_args: 0,
34637            };
34638            init
34639        },
34640        {
34641            let mut init = redisCommandArg {
34642                name: b"count\0" as *const u8 as *const libc::c_char,
34643                type_0: ARG_TYPE_INTEGER,
34644                key_spec_index: -(1 as libc::c_int),
34645                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
34646                summary: 0 as *const libc::c_char,
34647                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
34648                flags: (1 as libc::c_int) << 0 as libc::c_int,
34649                deprecated_since: 0 as *const libc::c_char,
34650                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34651                num_args: 0,
34652            };
34653            init
34654        },
34655        {
34656            let mut init = redisCommandArg {
34657                name: 0 as *const libc::c_char,
34658                type_0: ARG_TYPE_STRING,
34659                key_spec_index: 0,
34660                token: 0 as *const libc::c_char,
34661                summary: 0 as *const libc::c_char,
34662                since: 0 as *const libc::c_char,
34663                flags: 0,
34664                deprecated_since: 0 as *const libc::c_char,
34665                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34666                num_args: 0,
34667            };
34668            init
34669        },
34670    ]
34671};
34672#[no_mangle]
34673pub static mut XADD_id_or_auto_Subargs: [redisCommandArg; 3] = [
34674    {
34675        let mut init = redisCommandArg {
34676            name: b"auto_id\0" as *const u8 as *const libc::c_char,
34677            type_0: ARG_TYPE_PURE_TOKEN,
34678            key_spec_index: -(1 as libc::c_int),
34679            token: b"*\0" as *const u8 as *const libc::c_char,
34680            summary: 0 as *const libc::c_char,
34681            since: 0 as *const libc::c_char,
34682            flags: 0 as libc::c_int,
34683            deprecated_since: 0 as *const libc::c_char,
34684            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34685            num_args: 0,
34686        };
34687        init
34688    },
34689    {
34690        let mut init = redisCommandArg {
34691            name: b"id\0" as *const u8 as *const libc::c_char,
34692            type_0: ARG_TYPE_STRING,
34693            key_spec_index: -(1 as libc::c_int),
34694            token: 0 as *const libc::c_char,
34695            summary: 0 as *const libc::c_char,
34696            since: 0 as *const libc::c_char,
34697            flags: 0 as libc::c_int,
34698            deprecated_since: 0 as *const libc::c_char,
34699            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34700            num_args: 0,
34701        };
34702        init
34703    },
34704    {
34705        let mut init = redisCommandArg {
34706            name: 0 as *const libc::c_char,
34707            type_0: ARG_TYPE_STRING,
34708            key_spec_index: 0,
34709            token: 0 as *const libc::c_char,
34710            summary: 0 as *const libc::c_char,
34711            since: 0 as *const libc::c_char,
34712            flags: 0,
34713            deprecated_since: 0 as *const libc::c_char,
34714            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34715            num_args: 0,
34716        };
34717        init
34718    },
34719];
34720#[no_mangle]
34721pub static mut XADD_field_value_Subargs: [redisCommandArg; 3] = [
34722    {
34723        let mut init = redisCommandArg {
34724            name: b"field\0" as *const u8 as *const libc::c_char,
34725            type_0: ARG_TYPE_STRING,
34726            key_spec_index: -(1 as libc::c_int),
34727            token: 0 as *const libc::c_char,
34728            summary: 0 as *const libc::c_char,
34729            since: 0 as *const libc::c_char,
34730            flags: 0 as libc::c_int,
34731            deprecated_since: 0 as *const libc::c_char,
34732            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34733            num_args: 0,
34734        };
34735        init
34736    },
34737    {
34738        let mut init = redisCommandArg {
34739            name: b"value\0" as *const u8 as *const libc::c_char,
34740            type_0: ARG_TYPE_STRING,
34741            key_spec_index: -(1 as libc::c_int),
34742            token: 0 as *const libc::c_char,
34743            summary: 0 as *const libc::c_char,
34744            since: 0 as *const libc::c_char,
34745            flags: 0 as libc::c_int,
34746            deprecated_since: 0 as *const libc::c_char,
34747            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34748            num_args: 0,
34749        };
34750        init
34751    },
34752    {
34753        let mut init = redisCommandArg {
34754            name: 0 as *const libc::c_char,
34755            type_0: ARG_TYPE_STRING,
34756            key_spec_index: 0,
34757            token: 0 as *const libc::c_char,
34758            summary: 0 as *const libc::c_char,
34759            since: 0 as *const libc::c_char,
34760            flags: 0,
34761            deprecated_since: 0 as *const libc::c_char,
34762            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34763            num_args: 0,
34764        };
34765        init
34766    },
34767];
34768#[no_mangle]
34769pub static mut XADD_Args: [redisCommandArg; 6] = unsafe {
34770    [
34771        {
34772            let mut init = redisCommandArg {
34773                name: b"key\0" as *const u8 as *const libc::c_char,
34774                type_0: ARG_TYPE_KEY,
34775                key_spec_index: 0 as libc::c_int,
34776                token: 0 as *const libc::c_char,
34777                summary: 0 as *const libc::c_char,
34778                since: 0 as *const libc::c_char,
34779                flags: 0 as libc::c_int,
34780                deprecated_since: 0 as *const libc::c_char,
34781                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34782                num_args: 0,
34783            };
34784            init
34785        },
34786        {
34787            let mut init = redisCommandArg {
34788                name: b"nomkstream\0" as *const u8 as *const libc::c_char,
34789                type_0: ARG_TYPE_PURE_TOKEN,
34790                key_spec_index: -(1 as libc::c_int),
34791                token: b"NOMKSTREAM\0" as *const u8 as *const libc::c_char,
34792                summary: 0 as *const libc::c_char,
34793                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
34794                flags: (1 as libc::c_int) << 0 as libc::c_int,
34795                deprecated_since: 0 as *const libc::c_char,
34796                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34797                num_args: 0,
34798            };
34799            init
34800        },
34801        {
34802            let mut init = redisCommandArg {
34803                name: b"trim\0" as *const u8 as *const libc::c_char,
34804                type_0: ARG_TYPE_BLOCK,
34805                key_spec_index: -(1 as libc::c_int),
34806                token: 0 as *const libc::c_char,
34807                summary: 0 as *const libc::c_char,
34808                since: 0 as *const libc::c_char,
34809                flags: (1 as libc::c_int) << 0 as libc::c_int,
34810                deprecated_since: 0 as *const libc::c_char,
34811                subargs: XADD_trim_Subargs.as_ptr() as *mut _,
34812                num_args: 0,
34813            };
34814            init
34815        },
34816        {
34817            let mut init = redisCommandArg {
34818                name: b"id_or_auto\0" as *const u8 as *const libc::c_char,
34819                type_0: ARG_TYPE_ONEOF,
34820                key_spec_index: -(1 as libc::c_int),
34821                token: 0 as *const libc::c_char,
34822                summary: 0 as *const libc::c_char,
34823                since: 0 as *const libc::c_char,
34824                flags: 0 as libc::c_int,
34825                deprecated_since: 0 as *const libc::c_char,
34826                subargs: XADD_id_or_auto_Subargs.as_ptr() as *mut _,
34827                num_args: 0,
34828            };
34829            init
34830        },
34831        {
34832            let mut init = redisCommandArg {
34833                name: b"field_value\0" as *const u8 as *const libc::c_char,
34834                type_0: ARG_TYPE_BLOCK,
34835                key_spec_index: -(1 as libc::c_int),
34836                token: 0 as *const libc::c_char,
34837                summary: 0 as *const libc::c_char,
34838                since: 0 as *const libc::c_char,
34839                flags: (1 as libc::c_int) << 1 as libc::c_int,
34840                deprecated_since: 0 as *const libc::c_char,
34841                subargs: XADD_field_value_Subargs.as_ptr() as *mut _,
34842                num_args: 0,
34843            };
34844            init
34845        },
34846        {
34847            let mut init = redisCommandArg {
34848                name: 0 as *const libc::c_char,
34849                type_0: ARG_TYPE_STRING,
34850                key_spec_index: 0,
34851                token: 0 as *const libc::c_char,
34852                summary: 0 as *const libc::c_char,
34853                since: 0 as *const libc::c_char,
34854                flags: 0,
34855                deprecated_since: 0 as *const libc::c_char,
34856                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34857                num_args: 0,
34858            };
34859            init
34860        },
34861    ]
34862};
34863#[no_mangle]
34864pub static mut XAUTOCLAIM_History: [commandHistory; 2] = [
34865    {
34866        let mut init = commandHistory {
34867            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
34868            changes: b"Added an element to the reply array, containing deleted entries the command cleared from the PEL\0"
34869                as *const u8 as *const libc::c_char,
34870        };
34871        init
34872    },
34873    {
34874        let mut init = commandHistory {
34875            since: 0 as *const libc::c_char,
34876            changes: 0 as *const libc::c_char,
34877        };
34878        init
34879    },
34880];
34881#[no_mangle]
34882pub static mut XAUTOCLAIM_tips: [*const libc::c_char; 2] = [
34883    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
34884    0 as *const libc::c_char,
34885];
34886#[no_mangle]
34887pub static mut XAUTOCLAIM_Args: [redisCommandArg; 8] = [
34888    {
34889        let mut init = redisCommandArg {
34890            name: b"key\0" as *const u8 as *const libc::c_char,
34891            type_0: ARG_TYPE_KEY,
34892            key_spec_index: 0 as libc::c_int,
34893            token: 0 as *const libc::c_char,
34894            summary: 0 as *const libc::c_char,
34895            since: 0 as *const libc::c_char,
34896            flags: 0 as libc::c_int,
34897            deprecated_since: 0 as *const libc::c_char,
34898            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34899            num_args: 0,
34900        };
34901        init
34902    },
34903    {
34904        let mut init = redisCommandArg {
34905            name: b"group\0" as *const u8 as *const libc::c_char,
34906            type_0: ARG_TYPE_STRING,
34907            key_spec_index: -(1 as libc::c_int),
34908            token: 0 as *const libc::c_char,
34909            summary: 0 as *const libc::c_char,
34910            since: 0 as *const libc::c_char,
34911            flags: 0 as libc::c_int,
34912            deprecated_since: 0 as *const libc::c_char,
34913            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34914            num_args: 0,
34915        };
34916        init
34917    },
34918    {
34919        let mut init = redisCommandArg {
34920            name: b"consumer\0" as *const u8 as *const libc::c_char,
34921            type_0: ARG_TYPE_STRING,
34922            key_spec_index: -(1 as libc::c_int),
34923            token: 0 as *const libc::c_char,
34924            summary: 0 as *const libc::c_char,
34925            since: 0 as *const libc::c_char,
34926            flags: 0 as libc::c_int,
34927            deprecated_since: 0 as *const libc::c_char,
34928            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34929            num_args: 0,
34930        };
34931        init
34932    },
34933    {
34934        let mut init = redisCommandArg {
34935            name: b"min-idle-time\0" as *const u8 as *const libc::c_char,
34936            type_0: ARG_TYPE_STRING,
34937            key_spec_index: -(1 as libc::c_int),
34938            token: 0 as *const libc::c_char,
34939            summary: 0 as *const libc::c_char,
34940            since: 0 as *const libc::c_char,
34941            flags: 0 as libc::c_int,
34942            deprecated_since: 0 as *const libc::c_char,
34943            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34944            num_args: 0,
34945        };
34946        init
34947    },
34948    {
34949        let mut init = redisCommandArg {
34950            name: b"start\0" as *const u8 as *const libc::c_char,
34951            type_0: ARG_TYPE_STRING,
34952            key_spec_index: -(1 as libc::c_int),
34953            token: 0 as *const libc::c_char,
34954            summary: 0 as *const libc::c_char,
34955            since: 0 as *const libc::c_char,
34956            flags: 0 as libc::c_int,
34957            deprecated_since: 0 as *const libc::c_char,
34958            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34959            num_args: 0,
34960        };
34961        init
34962    },
34963    {
34964        let mut init = redisCommandArg {
34965            name: b"count\0" as *const u8 as *const libc::c_char,
34966            type_0: ARG_TYPE_INTEGER,
34967            key_spec_index: -(1 as libc::c_int),
34968            token: b"COUNT\0" as *const u8 as *const libc::c_char,
34969            summary: 0 as *const libc::c_char,
34970            since: 0 as *const libc::c_char,
34971            flags: (1 as libc::c_int) << 0 as libc::c_int,
34972            deprecated_since: 0 as *const libc::c_char,
34973            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34974            num_args: 0,
34975        };
34976        init
34977    },
34978    {
34979        let mut init = redisCommandArg {
34980            name: b"justid\0" as *const u8 as *const libc::c_char,
34981            type_0: ARG_TYPE_PURE_TOKEN,
34982            key_spec_index: -(1 as libc::c_int),
34983            token: b"JUSTID\0" as *const u8 as *const libc::c_char,
34984            summary: 0 as *const libc::c_char,
34985            since: 0 as *const libc::c_char,
34986            flags: (1 as libc::c_int) << 0 as libc::c_int,
34987            deprecated_since: 0 as *const libc::c_char,
34988            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
34989            num_args: 0,
34990        };
34991        init
34992    },
34993    {
34994        let mut init = redisCommandArg {
34995            name: 0 as *const libc::c_char,
34996            type_0: ARG_TYPE_STRING,
34997            key_spec_index: 0,
34998            token: 0 as *const libc::c_char,
34999            summary: 0 as *const libc::c_char,
35000            since: 0 as *const libc::c_char,
35001            flags: 0,
35002            deprecated_since: 0 as *const libc::c_char,
35003            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35004            num_args: 0,
35005        };
35006        init
35007    },
35008];
35009#[no_mangle]
35010pub static mut XCLAIM_tips: [*const libc::c_char; 2] = [
35011    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
35012    0 as *const libc::c_char,
35013];
35014#[no_mangle]
35015pub static mut XCLAIM_Args: [redisCommandArg; 12] = [
35016    {
35017        let mut init = redisCommandArg {
35018            name: b"key\0" as *const u8 as *const libc::c_char,
35019            type_0: ARG_TYPE_KEY,
35020            key_spec_index: 0 as libc::c_int,
35021            token: 0 as *const libc::c_char,
35022            summary: 0 as *const libc::c_char,
35023            since: 0 as *const libc::c_char,
35024            flags: 0 as libc::c_int,
35025            deprecated_since: 0 as *const libc::c_char,
35026            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35027            num_args: 0,
35028        };
35029        init
35030    },
35031    {
35032        let mut init = redisCommandArg {
35033            name: b"group\0" as *const u8 as *const libc::c_char,
35034            type_0: ARG_TYPE_STRING,
35035            key_spec_index: -(1 as libc::c_int),
35036            token: 0 as *const libc::c_char,
35037            summary: 0 as *const libc::c_char,
35038            since: 0 as *const libc::c_char,
35039            flags: 0 as libc::c_int,
35040            deprecated_since: 0 as *const libc::c_char,
35041            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35042            num_args: 0,
35043        };
35044        init
35045    },
35046    {
35047        let mut init = redisCommandArg {
35048            name: b"consumer\0" as *const u8 as *const libc::c_char,
35049            type_0: ARG_TYPE_STRING,
35050            key_spec_index: -(1 as libc::c_int),
35051            token: 0 as *const libc::c_char,
35052            summary: 0 as *const libc::c_char,
35053            since: 0 as *const libc::c_char,
35054            flags: 0 as libc::c_int,
35055            deprecated_since: 0 as *const libc::c_char,
35056            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35057            num_args: 0,
35058        };
35059        init
35060    },
35061    {
35062        let mut init = redisCommandArg {
35063            name: b"min-idle-time\0" as *const u8 as *const libc::c_char,
35064            type_0: ARG_TYPE_STRING,
35065            key_spec_index: -(1 as libc::c_int),
35066            token: 0 as *const libc::c_char,
35067            summary: 0 as *const libc::c_char,
35068            since: 0 as *const libc::c_char,
35069            flags: 0 as libc::c_int,
35070            deprecated_since: 0 as *const libc::c_char,
35071            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35072            num_args: 0,
35073        };
35074        init
35075    },
35076    {
35077        let mut init = redisCommandArg {
35078            name: b"id\0" as *const u8 as *const libc::c_char,
35079            type_0: ARG_TYPE_STRING,
35080            key_spec_index: -(1 as libc::c_int),
35081            token: 0 as *const libc::c_char,
35082            summary: 0 as *const libc::c_char,
35083            since: 0 as *const libc::c_char,
35084            flags: (1 as libc::c_int) << 1 as libc::c_int,
35085            deprecated_since: 0 as *const libc::c_char,
35086            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35087            num_args: 0,
35088        };
35089        init
35090    },
35091    {
35092        let mut init = redisCommandArg {
35093            name: b"ms\0" as *const u8 as *const libc::c_char,
35094            type_0: ARG_TYPE_INTEGER,
35095            key_spec_index: -(1 as libc::c_int),
35096            token: b"IDLE\0" as *const u8 as *const libc::c_char,
35097            summary: 0 as *const libc::c_char,
35098            since: 0 as *const libc::c_char,
35099            flags: (1 as libc::c_int) << 0 as libc::c_int,
35100            deprecated_since: 0 as *const libc::c_char,
35101            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35102            num_args: 0,
35103        };
35104        init
35105    },
35106    {
35107        let mut init = redisCommandArg {
35108            name: b"unix-time-milliseconds\0" as *const u8 as *const libc::c_char,
35109            type_0: ARG_TYPE_UNIX_TIME,
35110            key_spec_index: -(1 as libc::c_int),
35111            token: b"TIME\0" as *const u8 as *const libc::c_char,
35112            summary: 0 as *const libc::c_char,
35113            since: 0 as *const libc::c_char,
35114            flags: (1 as libc::c_int) << 0 as libc::c_int,
35115            deprecated_since: 0 as *const libc::c_char,
35116            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35117            num_args: 0,
35118        };
35119        init
35120    },
35121    {
35122        let mut init = redisCommandArg {
35123            name: b"count\0" as *const u8 as *const libc::c_char,
35124            type_0: ARG_TYPE_INTEGER,
35125            key_spec_index: -(1 as libc::c_int),
35126            token: b"RETRYCOUNT\0" as *const u8 as *const libc::c_char,
35127            summary: 0 as *const libc::c_char,
35128            since: 0 as *const libc::c_char,
35129            flags: (1 as libc::c_int) << 0 as libc::c_int,
35130            deprecated_since: 0 as *const libc::c_char,
35131            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35132            num_args: 0,
35133        };
35134        init
35135    },
35136    {
35137        let mut init = redisCommandArg {
35138            name: b"force\0" as *const u8 as *const libc::c_char,
35139            type_0: ARG_TYPE_PURE_TOKEN,
35140            key_spec_index: -(1 as libc::c_int),
35141            token: b"FORCE\0" as *const u8 as *const libc::c_char,
35142            summary: 0 as *const libc::c_char,
35143            since: 0 as *const libc::c_char,
35144            flags: (1 as libc::c_int) << 0 as libc::c_int,
35145            deprecated_since: 0 as *const libc::c_char,
35146            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35147            num_args: 0,
35148        };
35149        init
35150    },
35151    {
35152        let mut init = redisCommandArg {
35153            name: b"justid\0" as *const u8 as *const libc::c_char,
35154            type_0: ARG_TYPE_PURE_TOKEN,
35155            key_spec_index: -(1 as libc::c_int),
35156            token: b"JUSTID\0" as *const u8 as *const libc::c_char,
35157            summary: 0 as *const libc::c_char,
35158            since: 0 as *const libc::c_char,
35159            flags: (1 as libc::c_int) << 0 as libc::c_int,
35160            deprecated_since: 0 as *const libc::c_char,
35161            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35162            num_args: 0,
35163        };
35164        init
35165    },
35166    {
35167        let mut init = redisCommandArg {
35168            name: b"id\0" as *const u8 as *const libc::c_char,
35169            type_0: ARG_TYPE_STRING,
35170            key_spec_index: -(1 as libc::c_int),
35171            token: b"LASTID\0" as *const u8 as *const libc::c_char,
35172            summary: 0 as *const libc::c_char,
35173            since: 0 as *const libc::c_char,
35174            flags: (1 as libc::c_int) << 0 as libc::c_int,
35175            deprecated_since: 0 as *const libc::c_char,
35176            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35177            num_args: 0,
35178        };
35179        init
35180    },
35181    {
35182        let mut init = redisCommandArg {
35183            name: 0 as *const libc::c_char,
35184            type_0: ARG_TYPE_STRING,
35185            key_spec_index: 0,
35186            token: 0 as *const libc::c_char,
35187            summary: 0 as *const libc::c_char,
35188            since: 0 as *const libc::c_char,
35189            flags: 0,
35190            deprecated_since: 0 as *const libc::c_char,
35191            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35192            num_args: 0,
35193        };
35194        init
35195    },
35196];
35197#[no_mangle]
35198pub static mut XDEL_Args: [redisCommandArg; 3] = [
35199    {
35200        let mut init = redisCommandArg {
35201            name: b"key\0" as *const u8 as *const libc::c_char,
35202            type_0: ARG_TYPE_KEY,
35203            key_spec_index: 0 as libc::c_int,
35204            token: 0 as *const libc::c_char,
35205            summary: 0 as *const libc::c_char,
35206            since: 0 as *const libc::c_char,
35207            flags: 0 as libc::c_int,
35208            deprecated_since: 0 as *const libc::c_char,
35209            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35210            num_args: 0,
35211        };
35212        init
35213    },
35214    {
35215        let mut init = redisCommandArg {
35216            name: b"id\0" as *const u8 as *const libc::c_char,
35217            type_0: ARG_TYPE_STRING,
35218            key_spec_index: -(1 as libc::c_int),
35219            token: 0 as *const libc::c_char,
35220            summary: 0 as *const libc::c_char,
35221            since: 0 as *const libc::c_char,
35222            flags: (1 as libc::c_int) << 1 as libc::c_int,
35223            deprecated_since: 0 as *const libc::c_char,
35224            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35225            num_args: 0,
35226        };
35227        init
35228    },
35229    {
35230        let mut init = redisCommandArg {
35231            name: 0 as *const libc::c_char,
35232            type_0: ARG_TYPE_STRING,
35233            key_spec_index: 0,
35234            token: 0 as *const libc::c_char,
35235            summary: 0 as *const libc::c_char,
35236            since: 0 as *const libc::c_char,
35237            flags: 0,
35238            deprecated_since: 0 as *const libc::c_char,
35239            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35240            num_args: 0,
35241        };
35242        init
35243    },
35244];
35245#[no_mangle]
35246pub static mut XGROUP_CREATE_History: [commandHistory; 2] = [
35247    {
35248        let mut init = commandHistory {
35249            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
35250            changes: b"Added the `entries_read` named argument.\0" as *const u8
35251                as *const libc::c_char,
35252        };
35253        init
35254    },
35255    {
35256        let mut init = commandHistory {
35257            since: 0 as *const libc::c_char,
35258            changes: 0 as *const libc::c_char,
35259        };
35260        init
35261    },
35262];
35263#[no_mangle]
35264pub static mut XGROUP_CREATE_id_Subargs: [redisCommandArg; 3] = [
35265    {
35266        let mut init = redisCommandArg {
35267            name: b"id\0" as *const u8 as *const libc::c_char,
35268            type_0: ARG_TYPE_STRING,
35269            key_spec_index: -(1 as libc::c_int),
35270            token: 0 as *const libc::c_char,
35271            summary: 0 as *const libc::c_char,
35272            since: 0 as *const libc::c_char,
35273            flags: 0 as libc::c_int,
35274            deprecated_since: 0 as *const libc::c_char,
35275            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35276            num_args: 0,
35277        };
35278        init
35279    },
35280    {
35281        let mut init = redisCommandArg {
35282            name: b"new_id\0" as *const u8 as *const libc::c_char,
35283            type_0: ARG_TYPE_PURE_TOKEN,
35284            key_spec_index: -(1 as libc::c_int),
35285            token: b"$\0" as *const u8 as *const libc::c_char,
35286            summary: 0 as *const libc::c_char,
35287            since: 0 as *const libc::c_char,
35288            flags: 0 as libc::c_int,
35289            deprecated_since: 0 as *const libc::c_char,
35290            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35291            num_args: 0,
35292        };
35293        init
35294    },
35295    {
35296        let mut init = redisCommandArg {
35297            name: 0 as *const libc::c_char,
35298            type_0: ARG_TYPE_STRING,
35299            key_spec_index: 0,
35300            token: 0 as *const libc::c_char,
35301            summary: 0 as *const libc::c_char,
35302            since: 0 as *const libc::c_char,
35303            flags: 0,
35304            deprecated_since: 0 as *const libc::c_char,
35305            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35306            num_args: 0,
35307        };
35308        init
35309    },
35310];
35311#[no_mangle]
35312pub static mut XGROUP_CREATE_Args: [redisCommandArg; 6] = unsafe {
35313    [
35314        {
35315            let mut init = redisCommandArg {
35316                name: b"key\0" as *const u8 as *const libc::c_char,
35317                type_0: ARG_TYPE_KEY,
35318                key_spec_index: 0 as libc::c_int,
35319                token: 0 as *const libc::c_char,
35320                summary: 0 as *const libc::c_char,
35321                since: 0 as *const libc::c_char,
35322                flags: 0 as libc::c_int,
35323                deprecated_since: 0 as *const libc::c_char,
35324                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35325                num_args: 0,
35326            };
35327            init
35328        },
35329        {
35330            let mut init = redisCommandArg {
35331                name: b"groupname\0" as *const u8 as *const libc::c_char,
35332                type_0: ARG_TYPE_STRING,
35333                key_spec_index: -(1 as libc::c_int),
35334                token: 0 as *const libc::c_char,
35335                summary: 0 as *const libc::c_char,
35336                since: 0 as *const libc::c_char,
35337                flags: 0 as libc::c_int,
35338                deprecated_since: 0 as *const libc::c_char,
35339                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35340                num_args: 0,
35341            };
35342            init
35343        },
35344        {
35345            let mut init = redisCommandArg {
35346                name: b"id\0" as *const u8 as *const libc::c_char,
35347                type_0: ARG_TYPE_ONEOF,
35348                key_spec_index: -(1 as libc::c_int),
35349                token: 0 as *const libc::c_char,
35350                summary: 0 as *const libc::c_char,
35351                since: 0 as *const libc::c_char,
35352                flags: 0 as libc::c_int,
35353                deprecated_since: 0 as *const libc::c_char,
35354                subargs: XGROUP_CREATE_id_Subargs.as_ptr() as *mut _,
35355                num_args: 0,
35356            };
35357            init
35358        },
35359        {
35360            let mut init = redisCommandArg {
35361                name: b"mkstream\0" as *const u8 as *const libc::c_char,
35362                type_0: ARG_TYPE_PURE_TOKEN,
35363                key_spec_index: -(1 as libc::c_int),
35364                token: b"MKSTREAM\0" as *const u8 as *const libc::c_char,
35365                summary: 0 as *const libc::c_char,
35366                since: 0 as *const libc::c_char,
35367                flags: (1 as libc::c_int) << 0 as libc::c_int,
35368                deprecated_since: 0 as *const libc::c_char,
35369                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35370                num_args: 0,
35371            };
35372            init
35373        },
35374        {
35375            let mut init = redisCommandArg {
35376                name: b"entries_read\0" as *const u8 as *const libc::c_char,
35377                type_0: ARG_TYPE_INTEGER,
35378                key_spec_index: -(1 as libc::c_int),
35379                token: b"ENTRIESREAD\0" as *const u8 as *const libc::c_char,
35380                summary: 0 as *const libc::c_char,
35381                since: 0 as *const libc::c_char,
35382                flags: (1 as libc::c_int) << 0 as libc::c_int,
35383                deprecated_since: 0 as *const libc::c_char,
35384                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35385                num_args: 0,
35386            };
35387            init
35388        },
35389        {
35390            let mut init = redisCommandArg {
35391                name: 0 as *const libc::c_char,
35392                type_0: ARG_TYPE_STRING,
35393                key_spec_index: 0,
35394                token: 0 as *const libc::c_char,
35395                summary: 0 as *const libc::c_char,
35396                since: 0 as *const libc::c_char,
35397                flags: 0,
35398                deprecated_since: 0 as *const libc::c_char,
35399                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35400                num_args: 0,
35401            };
35402            init
35403        },
35404    ]
35405};
35406#[no_mangle]
35407pub static mut XGROUP_CREATECONSUMER_Args: [redisCommandArg; 4] = [
35408    {
35409        let mut init = redisCommandArg {
35410            name: b"key\0" as *const u8 as *const libc::c_char,
35411            type_0: ARG_TYPE_KEY,
35412            key_spec_index: 0 as libc::c_int,
35413            token: 0 as *const libc::c_char,
35414            summary: 0 as *const libc::c_char,
35415            since: 0 as *const libc::c_char,
35416            flags: 0 as libc::c_int,
35417            deprecated_since: 0 as *const libc::c_char,
35418            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35419            num_args: 0,
35420        };
35421        init
35422    },
35423    {
35424        let mut init = redisCommandArg {
35425            name: b"groupname\0" as *const u8 as *const libc::c_char,
35426            type_0: ARG_TYPE_STRING,
35427            key_spec_index: -(1 as libc::c_int),
35428            token: 0 as *const libc::c_char,
35429            summary: 0 as *const libc::c_char,
35430            since: 0 as *const libc::c_char,
35431            flags: 0 as libc::c_int,
35432            deprecated_since: 0 as *const libc::c_char,
35433            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35434            num_args: 0,
35435        };
35436        init
35437    },
35438    {
35439        let mut init = redisCommandArg {
35440            name: b"consumername\0" as *const u8 as *const libc::c_char,
35441            type_0: ARG_TYPE_STRING,
35442            key_spec_index: -(1 as libc::c_int),
35443            token: 0 as *const libc::c_char,
35444            summary: 0 as *const libc::c_char,
35445            since: 0 as *const libc::c_char,
35446            flags: 0 as libc::c_int,
35447            deprecated_since: 0 as *const libc::c_char,
35448            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35449            num_args: 0,
35450        };
35451        init
35452    },
35453    {
35454        let mut init = redisCommandArg {
35455            name: 0 as *const libc::c_char,
35456            type_0: ARG_TYPE_STRING,
35457            key_spec_index: 0,
35458            token: 0 as *const libc::c_char,
35459            summary: 0 as *const libc::c_char,
35460            since: 0 as *const libc::c_char,
35461            flags: 0,
35462            deprecated_since: 0 as *const libc::c_char,
35463            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35464            num_args: 0,
35465        };
35466        init
35467    },
35468];
35469#[no_mangle]
35470pub static mut XGROUP_DELCONSUMER_Args: [redisCommandArg; 4] = [
35471    {
35472        let mut init = redisCommandArg {
35473            name: b"key\0" as *const u8 as *const libc::c_char,
35474            type_0: ARG_TYPE_KEY,
35475            key_spec_index: 0 as libc::c_int,
35476            token: 0 as *const libc::c_char,
35477            summary: 0 as *const libc::c_char,
35478            since: 0 as *const libc::c_char,
35479            flags: 0 as libc::c_int,
35480            deprecated_since: 0 as *const libc::c_char,
35481            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35482            num_args: 0,
35483        };
35484        init
35485    },
35486    {
35487        let mut init = redisCommandArg {
35488            name: b"groupname\0" as *const u8 as *const libc::c_char,
35489            type_0: ARG_TYPE_STRING,
35490            key_spec_index: -(1 as libc::c_int),
35491            token: 0 as *const libc::c_char,
35492            summary: 0 as *const libc::c_char,
35493            since: 0 as *const libc::c_char,
35494            flags: 0 as libc::c_int,
35495            deprecated_since: 0 as *const libc::c_char,
35496            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35497            num_args: 0,
35498        };
35499        init
35500    },
35501    {
35502        let mut init = redisCommandArg {
35503            name: b"consumername\0" as *const u8 as *const libc::c_char,
35504            type_0: ARG_TYPE_STRING,
35505            key_spec_index: -(1 as libc::c_int),
35506            token: 0 as *const libc::c_char,
35507            summary: 0 as *const libc::c_char,
35508            since: 0 as *const libc::c_char,
35509            flags: 0 as libc::c_int,
35510            deprecated_since: 0 as *const libc::c_char,
35511            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35512            num_args: 0,
35513        };
35514        init
35515    },
35516    {
35517        let mut init = redisCommandArg {
35518            name: 0 as *const libc::c_char,
35519            type_0: ARG_TYPE_STRING,
35520            key_spec_index: 0,
35521            token: 0 as *const libc::c_char,
35522            summary: 0 as *const libc::c_char,
35523            since: 0 as *const libc::c_char,
35524            flags: 0,
35525            deprecated_since: 0 as *const libc::c_char,
35526            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35527            num_args: 0,
35528        };
35529        init
35530    },
35531];
35532#[no_mangle]
35533pub static mut XGROUP_DESTROY_Args: [redisCommandArg; 3] = [
35534    {
35535        let mut init = redisCommandArg {
35536            name: b"key\0" as *const u8 as *const libc::c_char,
35537            type_0: ARG_TYPE_KEY,
35538            key_spec_index: 0 as libc::c_int,
35539            token: 0 as *const libc::c_char,
35540            summary: 0 as *const libc::c_char,
35541            since: 0 as *const libc::c_char,
35542            flags: 0 as libc::c_int,
35543            deprecated_since: 0 as *const libc::c_char,
35544            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35545            num_args: 0,
35546        };
35547        init
35548    },
35549    {
35550        let mut init = redisCommandArg {
35551            name: b"groupname\0" as *const u8 as *const libc::c_char,
35552            type_0: ARG_TYPE_STRING,
35553            key_spec_index: -(1 as libc::c_int),
35554            token: 0 as *const libc::c_char,
35555            summary: 0 as *const libc::c_char,
35556            since: 0 as *const libc::c_char,
35557            flags: 0 as libc::c_int,
35558            deprecated_since: 0 as *const libc::c_char,
35559            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35560            num_args: 0,
35561        };
35562        init
35563    },
35564    {
35565        let mut init = redisCommandArg {
35566            name: 0 as *const libc::c_char,
35567            type_0: ARG_TYPE_STRING,
35568            key_spec_index: 0,
35569            token: 0 as *const libc::c_char,
35570            summary: 0 as *const libc::c_char,
35571            since: 0 as *const libc::c_char,
35572            flags: 0,
35573            deprecated_since: 0 as *const libc::c_char,
35574            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35575            num_args: 0,
35576        };
35577        init
35578    },
35579];
35580#[no_mangle]
35581pub static mut XGROUP_SETID_History: [commandHistory; 2] = [
35582    {
35583        let mut init = commandHistory {
35584            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
35585            changes: b"Added the optional `entries_read` argument.\0" as *const u8
35586                as *const libc::c_char,
35587        };
35588        init
35589    },
35590    {
35591        let mut init = commandHistory {
35592            since: 0 as *const libc::c_char,
35593            changes: 0 as *const libc::c_char,
35594        };
35595        init
35596    },
35597];
35598#[no_mangle]
35599pub static mut XGROUP_SETID_id_Subargs: [redisCommandArg; 3] = [
35600    {
35601        let mut init = redisCommandArg {
35602            name: b"id\0" as *const u8 as *const libc::c_char,
35603            type_0: ARG_TYPE_STRING,
35604            key_spec_index: -(1 as libc::c_int),
35605            token: 0 as *const libc::c_char,
35606            summary: 0 as *const libc::c_char,
35607            since: 0 as *const libc::c_char,
35608            flags: 0 as libc::c_int,
35609            deprecated_since: 0 as *const libc::c_char,
35610            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35611            num_args: 0,
35612        };
35613        init
35614    },
35615    {
35616        let mut init = redisCommandArg {
35617            name: b"new_id\0" as *const u8 as *const libc::c_char,
35618            type_0: ARG_TYPE_PURE_TOKEN,
35619            key_spec_index: -(1 as libc::c_int),
35620            token: b"$\0" as *const u8 as *const libc::c_char,
35621            summary: 0 as *const libc::c_char,
35622            since: 0 as *const libc::c_char,
35623            flags: 0 as libc::c_int,
35624            deprecated_since: 0 as *const libc::c_char,
35625            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35626            num_args: 0,
35627        };
35628        init
35629    },
35630    {
35631        let mut init = redisCommandArg {
35632            name: 0 as *const libc::c_char,
35633            type_0: ARG_TYPE_STRING,
35634            key_spec_index: 0,
35635            token: 0 as *const libc::c_char,
35636            summary: 0 as *const libc::c_char,
35637            since: 0 as *const libc::c_char,
35638            flags: 0,
35639            deprecated_since: 0 as *const libc::c_char,
35640            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35641            num_args: 0,
35642        };
35643        init
35644    },
35645];
35646#[no_mangle]
35647pub static mut XGROUP_SETID_Args: [redisCommandArg; 5] = unsafe {
35648    [
35649        {
35650            let mut init = redisCommandArg {
35651                name: b"key\0" as *const u8 as *const libc::c_char,
35652                type_0: ARG_TYPE_KEY,
35653                key_spec_index: 0 as libc::c_int,
35654                token: 0 as *const libc::c_char,
35655                summary: 0 as *const libc::c_char,
35656                since: 0 as *const libc::c_char,
35657                flags: 0 as libc::c_int,
35658                deprecated_since: 0 as *const libc::c_char,
35659                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35660                num_args: 0,
35661            };
35662            init
35663        },
35664        {
35665            let mut init = redisCommandArg {
35666                name: b"groupname\0" as *const u8 as *const libc::c_char,
35667                type_0: ARG_TYPE_STRING,
35668                key_spec_index: -(1 as libc::c_int),
35669                token: 0 as *const libc::c_char,
35670                summary: 0 as *const libc::c_char,
35671                since: 0 as *const libc::c_char,
35672                flags: 0 as libc::c_int,
35673                deprecated_since: 0 as *const libc::c_char,
35674                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35675                num_args: 0,
35676            };
35677            init
35678        },
35679        {
35680            let mut init = redisCommandArg {
35681                name: b"id\0" as *const u8 as *const libc::c_char,
35682                type_0: ARG_TYPE_ONEOF,
35683                key_spec_index: -(1 as libc::c_int),
35684                token: 0 as *const libc::c_char,
35685                summary: 0 as *const libc::c_char,
35686                since: 0 as *const libc::c_char,
35687                flags: 0 as libc::c_int,
35688                deprecated_since: 0 as *const libc::c_char,
35689                subargs: XGROUP_SETID_id_Subargs.as_ptr() as *mut _,
35690                num_args: 0,
35691            };
35692            init
35693        },
35694        {
35695            let mut init = redisCommandArg {
35696                name: b"entries_read\0" as *const u8 as *const libc::c_char,
35697                type_0: ARG_TYPE_INTEGER,
35698                key_spec_index: -(1 as libc::c_int),
35699                token: b"ENTRIESREAD\0" as *const u8 as *const libc::c_char,
35700                summary: 0 as *const libc::c_char,
35701                since: 0 as *const libc::c_char,
35702                flags: (1 as libc::c_int) << 0 as libc::c_int,
35703                deprecated_since: 0 as *const libc::c_char,
35704                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35705                num_args: 0,
35706            };
35707            init
35708        },
35709        {
35710            let mut init = redisCommandArg {
35711                name: 0 as *const libc::c_char,
35712                type_0: ARG_TYPE_STRING,
35713                key_spec_index: 0,
35714                token: 0 as *const libc::c_char,
35715                summary: 0 as *const libc::c_char,
35716                since: 0 as *const libc::c_char,
35717                flags: 0,
35718                deprecated_since: 0 as *const libc::c_char,
35719                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
35720                num_args: 0,
35721            };
35722            init
35723        },
35724    ]
35725};
35726#[no_mangle]
35727pub static mut XGROUP_Subcommands: [redisCommand; 7] = unsafe {
35728    [
35729        {
35730            let mut init = redisCommand {
35731                declared_name: b"create\0" as *const u8 as *const libc::c_char,
35732                summary: b"Create a consumer group.\0" as *const u8
35733                    as *const libc::c_char,
35734                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
35735                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
35736                doc_flags: 0 as libc::c_int,
35737                replaced_by: 0 as *const libc::c_char,
35738                deprecated_since: 0 as *const libc::c_char,
35739                group: COMMAND_GROUP_STREAM,
35740                history: XGROUP_CREATE_History.as_ptr() as *mut _,
35741                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
35742                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
35743                arity: -(5 as libc::c_int),
35744                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
35745                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
35746                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
35747                    as uint64_t,
35748                key_specs_static: [
35749                    {
35750                        let mut init = keySpec {
35751                            notes: 0 as *const libc::c_char,
35752                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
35753                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
35754                            begin_search_type: KSPEC_BS_INDEX,
35755                            bs: C2RustUnnamed_3 {
35756                                index: {
35757                                    let mut init = C2RustUnnamed_5 {
35758                                        pos: 2 as libc::c_int,
35759                                    };
35760                                    init
35761                                },
35762                            },
35763                            find_keys_type: KSPEC_FK_RANGE,
35764                            fk: C2RustUnnamed_0 {
35765                                range: {
35766                                    let mut init = C2RustUnnamed_2 {
35767                                        lastkey: 0 as libc::c_int,
35768                                        keystep: 1 as libc::c_int,
35769                                        limit: 0 as libc::c_int,
35770                                    };
35771                                    init
35772                                },
35773                            },
35774                        };
35775                        init
35776                    },
35777                    keySpec {
35778                        notes: 0 as *const libc::c_char,
35779                        flags: 0,
35780                        begin_search_type: KSPEC_BS_INVALID,
35781                        bs: C2RustUnnamed_3 {
35782                            index: C2RustUnnamed_5 { pos: 0 },
35783                        },
35784                        find_keys_type: KSPEC_FK_INVALID,
35785                        fk: C2RustUnnamed_0 {
35786                            range: C2RustUnnamed_2 {
35787                                lastkey: 0,
35788                                keystep: 0,
35789                                limit: 0,
35790                            },
35791                        },
35792                    },
35793                    keySpec {
35794                        notes: 0 as *const libc::c_char,
35795                        flags: 0,
35796                        begin_search_type: KSPEC_BS_INVALID,
35797                        bs: C2RustUnnamed_3 {
35798                            index: C2RustUnnamed_5 { pos: 0 },
35799                        },
35800                        find_keys_type: KSPEC_FK_INVALID,
35801                        fk: C2RustUnnamed_0 {
35802                            range: C2RustUnnamed_2 {
35803                                lastkey: 0,
35804                                keystep: 0,
35805                                limit: 0,
35806                            },
35807                        },
35808                    },
35809                    keySpec {
35810                        notes: 0 as *const libc::c_char,
35811                        flags: 0,
35812                        begin_search_type: KSPEC_BS_INVALID,
35813                        bs: C2RustUnnamed_3 {
35814                            index: C2RustUnnamed_5 { pos: 0 },
35815                        },
35816                        find_keys_type: KSPEC_FK_INVALID,
35817                        fk: C2RustUnnamed_0 {
35818                            range: C2RustUnnamed_2 {
35819                                lastkey: 0,
35820                                keystep: 0,
35821                                limit: 0,
35822                            },
35823                        },
35824                    },
35825                ],
35826                getkeys_proc: None,
35827                subcommands: 0 as *const redisCommand as *mut redisCommand,
35828                args: XGROUP_CREATE_Args.as_ptr() as *mut _,
35829                microseconds: 0,
35830                calls: 0,
35831                rejected_calls: 0,
35832                failed_calls: 0,
35833                id: 0,
35834                fullname: 0 as *const libc::c_char as *mut libc::c_char,
35835                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
35836                key_specs: 0 as *const keySpec as *mut keySpec,
35837                legacy_range_key_spec: keySpec {
35838                    notes: 0 as *const libc::c_char,
35839                    flags: 0,
35840                    begin_search_type: KSPEC_BS_INVALID,
35841                    bs: C2RustUnnamed_3 {
35842                        index: C2RustUnnamed_5 { pos: 0 },
35843                    },
35844                    find_keys_type: KSPEC_FK_INVALID,
35845                    fk: C2RustUnnamed_0 {
35846                        range: C2RustUnnamed_2 {
35847                            lastkey: 0,
35848                            keystep: 0,
35849                            limit: 0,
35850                        },
35851                    },
35852                },
35853                num_args: 0,
35854                num_history: 0,
35855                num_tips: 0,
35856                key_specs_num: 0,
35857                key_specs_max: 0,
35858                subcommands_dict: 0 as *const dict as *mut dict,
35859                parent: 0 as *const redisCommand as *mut redisCommand,
35860                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
35861            };
35862            init
35863        },
35864        {
35865            let mut init = redisCommand {
35866                declared_name: b"createconsumer\0" as *const u8 as *const libc::c_char,
35867                summary: b"Create a consumer in a consumer group.\0" as *const u8
35868                    as *const libc::c_char,
35869                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
35870                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
35871                doc_flags: 0 as libc::c_int,
35872                replaced_by: 0 as *const libc::c_char,
35873                deprecated_since: 0 as *const libc::c_char,
35874                group: COMMAND_GROUP_STREAM,
35875                history: 0 as *const commandHistory as *mut commandHistory,
35876                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
35877                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
35878                arity: 5 as libc::c_int,
35879                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
35880                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
35881                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
35882                    as uint64_t,
35883                key_specs_static: [
35884                    {
35885                        let mut init = keySpec {
35886                            notes: 0 as *const libc::c_char,
35887                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
35888                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
35889                            begin_search_type: KSPEC_BS_INDEX,
35890                            bs: C2RustUnnamed_3 {
35891                                index: {
35892                                    let mut init = C2RustUnnamed_5 {
35893                                        pos: 2 as libc::c_int,
35894                                    };
35895                                    init
35896                                },
35897                            },
35898                            find_keys_type: KSPEC_FK_RANGE,
35899                            fk: C2RustUnnamed_0 {
35900                                range: {
35901                                    let mut init = C2RustUnnamed_2 {
35902                                        lastkey: 0 as libc::c_int,
35903                                        keystep: 1 as libc::c_int,
35904                                        limit: 0 as libc::c_int,
35905                                    };
35906                                    init
35907                                },
35908                            },
35909                        };
35910                        init
35911                    },
35912                    keySpec {
35913                        notes: 0 as *const libc::c_char,
35914                        flags: 0,
35915                        begin_search_type: KSPEC_BS_INVALID,
35916                        bs: C2RustUnnamed_3 {
35917                            index: C2RustUnnamed_5 { pos: 0 },
35918                        },
35919                        find_keys_type: KSPEC_FK_INVALID,
35920                        fk: C2RustUnnamed_0 {
35921                            range: C2RustUnnamed_2 {
35922                                lastkey: 0,
35923                                keystep: 0,
35924                                limit: 0,
35925                            },
35926                        },
35927                    },
35928                    keySpec {
35929                        notes: 0 as *const libc::c_char,
35930                        flags: 0,
35931                        begin_search_type: KSPEC_BS_INVALID,
35932                        bs: C2RustUnnamed_3 {
35933                            index: C2RustUnnamed_5 { pos: 0 },
35934                        },
35935                        find_keys_type: KSPEC_FK_INVALID,
35936                        fk: C2RustUnnamed_0 {
35937                            range: C2RustUnnamed_2 {
35938                                lastkey: 0,
35939                                keystep: 0,
35940                                limit: 0,
35941                            },
35942                        },
35943                    },
35944                    keySpec {
35945                        notes: 0 as *const libc::c_char,
35946                        flags: 0,
35947                        begin_search_type: KSPEC_BS_INVALID,
35948                        bs: C2RustUnnamed_3 {
35949                            index: C2RustUnnamed_5 { pos: 0 },
35950                        },
35951                        find_keys_type: KSPEC_FK_INVALID,
35952                        fk: C2RustUnnamed_0 {
35953                            range: C2RustUnnamed_2 {
35954                                lastkey: 0,
35955                                keystep: 0,
35956                                limit: 0,
35957                            },
35958                        },
35959                    },
35960                ],
35961                getkeys_proc: None,
35962                subcommands: 0 as *const redisCommand as *mut redisCommand,
35963                args: XGROUP_CREATECONSUMER_Args.as_ptr() as *mut _,
35964                microseconds: 0,
35965                calls: 0,
35966                rejected_calls: 0,
35967                failed_calls: 0,
35968                id: 0,
35969                fullname: 0 as *const libc::c_char as *mut libc::c_char,
35970                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
35971                key_specs: 0 as *const keySpec as *mut keySpec,
35972                legacy_range_key_spec: keySpec {
35973                    notes: 0 as *const libc::c_char,
35974                    flags: 0,
35975                    begin_search_type: KSPEC_BS_INVALID,
35976                    bs: C2RustUnnamed_3 {
35977                        index: C2RustUnnamed_5 { pos: 0 },
35978                    },
35979                    find_keys_type: KSPEC_FK_INVALID,
35980                    fk: C2RustUnnamed_0 {
35981                        range: C2RustUnnamed_2 {
35982                            lastkey: 0,
35983                            keystep: 0,
35984                            limit: 0,
35985                        },
35986                    },
35987                },
35988                num_args: 0,
35989                num_history: 0,
35990                num_tips: 0,
35991                key_specs_num: 0,
35992                key_specs_max: 0,
35993                subcommands_dict: 0 as *const dict as *mut dict,
35994                parent: 0 as *const redisCommand as *mut redisCommand,
35995                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
35996            };
35997            init
35998        },
35999        {
36000            let mut init = redisCommand {
36001                declared_name: b"delconsumer\0" as *const u8 as *const libc::c_char,
36002                summary: b"Delete a consumer from a consumer group.\0" as *const u8
36003                    as *const libc::c_char,
36004                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
36005                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36006                doc_flags: 0 as libc::c_int,
36007                replaced_by: 0 as *const libc::c_char,
36008                deprecated_since: 0 as *const libc::c_char,
36009                group: COMMAND_GROUP_STREAM,
36010                history: 0 as *const commandHistory as *mut commandHistory,
36011                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36012                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
36013                arity: 5 as libc::c_int,
36014                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
36015                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36016                    as uint64_t,
36017                key_specs_static: [
36018                    {
36019                        let mut init = keySpec {
36020                            notes: 0 as *const libc::c_char,
36021                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
36022                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
36023                            begin_search_type: KSPEC_BS_INDEX,
36024                            bs: C2RustUnnamed_3 {
36025                                index: {
36026                                    let mut init = C2RustUnnamed_5 {
36027                                        pos: 2 as libc::c_int,
36028                                    };
36029                                    init
36030                                },
36031                            },
36032                            find_keys_type: KSPEC_FK_RANGE,
36033                            fk: C2RustUnnamed_0 {
36034                                range: {
36035                                    let mut init = C2RustUnnamed_2 {
36036                                        lastkey: 0 as libc::c_int,
36037                                        keystep: 1 as libc::c_int,
36038                                        limit: 0 as libc::c_int,
36039                                    };
36040                                    init
36041                                },
36042                            },
36043                        };
36044                        init
36045                    },
36046                    keySpec {
36047                        notes: 0 as *const libc::c_char,
36048                        flags: 0,
36049                        begin_search_type: KSPEC_BS_INVALID,
36050                        bs: C2RustUnnamed_3 {
36051                            index: C2RustUnnamed_5 { pos: 0 },
36052                        },
36053                        find_keys_type: KSPEC_FK_INVALID,
36054                        fk: C2RustUnnamed_0 {
36055                            range: C2RustUnnamed_2 {
36056                                lastkey: 0,
36057                                keystep: 0,
36058                                limit: 0,
36059                            },
36060                        },
36061                    },
36062                    keySpec {
36063                        notes: 0 as *const libc::c_char,
36064                        flags: 0,
36065                        begin_search_type: KSPEC_BS_INVALID,
36066                        bs: C2RustUnnamed_3 {
36067                            index: C2RustUnnamed_5 { pos: 0 },
36068                        },
36069                        find_keys_type: KSPEC_FK_INVALID,
36070                        fk: C2RustUnnamed_0 {
36071                            range: C2RustUnnamed_2 {
36072                                lastkey: 0,
36073                                keystep: 0,
36074                                limit: 0,
36075                            },
36076                        },
36077                    },
36078                    keySpec {
36079                        notes: 0 as *const libc::c_char,
36080                        flags: 0,
36081                        begin_search_type: KSPEC_BS_INVALID,
36082                        bs: C2RustUnnamed_3 {
36083                            index: C2RustUnnamed_5 { pos: 0 },
36084                        },
36085                        find_keys_type: KSPEC_FK_INVALID,
36086                        fk: C2RustUnnamed_0 {
36087                            range: C2RustUnnamed_2 {
36088                                lastkey: 0,
36089                                keystep: 0,
36090                                limit: 0,
36091                            },
36092                        },
36093                    },
36094                ],
36095                getkeys_proc: None,
36096                subcommands: 0 as *const redisCommand as *mut redisCommand,
36097                args: XGROUP_DELCONSUMER_Args.as_ptr() as *mut _,
36098                microseconds: 0,
36099                calls: 0,
36100                rejected_calls: 0,
36101                failed_calls: 0,
36102                id: 0,
36103                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36104                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36105                key_specs: 0 as *const keySpec as *mut keySpec,
36106                legacy_range_key_spec: keySpec {
36107                    notes: 0 as *const libc::c_char,
36108                    flags: 0,
36109                    begin_search_type: KSPEC_BS_INVALID,
36110                    bs: C2RustUnnamed_3 {
36111                        index: C2RustUnnamed_5 { pos: 0 },
36112                    },
36113                    find_keys_type: KSPEC_FK_INVALID,
36114                    fk: C2RustUnnamed_0 {
36115                        range: C2RustUnnamed_2 {
36116                            lastkey: 0,
36117                            keystep: 0,
36118                            limit: 0,
36119                        },
36120                    },
36121                },
36122                num_args: 0,
36123                num_history: 0,
36124                num_tips: 0,
36125                key_specs_num: 0,
36126                key_specs_max: 0,
36127                subcommands_dict: 0 as *const dict as *mut dict,
36128                parent: 0 as *const redisCommand as *mut redisCommand,
36129                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36130            };
36131            init
36132        },
36133        {
36134            let mut init = redisCommand {
36135                declared_name: b"destroy\0" as *const u8 as *const libc::c_char,
36136                summary: b"Destroy a consumer group.\0" as *const u8
36137                    as *const libc::c_char,
36138                complexity: b"O(N) where N is the number of entries in the group's pending entries list (PEL).\0"
36139                    as *const u8 as *const libc::c_char,
36140                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36141                doc_flags: 0 as libc::c_int,
36142                replaced_by: 0 as *const libc::c_char,
36143                deprecated_since: 0 as *const libc::c_char,
36144                group: COMMAND_GROUP_STREAM,
36145                history: 0 as *const commandHistory as *mut commandHistory,
36146                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36147                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
36148                arity: 4 as libc::c_int,
36149                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
36150                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36151                    as uint64_t,
36152                key_specs_static: [
36153                    {
36154                        let mut init = keySpec {
36155                            notes: 0 as *const libc::c_char,
36156                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
36157                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
36158                            begin_search_type: KSPEC_BS_INDEX,
36159                            bs: C2RustUnnamed_3 {
36160                                index: {
36161                                    let mut init = C2RustUnnamed_5 {
36162                                        pos: 2 as libc::c_int,
36163                                    };
36164                                    init
36165                                },
36166                            },
36167                            find_keys_type: KSPEC_FK_RANGE,
36168                            fk: C2RustUnnamed_0 {
36169                                range: {
36170                                    let mut init = C2RustUnnamed_2 {
36171                                        lastkey: 0 as libc::c_int,
36172                                        keystep: 1 as libc::c_int,
36173                                        limit: 0 as libc::c_int,
36174                                    };
36175                                    init
36176                                },
36177                            },
36178                        };
36179                        init
36180                    },
36181                    keySpec {
36182                        notes: 0 as *const libc::c_char,
36183                        flags: 0,
36184                        begin_search_type: KSPEC_BS_INVALID,
36185                        bs: C2RustUnnamed_3 {
36186                            index: C2RustUnnamed_5 { pos: 0 },
36187                        },
36188                        find_keys_type: KSPEC_FK_INVALID,
36189                        fk: C2RustUnnamed_0 {
36190                            range: C2RustUnnamed_2 {
36191                                lastkey: 0,
36192                                keystep: 0,
36193                                limit: 0,
36194                            },
36195                        },
36196                    },
36197                    keySpec {
36198                        notes: 0 as *const libc::c_char,
36199                        flags: 0,
36200                        begin_search_type: KSPEC_BS_INVALID,
36201                        bs: C2RustUnnamed_3 {
36202                            index: C2RustUnnamed_5 { pos: 0 },
36203                        },
36204                        find_keys_type: KSPEC_FK_INVALID,
36205                        fk: C2RustUnnamed_0 {
36206                            range: C2RustUnnamed_2 {
36207                                lastkey: 0,
36208                                keystep: 0,
36209                                limit: 0,
36210                            },
36211                        },
36212                    },
36213                    keySpec {
36214                        notes: 0 as *const libc::c_char,
36215                        flags: 0,
36216                        begin_search_type: KSPEC_BS_INVALID,
36217                        bs: C2RustUnnamed_3 {
36218                            index: C2RustUnnamed_5 { pos: 0 },
36219                        },
36220                        find_keys_type: KSPEC_FK_INVALID,
36221                        fk: C2RustUnnamed_0 {
36222                            range: C2RustUnnamed_2 {
36223                                lastkey: 0,
36224                                keystep: 0,
36225                                limit: 0,
36226                            },
36227                        },
36228                    },
36229                ],
36230                getkeys_proc: None,
36231                subcommands: 0 as *const redisCommand as *mut redisCommand,
36232                args: XGROUP_DESTROY_Args.as_ptr() as *mut _,
36233                microseconds: 0,
36234                calls: 0,
36235                rejected_calls: 0,
36236                failed_calls: 0,
36237                id: 0,
36238                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36239                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36240                key_specs: 0 as *const keySpec as *mut keySpec,
36241                legacy_range_key_spec: keySpec {
36242                    notes: 0 as *const libc::c_char,
36243                    flags: 0,
36244                    begin_search_type: KSPEC_BS_INVALID,
36245                    bs: C2RustUnnamed_3 {
36246                        index: C2RustUnnamed_5 { pos: 0 },
36247                    },
36248                    find_keys_type: KSPEC_FK_INVALID,
36249                    fk: C2RustUnnamed_0 {
36250                        range: C2RustUnnamed_2 {
36251                            lastkey: 0,
36252                            keystep: 0,
36253                            limit: 0,
36254                        },
36255                    },
36256                },
36257                num_args: 0,
36258                num_history: 0,
36259                num_tips: 0,
36260                key_specs_num: 0,
36261                key_specs_max: 0,
36262                subcommands_dict: 0 as *const dict as *mut dict,
36263                parent: 0 as *const redisCommand as *mut redisCommand,
36264                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36265            };
36266            init
36267        },
36268        {
36269            let mut init = redisCommand {
36270                declared_name: b"help\0" as *const u8 as *const libc::c_char,
36271                summary: b"Show helpful text about the different subcommands\0"
36272                    as *const u8 as *const libc::c_char,
36273                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
36274                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36275                doc_flags: 0 as libc::c_int,
36276                replaced_by: 0 as *const libc::c_char,
36277                deprecated_since: 0 as *const libc::c_char,
36278                group: COMMAND_GROUP_STREAM,
36279                history: 0 as *const commandHistory as *mut commandHistory,
36280                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36281                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
36282                arity: 2 as libc::c_int,
36283                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
36284                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
36285                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36286                    as uint64_t,
36287                key_specs_static: [keySpec {
36288                    notes: 0 as *const libc::c_char,
36289                    flags: 0,
36290                    begin_search_type: KSPEC_BS_INVALID,
36291                    bs: C2RustUnnamed_3 {
36292                        index: C2RustUnnamed_5 { pos: 0 },
36293                    },
36294                    find_keys_type: KSPEC_FK_INVALID,
36295                    fk: C2RustUnnamed_0 {
36296                        range: C2RustUnnamed_2 {
36297                            lastkey: 0,
36298                            keystep: 0,
36299                            limit: 0,
36300                        },
36301                    },
36302                }; 4],
36303                getkeys_proc: None,
36304                subcommands: 0 as *const redisCommand as *mut redisCommand,
36305                args: 0 as *const redisCommandArg as *mut redisCommandArg,
36306                microseconds: 0,
36307                calls: 0,
36308                rejected_calls: 0,
36309                failed_calls: 0,
36310                id: 0,
36311                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36312                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36313                key_specs: 0 as *const keySpec as *mut keySpec,
36314                legacy_range_key_spec: keySpec {
36315                    notes: 0 as *const libc::c_char,
36316                    flags: 0,
36317                    begin_search_type: KSPEC_BS_INVALID,
36318                    bs: C2RustUnnamed_3 {
36319                        index: C2RustUnnamed_5 { pos: 0 },
36320                    },
36321                    find_keys_type: KSPEC_FK_INVALID,
36322                    fk: C2RustUnnamed_0 {
36323                        range: C2RustUnnamed_2 {
36324                            lastkey: 0,
36325                            keystep: 0,
36326                            limit: 0,
36327                        },
36328                    },
36329                },
36330                num_args: 0,
36331                num_history: 0,
36332                num_tips: 0,
36333                key_specs_num: 0,
36334                key_specs_max: 0,
36335                subcommands_dict: 0 as *const dict as *mut dict,
36336                parent: 0 as *const redisCommand as *mut redisCommand,
36337                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36338            };
36339            init
36340        },
36341        {
36342            let mut init = redisCommand {
36343                declared_name: b"setid\0" as *const u8 as *const libc::c_char,
36344                summary: b"Set a consumer group to an arbitrary last delivered ID value.\0"
36345                    as *const u8 as *const libc::c_char,
36346                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
36347                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36348                doc_flags: 0 as libc::c_int,
36349                replaced_by: 0 as *const libc::c_char,
36350                deprecated_since: 0 as *const libc::c_char,
36351                group: COMMAND_GROUP_STREAM,
36352                history: XGROUP_SETID_History.as_ptr() as *mut _,
36353                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36354                proc_0: Some(xgroupCommand as unsafe extern "C" fn(*mut client) -> ()),
36355                arity: -(5 as libc::c_int),
36356                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
36357                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36358                    as uint64_t,
36359                key_specs_static: [
36360                    {
36361                        let mut init = keySpec {
36362                            notes: 0 as *const libc::c_char,
36363                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
36364                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
36365                            begin_search_type: KSPEC_BS_INDEX,
36366                            bs: C2RustUnnamed_3 {
36367                                index: {
36368                                    let mut init = C2RustUnnamed_5 {
36369                                        pos: 2 as libc::c_int,
36370                                    };
36371                                    init
36372                                },
36373                            },
36374                            find_keys_type: KSPEC_FK_RANGE,
36375                            fk: C2RustUnnamed_0 {
36376                                range: {
36377                                    let mut init = C2RustUnnamed_2 {
36378                                        lastkey: 0 as libc::c_int,
36379                                        keystep: 1 as libc::c_int,
36380                                        limit: 0 as libc::c_int,
36381                                    };
36382                                    init
36383                                },
36384                            },
36385                        };
36386                        init
36387                    },
36388                    keySpec {
36389                        notes: 0 as *const libc::c_char,
36390                        flags: 0,
36391                        begin_search_type: KSPEC_BS_INVALID,
36392                        bs: C2RustUnnamed_3 {
36393                            index: C2RustUnnamed_5 { pos: 0 },
36394                        },
36395                        find_keys_type: KSPEC_FK_INVALID,
36396                        fk: C2RustUnnamed_0 {
36397                            range: C2RustUnnamed_2 {
36398                                lastkey: 0,
36399                                keystep: 0,
36400                                limit: 0,
36401                            },
36402                        },
36403                    },
36404                    keySpec {
36405                        notes: 0 as *const libc::c_char,
36406                        flags: 0,
36407                        begin_search_type: KSPEC_BS_INVALID,
36408                        bs: C2RustUnnamed_3 {
36409                            index: C2RustUnnamed_5 { pos: 0 },
36410                        },
36411                        find_keys_type: KSPEC_FK_INVALID,
36412                        fk: C2RustUnnamed_0 {
36413                            range: C2RustUnnamed_2 {
36414                                lastkey: 0,
36415                                keystep: 0,
36416                                limit: 0,
36417                            },
36418                        },
36419                    },
36420                    keySpec {
36421                        notes: 0 as *const libc::c_char,
36422                        flags: 0,
36423                        begin_search_type: KSPEC_BS_INVALID,
36424                        bs: C2RustUnnamed_3 {
36425                            index: C2RustUnnamed_5 { pos: 0 },
36426                        },
36427                        find_keys_type: KSPEC_FK_INVALID,
36428                        fk: C2RustUnnamed_0 {
36429                            range: C2RustUnnamed_2 {
36430                                lastkey: 0,
36431                                keystep: 0,
36432                                limit: 0,
36433                            },
36434                        },
36435                    },
36436                ],
36437                getkeys_proc: None,
36438                subcommands: 0 as *const redisCommand as *mut redisCommand,
36439                args: XGROUP_SETID_Args.as_ptr() as *mut _,
36440                microseconds: 0,
36441                calls: 0,
36442                rejected_calls: 0,
36443                failed_calls: 0,
36444                id: 0,
36445                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36446                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36447                key_specs: 0 as *const keySpec as *mut keySpec,
36448                legacy_range_key_spec: keySpec {
36449                    notes: 0 as *const libc::c_char,
36450                    flags: 0,
36451                    begin_search_type: KSPEC_BS_INVALID,
36452                    bs: C2RustUnnamed_3 {
36453                        index: C2RustUnnamed_5 { pos: 0 },
36454                    },
36455                    find_keys_type: KSPEC_FK_INVALID,
36456                    fk: C2RustUnnamed_0 {
36457                        range: C2RustUnnamed_2 {
36458                            lastkey: 0,
36459                            keystep: 0,
36460                            limit: 0,
36461                        },
36462                    },
36463                },
36464                num_args: 0,
36465                num_history: 0,
36466                num_tips: 0,
36467                key_specs_num: 0,
36468                key_specs_max: 0,
36469                subcommands_dict: 0 as *const dict as *mut dict,
36470                parent: 0 as *const redisCommand as *mut redisCommand,
36471                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36472            };
36473            init
36474        },
36475        {
36476            let mut init = redisCommand {
36477                declared_name: 0 as *const libc::c_char,
36478                summary: 0 as *const libc::c_char,
36479                complexity: 0 as *const libc::c_char,
36480                since: 0 as *const libc::c_char,
36481                doc_flags: 0,
36482                replaced_by: 0 as *const libc::c_char,
36483                deprecated_since: 0 as *const libc::c_char,
36484                group: COMMAND_GROUP_GENERIC,
36485                history: 0 as *const commandHistory as *mut commandHistory,
36486                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36487                proc_0: None,
36488                arity: 0,
36489                flags: 0,
36490                acl_categories: 0,
36491                key_specs_static: [keySpec {
36492                    notes: 0 as *const libc::c_char,
36493                    flags: 0,
36494                    begin_search_type: KSPEC_BS_INVALID,
36495                    bs: C2RustUnnamed_3 {
36496                        index: C2RustUnnamed_5 { pos: 0 },
36497                    },
36498                    find_keys_type: KSPEC_FK_INVALID,
36499                    fk: C2RustUnnamed_0 {
36500                        range: C2RustUnnamed_2 {
36501                            lastkey: 0,
36502                            keystep: 0,
36503                            limit: 0,
36504                        },
36505                    },
36506                }; 4],
36507                getkeys_proc: None,
36508                subcommands: 0 as *const redisCommand as *mut redisCommand,
36509                args: 0 as *const redisCommandArg as *mut redisCommandArg,
36510                microseconds: 0,
36511                calls: 0,
36512                rejected_calls: 0,
36513                failed_calls: 0,
36514                id: 0,
36515                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36516                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36517                key_specs: 0 as *const keySpec as *mut keySpec,
36518                legacy_range_key_spec: keySpec {
36519                    notes: 0 as *const libc::c_char,
36520                    flags: 0,
36521                    begin_search_type: KSPEC_BS_INVALID,
36522                    bs: C2RustUnnamed_3 {
36523                        index: C2RustUnnamed_5 { pos: 0 },
36524                    },
36525                    find_keys_type: KSPEC_FK_INVALID,
36526                    fk: C2RustUnnamed_0 {
36527                        range: C2RustUnnamed_2 {
36528                            lastkey: 0,
36529                            keystep: 0,
36530                            limit: 0,
36531                        },
36532                    },
36533                },
36534                num_args: 0,
36535                num_history: 0,
36536                num_tips: 0,
36537                key_specs_num: 0,
36538                key_specs_max: 0,
36539                subcommands_dict: 0 as *const dict as *mut dict,
36540                parent: 0 as *const redisCommand as *mut redisCommand,
36541                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36542            };
36543            init
36544        },
36545    ]
36546};
36547#[no_mangle]
36548pub static mut XINFO_CONSUMERS_tips: [*const libc::c_char; 2] = [
36549    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
36550    0 as *const libc::c_char,
36551];
36552#[no_mangle]
36553pub static mut XINFO_CONSUMERS_Args: [redisCommandArg; 3] = [
36554    {
36555        let mut init = redisCommandArg {
36556            name: b"key\0" as *const u8 as *const libc::c_char,
36557            type_0: ARG_TYPE_KEY,
36558            key_spec_index: 0 as libc::c_int,
36559            token: 0 as *const libc::c_char,
36560            summary: 0 as *const libc::c_char,
36561            since: 0 as *const libc::c_char,
36562            flags: 0 as libc::c_int,
36563            deprecated_since: 0 as *const libc::c_char,
36564            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36565            num_args: 0,
36566        };
36567        init
36568    },
36569    {
36570        let mut init = redisCommandArg {
36571            name: b"groupname\0" as *const u8 as *const libc::c_char,
36572            type_0: ARG_TYPE_STRING,
36573            key_spec_index: -(1 as libc::c_int),
36574            token: 0 as *const libc::c_char,
36575            summary: 0 as *const libc::c_char,
36576            since: 0 as *const libc::c_char,
36577            flags: 0 as libc::c_int,
36578            deprecated_since: 0 as *const libc::c_char,
36579            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36580            num_args: 0,
36581        };
36582        init
36583    },
36584    {
36585        let mut init = redisCommandArg {
36586            name: 0 as *const libc::c_char,
36587            type_0: ARG_TYPE_STRING,
36588            key_spec_index: 0,
36589            token: 0 as *const libc::c_char,
36590            summary: 0 as *const libc::c_char,
36591            since: 0 as *const libc::c_char,
36592            flags: 0,
36593            deprecated_since: 0 as *const libc::c_char,
36594            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36595            num_args: 0,
36596        };
36597        init
36598    },
36599];
36600#[no_mangle]
36601pub static mut XINFO_GROUPS_History: [commandHistory; 2] = [
36602    {
36603        let mut init = commandHistory {
36604            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
36605            changes: b"Added the `entries-read` and `lag` fields\0" as *const u8
36606                as *const libc::c_char,
36607        };
36608        init
36609    },
36610    {
36611        let mut init = commandHistory {
36612            since: 0 as *const libc::c_char,
36613            changes: 0 as *const libc::c_char,
36614        };
36615        init
36616    },
36617];
36618#[no_mangle]
36619pub static mut XINFO_GROUPS_Args: [redisCommandArg; 2] = [
36620    {
36621        let mut init = redisCommandArg {
36622            name: b"key\0" as *const u8 as *const libc::c_char,
36623            type_0: ARG_TYPE_KEY,
36624            key_spec_index: 0 as libc::c_int,
36625            token: 0 as *const libc::c_char,
36626            summary: 0 as *const libc::c_char,
36627            since: 0 as *const libc::c_char,
36628            flags: 0 as libc::c_int,
36629            deprecated_since: 0 as *const libc::c_char,
36630            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36631            num_args: 0,
36632        };
36633        init
36634    },
36635    {
36636        let mut init = redisCommandArg {
36637            name: 0 as *const libc::c_char,
36638            type_0: ARG_TYPE_STRING,
36639            key_spec_index: 0,
36640            token: 0 as *const libc::c_char,
36641            summary: 0 as *const libc::c_char,
36642            since: 0 as *const libc::c_char,
36643            flags: 0,
36644            deprecated_since: 0 as *const libc::c_char,
36645            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36646            num_args: 0,
36647        };
36648        init
36649    },
36650];
36651#[no_mangle]
36652pub static mut XINFO_STREAM_History: [commandHistory; 3] = [
36653    {
36654        let mut init = commandHistory {
36655            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
36656            changes: b"Added the `FULL` modifier.\0" as *const u8 as *const libc::c_char,
36657        };
36658        init
36659    },
36660    {
36661        let mut init = commandHistory {
36662            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
36663            changes: b"Added the `max-deleted-entry-id`, `entries-added`, `recorded-first-entry-id`, `entries-read` and `lag` fields\0"
36664                as *const u8 as *const libc::c_char,
36665        };
36666        init
36667    },
36668    {
36669        let mut init = commandHistory {
36670            since: 0 as *const libc::c_char,
36671            changes: 0 as *const libc::c_char,
36672        };
36673        init
36674    },
36675];
36676#[no_mangle]
36677pub static mut XINFO_STREAM_full_Subargs: [redisCommandArg; 2] = [
36678    {
36679        let mut init = redisCommandArg {
36680            name: b"count\0" as *const u8 as *const libc::c_char,
36681            type_0: ARG_TYPE_INTEGER,
36682            key_spec_index: -(1 as libc::c_int),
36683            token: b"COUNT\0" as *const u8 as *const libc::c_char,
36684            summary: 0 as *const libc::c_char,
36685            since: 0 as *const libc::c_char,
36686            flags: (1 as libc::c_int) << 0 as libc::c_int,
36687            deprecated_since: 0 as *const libc::c_char,
36688            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36689            num_args: 0,
36690        };
36691        init
36692    },
36693    {
36694        let mut init = redisCommandArg {
36695            name: 0 as *const libc::c_char,
36696            type_0: ARG_TYPE_STRING,
36697            key_spec_index: 0,
36698            token: 0 as *const libc::c_char,
36699            summary: 0 as *const libc::c_char,
36700            since: 0 as *const libc::c_char,
36701            flags: 0,
36702            deprecated_since: 0 as *const libc::c_char,
36703            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36704            num_args: 0,
36705        };
36706        init
36707    },
36708];
36709#[no_mangle]
36710pub static mut XINFO_STREAM_Args: [redisCommandArg; 3] = unsafe {
36711    [
36712        {
36713            let mut init = redisCommandArg {
36714                name: b"key\0" as *const u8 as *const libc::c_char,
36715                type_0: ARG_TYPE_KEY,
36716                key_spec_index: 0 as libc::c_int,
36717                token: 0 as *const libc::c_char,
36718                summary: 0 as *const libc::c_char,
36719                since: 0 as *const libc::c_char,
36720                flags: 0 as libc::c_int,
36721                deprecated_since: 0 as *const libc::c_char,
36722                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36723                num_args: 0,
36724            };
36725            init
36726        },
36727        {
36728            let mut init = redisCommandArg {
36729                name: b"full\0" as *const u8 as *const libc::c_char,
36730                type_0: ARG_TYPE_BLOCK,
36731                key_spec_index: -(1 as libc::c_int),
36732                token: b"FULL\0" as *const u8 as *const libc::c_char,
36733                summary: 0 as *const libc::c_char,
36734                since: 0 as *const libc::c_char,
36735                flags: (1 as libc::c_int) << 0 as libc::c_int,
36736                deprecated_since: 0 as *const libc::c_char,
36737                subargs: XINFO_STREAM_full_Subargs.as_ptr() as *mut _,
36738                num_args: 0,
36739            };
36740            init
36741        },
36742        {
36743            let mut init = redisCommandArg {
36744                name: 0 as *const libc::c_char,
36745                type_0: ARG_TYPE_STRING,
36746                key_spec_index: 0,
36747                token: 0 as *const libc::c_char,
36748                summary: 0 as *const libc::c_char,
36749                since: 0 as *const libc::c_char,
36750                flags: 0,
36751                deprecated_since: 0 as *const libc::c_char,
36752                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
36753                num_args: 0,
36754            };
36755            init
36756        },
36757    ]
36758};
36759#[no_mangle]
36760pub static mut XINFO_Subcommands: [redisCommand; 5] = unsafe {
36761    [
36762        {
36763            let mut init = redisCommand {
36764                declared_name: b"consumers\0" as *const u8 as *const libc::c_char,
36765                summary: b"List the consumers in a consumer group\0" as *const u8
36766                    as *const libc::c_char,
36767                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
36768                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36769                doc_flags: 0 as libc::c_int,
36770                replaced_by: 0 as *const libc::c_char,
36771                deprecated_since: 0 as *const libc::c_char,
36772                group: COMMAND_GROUP_STREAM,
36773                history: 0 as *const commandHistory as *mut commandHistory,
36774                tips: XINFO_CONSUMERS_tips.as_ptr() as *mut _,
36775                proc_0: Some(xinfoCommand as unsafe extern "C" fn(*mut client) -> ()),
36776                arity: 4 as libc::c_int,
36777                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
36778                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36779                    as uint64_t,
36780                key_specs_static: [
36781                    {
36782                        let mut init = keySpec {
36783                            notes: 0 as *const libc::c_char,
36784                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
36785                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
36786                            begin_search_type: KSPEC_BS_INDEX,
36787                            bs: C2RustUnnamed_3 {
36788                                index: {
36789                                    let mut init = C2RustUnnamed_5 {
36790                                        pos: 2 as libc::c_int,
36791                                    };
36792                                    init
36793                                },
36794                            },
36795                            find_keys_type: KSPEC_FK_RANGE,
36796                            fk: C2RustUnnamed_0 {
36797                                range: {
36798                                    let mut init = C2RustUnnamed_2 {
36799                                        lastkey: 0 as libc::c_int,
36800                                        keystep: 1 as libc::c_int,
36801                                        limit: 0 as libc::c_int,
36802                                    };
36803                                    init
36804                                },
36805                            },
36806                        };
36807                        init
36808                    },
36809                    keySpec {
36810                        notes: 0 as *const libc::c_char,
36811                        flags: 0,
36812                        begin_search_type: KSPEC_BS_INVALID,
36813                        bs: C2RustUnnamed_3 {
36814                            index: C2RustUnnamed_5 { pos: 0 },
36815                        },
36816                        find_keys_type: KSPEC_FK_INVALID,
36817                        fk: C2RustUnnamed_0 {
36818                            range: C2RustUnnamed_2 {
36819                                lastkey: 0,
36820                                keystep: 0,
36821                                limit: 0,
36822                            },
36823                        },
36824                    },
36825                    keySpec {
36826                        notes: 0 as *const libc::c_char,
36827                        flags: 0,
36828                        begin_search_type: KSPEC_BS_INVALID,
36829                        bs: C2RustUnnamed_3 {
36830                            index: C2RustUnnamed_5 { pos: 0 },
36831                        },
36832                        find_keys_type: KSPEC_FK_INVALID,
36833                        fk: C2RustUnnamed_0 {
36834                            range: C2RustUnnamed_2 {
36835                                lastkey: 0,
36836                                keystep: 0,
36837                                limit: 0,
36838                            },
36839                        },
36840                    },
36841                    keySpec {
36842                        notes: 0 as *const libc::c_char,
36843                        flags: 0,
36844                        begin_search_type: KSPEC_BS_INVALID,
36845                        bs: C2RustUnnamed_3 {
36846                            index: C2RustUnnamed_5 { pos: 0 },
36847                        },
36848                        find_keys_type: KSPEC_FK_INVALID,
36849                        fk: C2RustUnnamed_0 {
36850                            range: C2RustUnnamed_2 {
36851                                lastkey: 0,
36852                                keystep: 0,
36853                                limit: 0,
36854                            },
36855                        },
36856                    },
36857                ],
36858                getkeys_proc: None,
36859                subcommands: 0 as *const redisCommand as *mut redisCommand,
36860                args: XINFO_CONSUMERS_Args.as_ptr() as *mut _,
36861                microseconds: 0,
36862                calls: 0,
36863                rejected_calls: 0,
36864                failed_calls: 0,
36865                id: 0,
36866                fullname: 0 as *const libc::c_char as *mut libc::c_char,
36867                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
36868                key_specs: 0 as *const keySpec as *mut keySpec,
36869                legacy_range_key_spec: keySpec {
36870                    notes: 0 as *const libc::c_char,
36871                    flags: 0,
36872                    begin_search_type: KSPEC_BS_INVALID,
36873                    bs: C2RustUnnamed_3 {
36874                        index: C2RustUnnamed_5 { pos: 0 },
36875                    },
36876                    find_keys_type: KSPEC_FK_INVALID,
36877                    fk: C2RustUnnamed_0 {
36878                        range: C2RustUnnamed_2 {
36879                            lastkey: 0,
36880                            keystep: 0,
36881                            limit: 0,
36882                        },
36883                    },
36884                },
36885                num_args: 0,
36886                num_history: 0,
36887                num_tips: 0,
36888                key_specs_num: 0,
36889                key_specs_max: 0,
36890                subcommands_dict: 0 as *const dict as *mut dict,
36891                parent: 0 as *const redisCommand as *mut redisCommand,
36892                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
36893            };
36894            init
36895        },
36896        {
36897            let mut init = redisCommand {
36898                declared_name: b"groups\0" as *const u8 as *const libc::c_char,
36899                summary: b"List the consumer groups of a stream\0" as *const u8
36900                    as *const libc::c_char,
36901                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
36902                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
36903                doc_flags: 0 as libc::c_int,
36904                replaced_by: 0 as *const libc::c_char,
36905                deprecated_since: 0 as *const libc::c_char,
36906                group: COMMAND_GROUP_STREAM,
36907                history: XINFO_GROUPS_History.as_ptr() as *mut _,
36908                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
36909                proc_0: Some(xinfoCommand as unsafe extern "C" fn(*mut client) -> ()),
36910                arity: 3 as libc::c_int,
36911                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
36912                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
36913                    as uint64_t,
36914                key_specs_static: [
36915                    {
36916                        let mut init = keySpec {
36917                            notes: 0 as *const libc::c_char,
36918                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
36919                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
36920                            begin_search_type: KSPEC_BS_INDEX,
36921                            bs: C2RustUnnamed_3 {
36922                                index: {
36923                                    let mut init = C2RustUnnamed_5 {
36924                                        pos: 2 as libc::c_int,
36925                                    };
36926                                    init
36927                                },
36928                            },
36929                            find_keys_type: KSPEC_FK_RANGE,
36930                            fk: C2RustUnnamed_0 {
36931                                range: {
36932                                    let mut init = C2RustUnnamed_2 {
36933                                        lastkey: 0 as libc::c_int,
36934                                        keystep: 1 as libc::c_int,
36935                                        limit: 0 as libc::c_int,
36936                                    };
36937                                    init
36938                                },
36939                            },
36940                        };
36941                        init
36942                    },
36943                    keySpec {
36944                        notes: 0 as *const libc::c_char,
36945                        flags: 0,
36946                        begin_search_type: KSPEC_BS_INVALID,
36947                        bs: C2RustUnnamed_3 {
36948                            index: C2RustUnnamed_5 { pos: 0 },
36949                        },
36950                        find_keys_type: KSPEC_FK_INVALID,
36951                        fk: C2RustUnnamed_0 {
36952                            range: C2RustUnnamed_2 {
36953                                lastkey: 0,
36954                                keystep: 0,
36955                                limit: 0,
36956                            },
36957                        },
36958                    },
36959                    keySpec {
36960                        notes: 0 as *const libc::c_char,
36961                        flags: 0,
36962                        begin_search_type: KSPEC_BS_INVALID,
36963                        bs: C2RustUnnamed_3 {
36964                            index: C2RustUnnamed_5 { pos: 0 },
36965                        },
36966                        find_keys_type: KSPEC_FK_INVALID,
36967                        fk: C2RustUnnamed_0 {
36968                            range: C2RustUnnamed_2 {
36969                                lastkey: 0,
36970                                keystep: 0,
36971                                limit: 0,
36972                            },
36973                        },
36974                    },
36975                    keySpec {
36976                        notes: 0 as *const libc::c_char,
36977                        flags: 0,
36978                        begin_search_type: KSPEC_BS_INVALID,
36979                        bs: C2RustUnnamed_3 {
36980                            index: C2RustUnnamed_5 { pos: 0 },
36981                        },
36982                        find_keys_type: KSPEC_FK_INVALID,
36983                        fk: C2RustUnnamed_0 {
36984                            range: C2RustUnnamed_2 {
36985                                lastkey: 0,
36986                                keystep: 0,
36987                                limit: 0,
36988                            },
36989                        },
36990                    },
36991                ],
36992                getkeys_proc: None,
36993                subcommands: 0 as *const redisCommand as *mut redisCommand,
36994                args: XINFO_GROUPS_Args.as_ptr() as *mut _,
36995                microseconds: 0,
36996                calls: 0,
36997                rejected_calls: 0,
36998                failed_calls: 0,
36999                id: 0,
37000                fullname: 0 as *const libc::c_char as *mut libc::c_char,
37001                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
37002                key_specs: 0 as *const keySpec as *mut keySpec,
37003                legacy_range_key_spec: keySpec {
37004                    notes: 0 as *const libc::c_char,
37005                    flags: 0,
37006                    begin_search_type: KSPEC_BS_INVALID,
37007                    bs: C2RustUnnamed_3 {
37008                        index: C2RustUnnamed_5 { pos: 0 },
37009                    },
37010                    find_keys_type: KSPEC_FK_INVALID,
37011                    fk: C2RustUnnamed_0 {
37012                        range: C2RustUnnamed_2 {
37013                            lastkey: 0,
37014                            keystep: 0,
37015                            limit: 0,
37016                        },
37017                    },
37018                },
37019                num_args: 0,
37020                num_history: 0,
37021                num_tips: 0,
37022                key_specs_num: 0,
37023                key_specs_max: 0,
37024                subcommands_dict: 0 as *const dict as *mut dict,
37025                parent: 0 as *const redisCommand as *mut redisCommand,
37026                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
37027            };
37028            init
37029        },
37030        {
37031            let mut init = redisCommand {
37032                declared_name: b"help\0" as *const u8 as *const libc::c_char,
37033                summary: b"Show helpful text about the different subcommands\0"
37034                    as *const u8 as *const libc::c_char,
37035                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
37036                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
37037                doc_flags: 0 as libc::c_int,
37038                replaced_by: 0 as *const libc::c_char,
37039                deprecated_since: 0 as *const libc::c_char,
37040                group: COMMAND_GROUP_STREAM,
37041                history: 0 as *const commandHistory as *mut commandHistory,
37042                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
37043                proc_0: Some(xinfoCommand as unsafe extern "C" fn(*mut client) -> ()),
37044                arity: 2 as libc::c_int,
37045                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
37046                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
37047                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
37048                    as uint64_t,
37049                key_specs_static: [keySpec {
37050                    notes: 0 as *const libc::c_char,
37051                    flags: 0,
37052                    begin_search_type: KSPEC_BS_INVALID,
37053                    bs: C2RustUnnamed_3 {
37054                        index: C2RustUnnamed_5 { pos: 0 },
37055                    },
37056                    find_keys_type: KSPEC_FK_INVALID,
37057                    fk: C2RustUnnamed_0 {
37058                        range: C2RustUnnamed_2 {
37059                            lastkey: 0,
37060                            keystep: 0,
37061                            limit: 0,
37062                        },
37063                    },
37064                }; 4],
37065                getkeys_proc: None,
37066                subcommands: 0 as *const redisCommand as *mut redisCommand,
37067                args: 0 as *const redisCommandArg as *mut redisCommandArg,
37068                microseconds: 0,
37069                calls: 0,
37070                rejected_calls: 0,
37071                failed_calls: 0,
37072                id: 0,
37073                fullname: 0 as *const libc::c_char as *mut libc::c_char,
37074                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
37075                key_specs: 0 as *const keySpec as *mut keySpec,
37076                legacy_range_key_spec: keySpec {
37077                    notes: 0 as *const libc::c_char,
37078                    flags: 0,
37079                    begin_search_type: KSPEC_BS_INVALID,
37080                    bs: C2RustUnnamed_3 {
37081                        index: C2RustUnnamed_5 { pos: 0 },
37082                    },
37083                    find_keys_type: KSPEC_FK_INVALID,
37084                    fk: C2RustUnnamed_0 {
37085                        range: C2RustUnnamed_2 {
37086                            lastkey: 0,
37087                            keystep: 0,
37088                            limit: 0,
37089                        },
37090                    },
37091                },
37092                num_args: 0,
37093                num_history: 0,
37094                num_tips: 0,
37095                key_specs_num: 0,
37096                key_specs_max: 0,
37097                subcommands_dict: 0 as *const dict as *mut dict,
37098                parent: 0 as *const redisCommand as *mut redisCommand,
37099                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
37100            };
37101            init
37102        },
37103        {
37104            let mut init = redisCommand {
37105                declared_name: b"stream\0" as *const u8 as *const libc::c_char,
37106                summary: b"Get information about a stream\0" as *const u8
37107                    as *const libc::c_char,
37108                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
37109                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
37110                doc_flags: 0 as libc::c_int,
37111                replaced_by: 0 as *const libc::c_char,
37112                deprecated_since: 0 as *const libc::c_char,
37113                group: COMMAND_GROUP_STREAM,
37114                history: XINFO_STREAM_History.as_ptr() as *mut _,
37115                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
37116                proc_0: Some(xinfoCommand as unsafe extern "C" fn(*mut client) -> ()),
37117                arity: -(3 as libc::c_int),
37118                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
37119                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
37120                    as uint64_t,
37121                key_specs_static: [
37122                    {
37123                        let mut init = keySpec {
37124                            notes: 0 as *const libc::c_char,
37125                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
37126                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
37127                            begin_search_type: KSPEC_BS_INDEX,
37128                            bs: C2RustUnnamed_3 {
37129                                index: {
37130                                    let mut init = C2RustUnnamed_5 {
37131                                        pos: 2 as libc::c_int,
37132                                    };
37133                                    init
37134                                },
37135                            },
37136                            find_keys_type: KSPEC_FK_RANGE,
37137                            fk: C2RustUnnamed_0 {
37138                                range: {
37139                                    let mut init = C2RustUnnamed_2 {
37140                                        lastkey: 0 as libc::c_int,
37141                                        keystep: 1 as libc::c_int,
37142                                        limit: 0 as libc::c_int,
37143                                    };
37144                                    init
37145                                },
37146                            },
37147                        };
37148                        init
37149                    },
37150                    keySpec {
37151                        notes: 0 as *const libc::c_char,
37152                        flags: 0,
37153                        begin_search_type: KSPEC_BS_INVALID,
37154                        bs: C2RustUnnamed_3 {
37155                            index: C2RustUnnamed_5 { pos: 0 },
37156                        },
37157                        find_keys_type: KSPEC_FK_INVALID,
37158                        fk: C2RustUnnamed_0 {
37159                            range: C2RustUnnamed_2 {
37160                                lastkey: 0,
37161                                keystep: 0,
37162                                limit: 0,
37163                            },
37164                        },
37165                    },
37166                    keySpec {
37167                        notes: 0 as *const libc::c_char,
37168                        flags: 0,
37169                        begin_search_type: KSPEC_BS_INVALID,
37170                        bs: C2RustUnnamed_3 {
37171                            index: C2RustUnnamed_5 { pos: 0 },
37172                        },
37173                        find_keys_type: KSPEC_FK_INVALID,
37174                        fk: C2RustUnnamed_0 {
37175                            range: C2RustUnnamed_2 {
37176                                lastkey: 0,
37177                                keystep: 0,
37178                                limit: 0,
37179                            },
37180                        },
37181                    },
37182                    keySpec {
37183                        notes: 0 as *const libc::c_char,
37184                        flags: 0,
37185                        begin_search_type: KSPEC_BS_INVALID,
37186                        bs: C2RustUnnamed_3 {
37187                            index: C2RustUnnamed_5 { pos: 0 },
37188                        },
37189                        find_keys_type: KSPEC_FK_INVALID,
37190                        fk: C2RustUnnamed_0 {
37191                            range: C2RustUnnamed_2 {
37192                                lastkey: 0,
37193                                keystep: 0,
37194                                limit: 0,
37195                            },
37196                        },
37197                    },
37198                ],
37199                getkeys_proc: None,
37200                subcommands: 0 as *const redisCommand as *mut redisCommand,
37201                args: XINFO_STREAM_Args.as_ptr() as *mut _,
37202                microseconds: 0,
37203                calls: 0,
37204                rejected_calls: 0,
37205                failed_calls: 0,
37206                id: 0,
37207                fullname: 0 as *const libc::c_char as *mut libc::c_char,
37208                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
37209                key_specs: 0 as *const keySpec as *mut keySpec,
37210                legacy_range_key_spec: keySpec {
37211                    notes: 0 as *const libc::c_char,
37212                    flags: 0,
37213                    begin_search_type: KSPEC_BS_INVALID,
37214                    bs: C2RustUnnamed_3 {
37215                        index: C2RustUnnamed_5 { pos: 0 },
37216                    },
37217                    find_keys_type: KSPEC_FK_INVALID,
37218                    fk: C2RustUnnamed_0 {
37219                        range: C2RustUnnamed_2 {
37220                            lastkey: 0,
37221                            keystep: 0,
37222                            limit: 0,
37223                        },
37224                    },
37225                },
37226                num_args: 0,
37227                num_history: 0,
37228                num_tips: 0,
37229                key_specs_num: 0,
37230                key_specs_max: 0,
37231                subcommands_dict: 0 as *const dict as *mut dict,
37232                parent: 0 as *const redisCommand as *mut redisCommand,
37233                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
37234            };
37235            init
37236        },
37237        {
37238            let mut init = redisCommand {
37239                declared_name: 0 as *const libc::c_char,
37240                summary: 0 as *const libc::c_char,
37241                complexity: 0 as *const libc::c_char,
37242                since: 0 as *const libc::c_char,
37243                doc_flags: 0,
37244                replaced_by: 0 as *const libc::c_char,
37245                deprecated_since: 0 as *const libc::c_char,
37246                group: COMMAND_GROUP_GENERIC,
37247                history: 0 as *const commandHistory as *mut commandHistory,
37248                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
37249                proc_0: None,
37250                arity: 0,
37251                flags: 0,
37252                acl_categories: 0,
37253                key_specs_static: [keySpec {
37254                    notes: 0 as *const libc::c_char,
37255                    flags: 0,
37256                    begin_search_type: KSPEC_BS_INVALID,
37257                    bs: C2RustUnnamed_3 {
37258                        index: C2RustUnnamed_5 { pos: 0 },
37259                    },
37260                    find_keys_type: KSPEC_FK_INVALID,
37261                    fk: C2RustUnnamed_0 {
37262                        range: C2RustUnnamed_2 {
37263                            lastkey: 0,
37264                            keystep: 0,
37265                            limit: 0,
37266                        },
37267                    },
37268                }; 4],
37269                getkeys_proc: None,
37270                subcommands: 0 as *const redisCommand as *mut redisCommand,
37271                args: 0 as *const redisCommandArg as *mut redisCommandArg,
37272                microseconds: 0,
37273                calls: 0,
37274                rejected_calls: 0,
37275                failed_calls: 0,
37276                id: 0,
37277                fullname: 0 as *const libc::c_char as *mut libc::c_char,
37278                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
37279                key_specs: 0 as *const keySpec as *mut keySpec,
37280                legacy_range_key_spec: keySpec {
37281                    notes: 0 as *const libc::c_char,
37282                    flags: 0,
37283                    begin_search_type: KSPEC_BS_INVALID,
37284                    bs: C2RustUnnamed_3 {
37285                        index: C2RustUnnamed_5 { pos: 0 },
37286                    },
37287                    find_keys_type: KSPEC_FK_INVALID,
37288                    fk: C2RustUnnamed_0 {
37289                        range: C2RustUnnamed_2 {
37290                            lastkey: 0,
37291                            keystep: 0,
37292                            limit: 0,
37293                        },
37294                    },
37295                },
37296                num_args: 0,
37297                num_history: 0,
37298                num_tips: 0,
37299                key_specs_num: 0,
37300                key_specs_max: 0,
37301                subcommands_dict: 0 as *const dict as *mut dict,
37302                parent: 0 as *const redisCommand as *mut redisCommand,
37303                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
37304            };
37305            init
37306        },
37307    ]
37308};
37309#[no_mangle]
37310pub static mut XLEN_Args: [redisCommandArg; 2] = [
37311    {
37312        let mut init = redisCommandArg {
37313            name: b"key\0" as *const u8 as *const libc::c_char,
37314            type_0: ARG_TYPE_KEY,
37315            key_spec_index: 0 as libc::c_int,
37316            token: 0 as *const libc::c_char,
37317            summary: 0 as *const libc::c_char,
37318            since: 0 as *const libc::c_char,
37319            flags: 0 as libc::c_int,
37320            deprecated_since: 0 as *const libc::c_char,
37321            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37322            num_args: 0,
37323        };
37324        init
37325    },
37326    {
37327        let mut init = redisCommandArg {
37328            name: 0 as *const libc::c_char,
37329            type_0: ARG_TYPE_STRING,
37330            key_spec_index: 0,
37331            token: 0 as *const libc::c_char,
37332            summary: 0 as *const libc::c_char,
37333            since: 0 as *const libc::c_char,
37334            flags: 0,
37335            deprecated_since: 0 as *const libc::c_char,
37336            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37337            num_args: 0,
37338        };
37339        init
37340    },
37341];
37342#[no_mangle]
37343pub static mut XPENDING_History: [commandHistory; 2] = [
37344    {
37345        let mut init = commandHistory {
37346            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
37347            changes: b"Added the `IDLE` option and exclusive range intervals.\0"
37348                as *const u8 as *const libc::c_char,
37349        };
37350        init
37351    },
37352    {
37353        let mut init = commandHistory {
37354            since: 0 as *const libc::c_char,
37355            changes: 0 as *const libc::c_char,
37356        };
37357        init
37358    },
37359];
37360#[no_mangle]
37361pub static mut XPENDING_tips: [*const libc::c_char; 2] = [
37362    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
37363    0 as *const libc::c_char,
37364];
37365#[no_mangle]
37366pub static mut XPENDING_filters_Subargs: [redisCommandArg; 6] = [
37367    {
37368        let mut init = redisCommandArg {
37369            name: b"min-idle-time\0" as *const u8 as *const libc::c_char,
37370            type_0: ARG_TYPE_INTEGER,
37371            key_spec_index: -(1 as libc::c_int),
37372            token: b"IDLE\0" as *const u8 as *const libc::c_char,
37373            summary: 0 as *const libc::c_char,
37374            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
37375            flags: (1 as libc::c_int) << 0 as libc::c_int,
37376            deprecated_since: 0 as *const libc::c_char,
37377            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37378            num_args: 0,
37379        };
37380        init
37381    },
37382    {
37383        let mut init = redisCommandArg {
37384            name: b"start\0" as *const u8 as *const libc::c_char,
37385            type_0: ARG_TYPE_STRING,
37386            key_spec_index: -(1 as libc::c_int),
37387            token: 0 as *const libc::c_char,
37388            summary: 0 as *const libc::c_char,
37389            since: 0 as *const libc::c_char,
37390            flags: 0 as libc::c_int,
37391            deprecated_since: 0 as *const libc::c_char,
37392            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37393            num_args: 0,
37394        };
37395        init
37396    },
37397    {
37398        let mut init = redisCommandArg {
37399            name: b"end\0" as *const u8 as *const libc::c_char,
37400            type_0: ARG_TYPE_STRING,
37401            key_spec_index: -(1 as libc::c_int),
37402            token: 0 as *const libc::c_char,
37403            summary: 0 as *const libc::c_char,
37404            since: 0 as *const libc::c_char,
37405            flags: 0 as libc::c_int,
37406            deprecated_since: 0 as *const libc::c_char,
37407            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37408            num_args: 0,
37409        };
37410        init
37411    },
37412    {
37413        let mut init = redisCommandArg {
37414            name: b"count\0" as *const u8 as *const libc::c_char,
37415            type_0: ARG_TYPE_INTEGER,
37416            key_spec_index: -(1 as libc::c_int),
37417            token: 0 as *const libc::c_char,
37418            summary: 0 as *const libc::c_char,
37419            since: 0 as *const libc::c_char,
37420            flags: 0 as libc::c_int,
37421            deprecated_since: 0 as *const libc::c_char,
37422            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37423            num_args: 0,
37424        };
37425        init
37426    },
37427    {
37428        let mut init = redisCommandArg {
37429            name: b"consumer\0" as *const u8 as *const libc::c_char,
37430            type_0: ARG_TYPE_STRING,
37431            key_spec_index: -(1 as libc::c_int),
37432            token: 0 as *const libc::c_char,
37433            summary: 0 as *const libc::c_char,
37434            since: 0 as *const libc::c_char,
37435            flags: (1 as libc::c_int) << 0 as libc::c_int,
37436            deprecated_since: 0 as *const libc::c_char,
37437            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37438            num_args: 0,
37439        };
37440        init
37441    },
37442    {
37443        let mut init = redisCommandArg {
37444            name: 0 as *const libc::c_char,
37445            type_0: ARG_TYPE_STRING,
37446            key_spec_index: 0,
37447            token: 0 as *const libc::c_char,
37448            summary: 0 as *const libc::c_char,
37449            since: 0 as *const libc::c_char,
37450            flags: 0,
37451            deprecated_since: 0 as *const libc::c_char,
37452            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37453            num_args: 0,
37454        };
37455        init
37456    },
37457];
37458#[no_mangle]
37459pub static mut XPENDING_Args: [redisCommandArg; 4] = unsafe {
37460    [
37461        {
37462            let mut init = redisCommandArg {
37463                name: b"key\0" as *const u8 as *const libc::c_char,
37464                type_0: ARG_TYPE_KEY,
37465                key_spec_index: 0 as libc::c_int,
37466                token: 0 as *const libc::c_char,
37467                summary: 0 as *const libc::c_char,
37468                since: 0 as *const libc::c_char,
37469                flags: 0 as libc::c_int,
37470                deprecated_since: 0 as *const libc::c_char,
37471                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37472                num_args: 0,
37473            };
37474            init
37475        },
37476        {
37477            let mut init = redisCommandArg {
37478                name: b"group\0" as *const u8 as *const libc::c_char,
37479                type_0: ARG_TYPE_STRING,
37480                key_spec_index: -(1 as libc::c_int),
37481                token: 0 as *const libc::c_char,
37482                summary: 0 as *const libc::c_char,
37483                since: 0 as *const libc::c_char,
37484                flags: 0 as libc::c_int,
37485                deprecated_since: 0 as *const libc::c_char,
37486                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37487                num_args: 0,
37488            };
37489            init
37490        },
37491        {
37492            let mut init = redisCommandArg {
37493                name: b"filters\0" as *const u8 as *const libc::c_char,
37494                type_0: ARG_TYPE_BLOCK,
37495                key_spec_index: -(1 as libc::c_int),
37496                token: 0 as *const libc::c_char,
37497                summary: 0 as *const libc::c_char,
37498                since: 0 as *const libc::c_char,
37499                flags: (1 as libc::c_int) << 0 as libc::c_int,
37500                deprecated_since: 0 as *const libc::c_char,
37501                subargs: XPENDING_filters_Subargs.as_ptr() as *mut _,
37502                num_args: 0,
37503            };
37504            init
37505        },
37506        {
37507            let mut init = redisCommandArg {
37508                name: 0 as *const libc::c_char,
37509                type_0: ARG_TYPE_STRING,
37510                key_spec_index: 0,
37511                token: 0 as *const libc::c_char,
37512                summary: 0 as *const libc::c_char,
37513                since: 0 as *const libc::c_char,
37514                flags: 0,
37515                deprecated_since: 0 as *const libc::c_char,
37516                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37517                num_args: 0,
37518            };
37519            init
37520        },
37521    ]
37522};
37523#[no_mangle]
37524pub static mut XRANGE_History: [commandHistory; 2] = [
37525    {
37526        let mut init = commandHistory {
37527            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
37528            changes: b"Added exclusive ranges.\0" as *const u8 as *const libc::c_char,
37529        };
37530        init
37531    },
37532    {
37533        let mut init = commandHistory {
37534            since: 0 as *const libc::c_char,
37535            changes: 0 as *const libc::c_char,
37536        };
37537        init
37538    },
37539];
37540#[no_mangle]
37541pub static mut XRANGE_Args: [redisCommandArg; 5] = [
37542    {
37543        let mut init = redisCommandArg {
37544            name: b"key\0" as *const u8 as *const libc::c_char,
37545            type_0: ARG_TYPE_KEY,
37546            key_spec_index: 0 as libc::c_int,
37547            token: 0 as *const libc::c_char,
37548            summary: 0 as *const libc::c_char,
37549            since: 0 as *const libc::c_char,
37550            flags: 0 as libc::c_int,
37551            deprecated_since: 0 as *const libc::c_char,
37552            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37553            num_args: 0,
37554        };
37555        init
37556    },
37557    {
37558        let mut init = redisCommandArg {
37559            name: b"start\0" as *const u8 as *const libc::c_char,
37560            type_0: ARG_TYPE_STRING,
37561            key_spec_index: -(1 as libc::c_int),
37562            token: 0 as *const libc::c_char,
37563            summary: 0 as *const libc::c_char,
37564            since: 0 as *const libc::c_char,
37565            flags: 0 as libc::c_int,
37566            deprecated_since: 0 as *const libc::c_char,
37567            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37568            num_args: 0,
37569        };
37570        init
37571    },
37572    {
37573        let mut init = redisCommandArg {
37574            name: b"end\0" as *const u8 as *const libc::c_char,
37575            type_0: ARG_TYPE_STRING,
37576            key_spec_index: -(1 as libc::c_int),
37577            token: 0 as *const libc::c_char,
37578            summary: 0 as *const libc::c_char,
37579            since: 0 as *const libc::c_char,
37580            flags: 0 as libc::c_int,
37581            deprecated_since: 0 as *const libc::c_char,
37582            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37583            num_args: 0,
37584        };
37585        init
37586    },
37587    {
37588        let mut init = redisCommandArg {
37589            name: b"count\0" as *const u8 as *const libc::c_char,
37590            type_0: ARG_TYPE_INTEGER,
37591            key_spec_index: -(1 as libc::c_int),
37592            token: b"COUNT\0" as *const u8 as *const libc::c_char,
37593            summary: 0 as *const libc::c_char,
37594            since: 0 as *const libc::c_char,
37595            flags: (1 as libc::c_int) << 0 as libc::c_int,
37596            deprecated_since: 0 as *const libc::c_char,
37597            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37598            num_args: 0,
37599        };
37600        init
37601    },
37602    {
37603        let mut init = redisCommandArg {
37604            name: 0 as *const libc::c_char,
37605            type_0: ARG_TYPE_STRING,
37606            key_spec_index: 0,
37607            token: 0 as *const libc::c_char,
37608            summary: 0 as *const libc::c_char,
37609            since: 0 as *const libc::c_char,
37610            flags: 0,
37611            deprecated_since: 0 as *const libc::c_char,
37612            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37613            num_args: 0,
37614        };
37615        init
37616    },
37617];
37618#[no_mangle]
37619pub static mut XREAD_streams_Subargs: [redisCommandArg; 3] = [
37620    {
37621        let mut init = redisCommandArg {
37622            name: b"key\0" as *const u8 as *const libc::c_char,
37623            type_0: ARG_TYPE_KEY,
37624            key_spec_index: 0 as libc::c_int,
37625            token: 0 as *const libc::c_char,
37626            summary: 0 as *const libc::c_char,
37627            since: 0 as *const libc::c_char,
37628            flags: (1 as libc::c_int) << 1 as libc::c_int,
37629            deprecated_since: 0 as *const libc::c_char,
37630            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37631            num_args: 0,
37632        };
37633        init
37634    },
37635    {
37636        let mut init = redisCommandArg {
37637            name: b"id\0" as *const u8 as *const libc::c_char,
37638            type_0: ARG_TYPE_STRING,
37639            key_spec_index: -(1 as libc::c_int),
37640            token: 0 as *const libc::c_char,
37641            summary: 0 as *const libc::c_char,
37642            since: 0 as *const libc::c_char,
37643            flags: (1 as libc::c_int) << 1 as libc::c_int,
37644            deprecated_since: 0 as *const libc::c_char,
37645            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37646            num_args: 0,
37647        };
37648        init
37649    },
37650    {
37651        let mut init = redisCommandArg {
37652            name: 0 as *const libc::c_char,
37653            type_0: ARG_TYPE_STRING,
37654            key_spec_index: 0,
37655            token: 0 as *const libc::c_char,
37656            summary: 0 as *const libc::c_char,
37657            since: 0 as *const libc::c_char,
37658            flags: 0,
37659            deprecated_since: 0 as *const libc::c_char,
37660            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37661            num_args: 0,
37662        };
37663        init
37664    },
37665];
37666#[no_mangle]
37667pub static mut XREAD_Args: [redisCommandArg; 4] = unsafe {
37668    [
37669        {
37670            let mut init = redisCommandArg {
37671                name: b"count\0" as *const u8 as *const libc::c_char,
37672                type_0: ARG_TYPE_INTEGER,
37673                key_spec_index: -(1 as libc::c_int),
37674                token: b"COUNT\0" as *const u8 as *const libc::c_char,
37675                summary: 0 as *const libc::c_char,
37676                since: 0 as *const libc::c_char,
37677                flags: (1 as libc::c_int) << 0 as libc::c_int,
37678                deprecated_since: 0 as *const libc::c_char,
37679                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37680                num_args: 0,
37681            };
37682            init
37683        },
37684        {
37685            let mut init = redisCommandArg {
37686                name: b"milliseconds\0" as *const u8 as *const libc::c_char,
37687                type_0: ARG_TYPE_INTEGER,
37688                key_spec_index: -(1 as libc::c_int),
37689                token: b"BLOCK\0" as *const u8 as *const libc::c_char,
37690                summary: 0 as *const libc::c_char,
37691                since: 0 as *const libc::c_char,
37692                flags: (1 as libc::c_int) << 0 as libc::c_int,
37693                deprecated_since: 0 as *const libc::c_char,
37694                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37695                num_args: 0,
37696            };
37697            init
37698        },
37699        {
37700            let mut init = redisCommandArg {
37701                name: b"streams\0" as *const u8 as *const libc::c_char,
37702                type_0: ARG_TYPE_BLOCK,
37703                key_spec_index: -(1 as libc::c_int),
37704                token: b"STREAMS\0" as *const u8 as *const libc::c_char,
37705                summary: 0 as *const libc::c_char,
37706                since: 0 as *const libc::c_char,
37707                flags: 0 as libc::c_int,
37708                deprecated_since: 0 as *const libc::c_char,
37709                subargs: XREAD_streams_Subargs.as_ptr() as *mut _,
37710                num_args: 0,
37711            };
37712            init
37713        },
37714        {
37715            let mut init = redisCommandArg {
37716                name: 0 as *const libc::c_char,
37717                type_0: ARG_TYPE_STRING,
37718                key_spec_index: 0,
37719                token: 0 as *const libc::c_char,
37720                summary: 0 as *const libc::c_char,
37721                since: 0 as *const libc::c_char,
37722                flags: 0,
37723                deprecated_since: 0 as *const libc::c_char,
37724                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37725                num_args: 0,
37726            };
37727            init
37728        },
37729    ]
37730};
37731#[no_mangle]
37732pub static mut XREADGROUP_group_consumer_Subargs: [redisCommandArg; 3] = [
37733    {
37734        let mut init = redisCommandArg {
37735            name: b"group\0" as *const u8 as *const libc::c_char,
37736            type_0: ARG_TYPE_STRING,
37737            key_spec_index: -(1 as libc::c_int),
37738            token: 0 as *const libc::c_char,
37739            summary: 0 as *const libc::c_char,
37740            since: 0 as *const libc::c_char,
37741            flags: 0 as libc::c_int,
37742            deprecated_since: 0 as *const libc::c_char,
37743            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37744            num_args: 0,
37745        };
37746        init
37747    },
37748    {
37749        let mut init = redisCommandArg {
37750            name: b"consumer\0" as *const u8 as *const libc::c_char,
37751            type_0: ARG_TYPE_STRING,
37752            key_spec_index: -(1 as libc::c_int),
37753            token: 0 as *const libc::c_char,
37754            summary: 0 as *const libc::c_char,
37755            since: 0 as *const libc::c_char,
37756            flags: 0 as libc::c_int,
37757            deprecated_since: 0 as *const libc::c_char,
37758            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37759            num_args: 0,
37760        };
37761        init
37762    },
37763    {
37764        let mut init = redisCommandArg {
37765            name: 0 as *const libc::c_char,
37766            type_0: ARG_TYPE_STRING,
37767            key_spec_index: 0,
37768            token: 0 as *const libc::c_char,
37769            summary: 0 as *const libc::c_char,
37770            since: 0 as *const libc::c_char,
37771            flags: 0,
37772            deprecated_since: 0 as *const libc::c_char,
37773            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37774            num_args: 0,
37775        };
37776        init
37777    },
37778];
37779#[no_mangle]
37780pub static mut XREADGROUP_streams_Subargs: [redisCommandArg; 3] = [
37781    {
37782        let mut init = redisCommandArg {
37783            name: b"key\0" as *const u8 as *const libc::c_char,
37784            type_0: ARG_TYPE_KEY,
37785            key_spec_index: 0 as libc::c_int,
37786            token: 0 as *const libc::c_char,
37787            summary: 0 as *const libc::c_char,
37788            since: 0 as *const libc::c_char,
37789            flags: (1 as libc::c_int) << 1 as libc::c_int,
37790            deprecated_since: 0 as *const libc::c_char,
37791            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37792            num_args: 0,
37793        };
37794        init
37795    },
37796    {
37797        let mut init = redisCommandArg {
37798            name: b"id\0" as *const u8 as *const libc::c_char,
37799            type_0: ARG_TYPE_STRING,
37800            key_spec_index: -(1 as libc::c_int),
37801            token: 0 as *const libc::c_char,
37802            summary: 0 as *const libc::c_char,
37803            since: 0 as *const libc::c_char,
37804            flags: (1 as libc::c_int) << 1 as libc::c_int,
37805            deprecated_since: 0 as *const libc::c_char,
37806            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37807            num_args: 0,
37808        };
37809        init
37810    },
37811    {
37812        let mut init = redisCommandArg {
37813            name: 0 as *const libc::c_char,
37814            type_0: ARG_TYPE_STRING,
37815            key_spec_index: 0,
37816            token: 0 as *const libc::c_char,
37817            summary: 0 as *const libc::c_char,
37818            since: 0 as *const libc::c_char,
37819            flags: 0,
37820            deprecated_since: 0 as *const libc::c_char,
37821            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37822            num_args: 0,
37823        };
37824        init
37825    },
37826];
37827#[no_mangle]
37828pub static mut XREADGROUP_Args: [redisCommandArg; 6] = unsafe {
37829    [
37830        {
37831            let mut init = redisCommandArg {
37832                name: b"group_consumer\0" as *const u8 as *const libc::c_char,
37833                type_0: ARG_TYPE_BLOCK,
37834                key_spec_index: -(1 as libc::c_int),
37835                token: b"GROUP\0" as *const u8 as *const libc::c_char,
37836                summary: 0 as *const libc::c_char,
37837                since: 0 as *const libc::c_char,
37838                flags: 0 as libc::c_int,
37839                deprecated_since: 0 as *const libc::c_char,
37840                subargs: XREADGROUP_group_consumer_Subargs.as_ptr() as *mut _,
37841                num_args: 0,
37842            };
37843            init
37844        },
37845        {
37846            let mut init = redisCommandArg {
37847                name: b"count\0" as *const u8 as *const libc::c_char,
37848                type_0: ARG_TYPE_INTEGER,
37849                key_spec_index: -(1 as libc::c_int),
37850                token: b"COUNT\0" as *const u8 as *const libc::c_char,
37851                summary: 0 as *const libc::c_char,
37852                since: 0 as *const libc::c_char,
37853                flags: (1 as libc::c_int) << 0 as libc::c_int,
37854                deprecated_since: 0 as *const libc::c_char,
37855                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37856                num_args: 0,
37857            };
37858            init
37859        },
37860        {
37861            let mut init = redisCommandArg {
37862                name: b"milliseconds\0" as *const u8 as *const libc::c_char,
37863                type_0: ARG_TYPE_INTEGER,
37864                key_spec_index: -(1 as libc::c_int),
37865                token: b"BLOCK\0" as *const u8 as *const libc::c_char,
37866                summary: 0 as *const libc::c_char,
37867                since: 0 as *const libc::c_char,
37868                flags: (1 as libc::c_int) << 0 as libc::c_int,
37869                deprecated_since: 0 as *const libc::c_char,
37870                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37871                num_args: 0,
37872            };
37873            init
37874        },
37875        {
37876            let mut init = redisCommandArg {
37877                name: b"noack\0" as *const u8 as *const libc::c_char,
37878                type_0: ARG_TYPE_PURE_TOKEN,
37879                key_spec_index: -(1 as libc::c_int),
37880                token: b"NOACK\0" as *const u8 as *const libc::c_char,
37881                summary: 0 as *const libc::c_char,
37882                since: 0 as *const libc::c_char,
37883                flags: (1 as libc::c_int) << 0 as libc::c_int,
37884                deprecated_since: 0 as *const libc::c_char,
37885                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37886                num_args: 0,
37887            };
37888            init
37889        },
37890        {
37891            let mut init = redisCommandArg {
37892                name: b"streams\0" as *const u8 as *const libc::c_char,
37893                type_0: ARG_TYPE_BLOCK,
37894                key_spec_index: -(1 as libc::c_int),
37895                token: b"STREAMS\0" as *const u8 as *const libc::c_char,
37896                summary: 0 as *const libc::c_char,
37897                since: 0 as *const libc::c_char,
37898                flags: 0 as libc::c_int,
37899                deprecated_since: 0 as *const libc::c_char,
37900                subargs: XREADGROUP_streams_Subargs.as_ptr() as *mut _,
37901                num_args: 0,
37902            };
37903            init
37904        },
37905        {
37906            let mut init = redisCommandArg {
37907                name: 0 as *const libc::c_char,
37908                type_0: ARG_TYPE_STRING,
37909                key_spec_index: 0,
37910                token: 0 as *const libc::c_char,
37911                summary: 0 as *const libc::c_char,
37912                since: 0 as *const libc::c_char,
37913                flags: 0,
37914                deprecated_since: 0 as *const libc::c_char,
37915                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37916                num_args: 0,
37917            };
37918            init
37919        },
37920    ]
37921};
37922#[no_mangle]
37923pub static mut XREVRANGE_History: [commandHistory; 2] = [
37924    {
37925        let mut init = commandHistory {
37926            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
37927            changes: b"Added exclusive ranges.\0" as *const u8 as *const libc::c_char,
37928        };
37929        init
37930    },
37931    {
37932        let mut init = commandHistory {
37933            since: 0 as *const libc::c_char,
37934            changes: 0 as *const libc::c_char,
37935        };
37936        init
37937    },
37938];
37939#[no_mangle]
37940pub static mut XREVRANGE_Args: [redisCommandArg; 5] = [
37941    {
37942        let mut init = redisCommandArg {
37943            name: b"key\0" as *const u8 as *const libc::c_char,
37944            type_0: ARG_TYPE_KEY,
37945            key_spec_index: 0 as libc::c_int,
37946            token: 0 as *const libc::c_char,
37947            summary: 0 as *const libc::c_char,
37948            since: 0 as *const libc::c_char,
37949            flags: 0 as libc::c_int,
37950            deprecated_since: 0 as *const libc::c_char,
37951            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37952            num_args: 0,
37953        };
37954        init
37955    },
37956    {
37957        let mut init = redisCommandArg {
37958            name: b"end\0" as *const u8 as *const libc::c_char,
37959            type_0: ARG_TYPE_STRING,
37960            key_spec_index: -(1 as libc::c_int),
37961            token: 0 as *const libc::c_char,
37962            summary: 0 as *const libc::c_char,
37963            since: 0 as *const libc::c_char,
37964            flags: 0 as libc::c_int,
37965            deprecated_since: 0 as *const libc::c_char,
37966            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37967            num_args: 0,
37968        };
37969        init
37970    },
37971    {
37972        let mut init = redisCommandArg {
37973            name: b"start\0" as *const u8 as *const libc::c_char,
37974            type_0: ARG_TYPE_STRING,
37975            key_spec_index: -(1 as libc::c_int),
37976            token: 0 as *const libc::c_char,
37977            summary: 0 as *const libc::c_char,
37978            since: 0 as *const libc::c_char,
37979            flags: 0 as libc::c_int,
37980            deprecated_since: 0 as *const libc::c_char,
37981            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37982            num_args: 0,
37983        };
37984        init
37985    },
37986    {
37987        let mut init = redisCommandArg {
37988            name: b"count\0" as *const u8 as *const libc::c_char,
37989            type_0: ARG_TYPE_INTEGER,
37990            key_spec_index: -(1 as libc::c_int),
37991            token: b"COUNT\0" as *const u8 as *const libc::c_char,
37992            summary: 0 as *const libc::c_char,
37993            since: 0 as *const libc::c_char,
37994            flags: (1 as libc::c_int) << 0 as libc::c_int,
37995            deprecated_since: 0 as *const libc::c_char,
37996            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
37997            num_args: 0,
37998        };
37999        init
38000    },
38001    {
38002        let mut init = redisCommandArg {
38003            name: 0 as *const libc::c_char,
38004            type_0: ARG_TYPE_STRING,
38005            key_spec_index: 0,
38006            token: 0 as *const libc::c_char,
38007            summary: 0 as *const libc::c_char,
38008            since: 0 as *const libc::c_char,
38009            flags: 0,
38010            deprecated_since: 0 as *const libc::c_char,
38011            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38012            num_args: 0,
38013        };
38014        init
38015    },
38016];
38017#[no_mangle]
38018pub static mut XSETID_History: [commandHistory; 2] = [
38019    {
38020        let mut init = commandHistory {
38021            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
38022            changes: b"Added the `entries_added` and `max_deleted_entry_id` arguments.\0"
38023                as *const u8 as *const libc::c_char,
38024        };
38025        init
38026    },
38027    {
38028        let mut init = commandHistory {
38029            since: 0 as *const libc::c_char,
38030            changes: 0 as *const libc::c_char,
38031        };
38032        init
38033    },
38034];
38035#[no_mangle]
38036pub static mut XSETID_Args: [redisCommandArg; 5] = [
38037    {
38038        let mut init = redisCommandArg {
38039            name: b"key\0" as *const u8 as *const libc::c_char,
38040            type_0: ARG_TYPE_KEY,
38041            key_spec_index: 0 as libc::c_int,
38042            token: 0 as *const libc::c_char,
38043            summary: 0 as *const libc::c_char,
38044            since: 0 as *const libc::c_char,
38045            flags: 0 as libc::c_int,
38046            deprecated_since: 0 as *const libc::c_char,
38047            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38048            num_args: 0,
38049        };
38050        init
38051    },
38052    {
38053        let mut init = redisCommandArg {
38054            name: b"last-id\0" as *const u8 as *const libc::c_char,
38055            type_0: ARG_TYPE_STRING,
38056            key_spec_index: -(1 as libc::c_int),
38057            token: 0 as *const libc::c_char,
38058            summary: 0 as *const libc::c_char,
38059            since: 0 as *const libc::c_char,
38060            flags: 0 as libc::c_int,
38061            deprecated_since: 0 as *const libc::c_char,
38062            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38063            num_args: 0,
38064        };
38065        init
38066    },
38067    {
38068        let mut init = redisCommandArg {
38069            name: b"entries_added\0" as *const u8 as *const libc::c_char,
38070            type_0: ARG_TYPE_INTEGER,
38071            key_spec_index: -(1 as libc::c_int),
38072            token: b"ENTRIESADDED\0" as *const u8 as *const libc::c_char,
38073            summary: 0 as *const libc::c_char,
38074            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
38075            flags: (1 as libc::c_int) << 0 as libc::c_int,
38076            deprecated_since: 0 as *const libc::c_char,
38077            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38078            num_args: 0,
38079        };
38080        init
38081    },
38082    {
38083        let mut init = redisCommandArg {
38084            name: b"max_deleted_entry_id\0" as *const u8 as *const libc::c_char,
38085            type_0: ARG_TYPE_STRING,
38086            key_spec_index: -(1 as libc::c_int),
38087            token: b"MAXDELETEDID\0" as *const u8 as *const libc::c_char,
38088            summary: 0 as *const libc::c_char,
38089            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
38090            flags: (1 as libc::c_int) << 0 as libc::c_int,
38091            deprecated_since: 0 as *const libc::c_char,
38092            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38093            num_args: 0,
38094        };
38095        init
38096    },
38097    {
38098        let mut init = redisCommandArg {
38099            name: 0 as *const libc::c_char,
38100            type_0: ARG_TYPE_STRING,
38101            key_spec_index: 0,
38102            token: 0 as *const libc::c_char,
38103            summary: 0 as *const libc::c_char,
38104            since: 0 as *const libc::c_char,
38105            flags: 0,
38106            deprecated_since: 0 as *const libc::c_char,
38107            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38108            num_args: 0,
38109        };
38110        init
38111    },
38112];
38113#[no_mangle]
38114pub static mut XTRIM_History: [commandHistory; 2] = [
38115    {
38116        let mut init = commandHistory {
38117            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
38118            changes: b"Added the `MINID` trimming strategy and the `LIMIT` option.\0"
38119                as *const u8 as *const libc::c_char,
38120        };
38121        init
38122    },
38123    {
38124        let mut init = commandHistory {
38125            since: 0 as *const libc::c_char,
38126            changes: 0 as *const libc::c_char,
38127        };
38128        init
38129    },
38130];
38131#[no_mangle]
38132pub static mut XTRIM_tips: [*const libc::c_char; 2] = [
38133    b"nondeterministic_output\0" as *const u8 as *const libc::c_char,
38134    0 as *const libc::c_char,
38135];
38136#[no_mangle]
38137pub static mut XTRIM_trim_strategy_Subargs: [redisCommandArg; 3] = [
38138    {
38139        let mut init = redisCommandArg {
38140            name: b"maxlen\0" as *const u8 as *const libc::c_char,
38141            type_0: ARG_TYPE_PURE_TOKEN,
38142            key_spec_index: -(1 as libc::c_int),
38143            token: b"MAXLEN\0" as *const u8 as *const libc::c_char,
38144            summary: 0 as *const libc::c_char,
38145            since: 0 as *const libc::c_char,
38146            flags: 0 as libc::c_int,
38147            deprecated_since: 0 as *const libc::c_char,
38148            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38149            num_args: 0,
38150        };
38151        init
38152    },
38153    {
38154        let mut init = redisCommandArg {
38155            name: b"minid\0" as *const u8 as *const libc::c_char,
38156            type_0: ARG_TYPE_PURE_TOKEN,
38157            key_spec_index: -(1 as libc::c_int),
38158            token: b"MINID\0" as *const u8 as *const libc::c_char,
38159            summary: 0 as *const libc::c_char,
38160            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
38161            flags: 0 as libc::c_int,
38162            deprecated_since: 0 as *const libc::c_char,
38163            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38164            num_args: 0,
38165        };
38166        init
38167    },
38168    {
38169        let mut init = redisCommandArg {
38170            name: 0 as *const libc::c_char,
38171            type_0: ARG_TYPE_STRING,
38172            key_spec_index: 0,
38173            token: 0 as *const libc::c_char,
38174            summary: 0 as *const libc::c_char,
38175            since: 0 as *const libc::c_char,
38176            flags: 0,
38177            deprecated_since: 0 as *const libc::c_char,
38178            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38179            num_args: 0,
38180        };
38181        init
38182    },
38183];
38184#[no_mangle]
38185pub static mut XTRIM_trim_operator_Subargs: [redisCommandArg; 3] = [
38186    {
38187        let mut init = redisCommandArg {
38188            name: b"equal\0" as *const u8 as *const libc::c_char,
38189            type_0: ARG_TYPE_PURE_TOKEN,
38190            key_spec_index: -(1 as libc::c_int),
38191            token: b"=\0" as *const u8 as *const libc::c_char,
38192            summary: 0 as *const libc::c_char,
38193            since: 0 as *const libc::c_char,
38194            flags: 0 as libc::c_int,
38195            deprecated_since: 0 as *const libc::c_char,
38196            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38197            num_args: 0,
38198        };
38199        init
38200    },
38201    {
38202        let mut init = redisCommandArg {
38203            name: b"approximately\0" as *const u8 as *const libc::c_char,
38204            type_0: ARG_TYPE_PURE_TOKEN,
38205            key_spec_index: -(1 as libc::c_int),
38206            token: b"~\0" as *const u8 as *const libc::c_char,
38207            summary: 0 as *const libc::c_char,
38208            since: 0 as *const libc::c_char,
38209            flags: 0 as libc::c_int,
38210            deprecated_since: 0 as *const libc::c_char,
38211            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38212            num_args: 0,
38213        };
38214        init
38215    },
38216    {
38217        let mut init = redisCommandArg {
38218            name: 0 as *const libc::c_char,
38219            type_0: ARG_TYPE_STRING,
38220            key_spec_index: 0,
38221            token: 0 as *const libc::c_char,
38222            summary: 0 as *const libc::c_char,
38223            since: 0 as *const libc::c_char,
38224            flags: 0,
38225            deprecated_since: 0 as *const libc::c_char,
38226            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38227            num_args: 0,
38228        };
38229        init
38230    },
38231];
38232#[no_mangle]
38233pub static mut XTRIM_trim_Subargs: [redisCommandArg; 5] = unsafe {
38234    [
38235        {
38236            let mut init = redisCommandArg {
38237                name: b"strategy\0" as *const u8 as *const libc::c_char,
38238                type_0: ARG_TYPE_ONEOF,
38239                key_spec_index: -(1 as libc::c_int),
38240                token: 0 as *const libc::c_char,
38241                summary: 0 as *const libc::c_char,
38242                since: 0 as *const libc::c_char,
38243                flags: 0 as libc::c_int,
38244                deprecated_since: 0 as *const libc::c_char,
38245                subargs: XTRIM_trim_strategy_Subargs.as_ptr() as *mut _,
38246                num_args: 0,
38247            };
38248            init
38249        },
38250        {
38251            let mut init = redisCommandArg {
38252                name: b"operator\0" as *const u8 as *const libc::c_char,
38253                type_0: ARG_TYPE_ONEOF,
38254                key_spec_index: -(1 as libc::c_int),
38255                token: 0 as *const libc::c_char,
38256                summary: 0 as *const libc::c_char,
38257                since: 0 as *const libc::c_char,
38258                flags: (1 as libc::c_int) << 0 as libc::c_int,
38259                deprecated_since: 0 as *const libc::c_char,
38260                subargs: XTRIM_trim_operator_Subargs.as_ptr() as *mut _,
38261                num_args: 0,
38262            };
38263            init
38264        },
38265        {
38266            let mut init = redisCommandArg {
38267                name: b"threshold\0" as *const u8 as *const libc::c_char,
38268                type_0: ARG_TYPE_STRING,
38269                key_spec_index: -(1 as libc::c_int),
38270                token: 0 as *const libc::c_char,
38271                summary: 0 as *const libc::c_char,
38272                since: 0 as *const libc::c_char,
38273                flags: 0 as libc::c_int,
38274                deprecated_since: 0 as *const libc::c_char,
38275                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38276                num_args: 0,
38277            };
38278            init
38279        },
38280        {
38281            let mut init = redisCommandArg {
38282                name: b"count\0" as *const u8 as *const libc::c_char,
38283                type_0: ARG_TYPE_INTEGER,
38284                key_spec_index: -(1 as libc::c_int),
38285                token: b"LIMIT\0" as *const u8 as *const libc::c_char,
38286                summary: 0 as *const libc::c_char,
38287                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
38288                flags: (1 as libc::c_int) << 0 as libc::c_int,
38289                deprecated_since: 0 as *const libc::c_char,
38290                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38291                num_args: 0,
38292            };
38293            init
38294        },
38295        {
38296            let mut init = redisCommandArg {
38297                name: 0 as *const libc::c_char,
38298                type_0: ARG_TYPE_STRING,
38299                key_spec_index: 0,
38300                token: 0 as *const libc::c_char,
38301                summary: 0 as *const libc::c_char,
38302                since: 0 as *const libc::c_char,
38303                flags: 0,
38304                deprecated_since: 0 as *const libc::c_char,
38305                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38306                num_args: 0,
38307            };
38308            init
38309        },
38310    ]
38311};
38312#[no_mangle]
38313pub static mut XTRIM_Args: [redisCommandArg; 3] = unsafe {
38314    [
38315        {
38316            let mut init = redisCommandArg {
38317                name: b"key\0" as *const u8 as *const libc::c_char,
38318                type_0: ARG_TYPE_KEY,
38319                key_spec_index: 0 as libc::c_int,
38320                token: 0 as *const libc::c_char,
38321                summary: 0 as *const libc::c_char,
38322                since: 0 as *const libc::c_char,
38323                flags: 0 as libc::c_int,
38324                deprecated_since: 0 as *const libc::c_char,
38325                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38326                num_args: 0,
38327            };
38328            init
38329        },
38330        {
38331            let mut init = redisCommandArg {
38332                name: b"trim\0" as *const u8 as *const libc::c_char,
38333                type_0: ARG_TYPE_BLOCK,
38334                key_spec_index: -(1 as libc::c_int),
38335                token: 0 as *const libc::c_char,
38336                summary: 0 as *const libc::c_char,
38337                since: 0 as *const libc::c_char,
38338                flags: 0 as libc::c_int,
38339                deprecated_since: 0 as *const libc::c_char,
38340                subargs: XTRIM_trim_Subargs.as_ptr() as *mut _,
38341                num_args: 0,
38342            };
38343            init
38344        },
38345        {
38346            let mut init = redisCommandArg {
38347                name: 0 as *const libc::c_char,
38348                type_0: ARG_TYPE_STRING,
38349                key_spec_index: 0,
38350                token: 0 as *const libc::c_char,
38351                summary: 0 as *const libc::c_char,
38352                since: 0 as *const libc::c_char,
38353                flags: 0,
38354                deprecated_since: 0 as *const libc::c_char,
38355                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38356                num_args: 0,
38357            };
38358            init
38359        },
38360    ]
38361};
38362#[no_mangle]
38363pub static mut APPEND_Args: [redisCommandArg; 3] = [
38364    {
38365        let mut init = redisCommandArg {
38366            name: b"key\0" as *const u8 as *const libc::c_char,
38367            type_0: ARG_TYPE_KEY,
38368            key_spec_index: 0 as libc::c_int,
38369            token: 0 as *const libc::c_char,
38370            summary: 0 as *const libc::c_char,
38371            since: 0 as *const libc::c_char,
38372            flags: 0 as libc::c_int,
38373            deprecated_since: 0 as *const libc::c_char,
38374            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38375            num_args: 0,
38376        };
38377        init
38378    },
38379    {
38380        let mut init = redisCommandArg {
38381            name: b"value\0" as *const u8 as *const libc::c_char,
38382            type_0: ARG_TYPE_STRING,
38383            key_spec_index: -(1 as libc::c_int),
38384            token: 0 as *const libc::c_char,
38385            summary: 0 as *const libc::c_char,
38386            since: 0 as *const libc::c_char,
38387            flags: 0 as libc::c_int,
38388            deprecated_since: 0 as *const libc::c_char,
38389            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38390            num_args: 0,
38391        };
38392        init
38393    },
38394    {
38395        let mut init = redisCommandArg {
38396            name: 0 as *const libc::c_char,
38397            type_0: ARG_TYPE_STRING,
38398            key_spec_index: 0,
38399            token: 0 as *const libc::c_char,
38400            summary: 0 as *const libc::c_char,
38401            since: 0 as *const libc::c_char,
38402            flags: 0,
38403            deprecated_since: 0 as *const libc::c_char,
38404            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38405            num_args: 0,
38406        };
38407        init
38408    },
38409];
38410#[no_mangle]
38411pub static mut DECR_Args: [redisCommandArg; 2] = [
38412    {
38413        let mut init = redisCommandArg {
38414            name: b"key\0" as *const u8 as *const libc::c_char,
38415            type_0: ARG_TYPE_KEY,
38416            key_spec_index: 0 as libc::c_int,
38417            token: 0 as *const libc::c_char,
38418            summary: 0 as *const libc::c_char,
38419            since: 0 as *const libc::c_char,
38420            flags: 0 as libc::c_int,
38421            deprecated_since: 0 as *const libc::c_char,
38422            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38423            num_args: 0,
38424        };
38425        init
38426    },
38427    {
38428        let mut init = redisCommandArg {
38429            name: 0 as *const libc::c_char,
38430            type_0: ARG_TYPE_STRING,
38431            key_spec_index: 0,
38432            token: 0 as *const libc::c_char,
38433            summary: 0 as *const libc::c_char,
38434            since: 0 as *const libc::c_char,
38435            flags: 0,
38436            deprecated_since: 0 as *const libc::c_char,
38437            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38438            num_args: 0,
38439        };
38440        init
38441    },
38442];
38443#[no_mangle]
38444pub static mut DECRBY_Args: [redisCommandArg; 3] = [
38445    {
38446        let mut init = redisCommandArg {
38447            name: b"key\0" as *const u8 as *const libc::c_char,
38448            type_0: ARG_TYPE_KEY,
38449            key_spec_index: 0 as libc::c_int,
38450            token: 0 as *const libc::c_char,
38451            summary: 0 as *const libc::c_char,
38452            since: 0 as *const libc::c_char,
38453            flags: 0 as libc::c_int,
38454            deprecated_since: 0 as *const libc::c_char,
38455            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38456            num_args: 0,
38457        };
38458        init
38459    },
38460    {
38461        let mut init = redisCommandArg {
38462            name: b"decrement\0" as *const u8 as *const libc::c_char,
38463            type_0: ARG_TYPE_INTEGER,
38464            key_spec_index: -(1 as libc::c_int),
38465            token: 0 as *const libc::c_char,
38466            summary: 0 as *const libc::c_char,
38467            since: 0 as *const libc::c_char,
38468            flags: 0 as libc::c_int,
38469            deprecated_since: 0 as *const libc::c_char,
38470            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38471            num_args: 0,
38472        };
38473        init
38474    },
38475    {
38476        let mut init = redisCommandArg {
38477            name: 0 as *const libc::c_char,
38478            type_0: ARG_TYPE_STRING,
38479            key_spec_index: 0,
38480            token: 0 as *const libc::c_char,
38481            summary: 0 as *const libc::c_char,
38482            since: 0 as *const libc::c_char,
38483            flags: 0,
38484            deprecated_since: 0 as *const libc::c_char,
38485            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38486            num_args: 0,
38487        };
38488        init
38489    },
38490];
38491#[no_mangle]
38492pub static mut GET_Args: [redisCommandArg; 2] = [
38493    {
38494        let mut init = redisCommandArg {
38495            name: b"key\0" as *const u8 as *const libc::c_char,
38496            type_0: ARG_TYPE_KEY,
38497            key_spec_index: 0 as libc::c_int,
38498            token: 0 as *const libc::c_char,
38499            summary: 0 as *const libc::c_char,
38500            since: 0 as *const libc::c_char,
38501            flags: 0 as libc::c_int,
38502            deprecated_since: 0 as *const libc::c_char,
38503            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38504            num_args: 0,
38505        };
38506        init
38507    },
38508    {
38509        let mut init = redisCommandArg {
38510            name: 0 as *const libc::c_char,
38511            type_0: ARG_TYPE_STRING,
38512            key_spec_index: 0,
38513            token: 0 as *const libc::c_char,
38514            summary: 0 as *const libc::c_char,
38515            since: 0 as *const libc::c_char,
38516            flags: 0,
38517            deprecated_since: 0 as *const libc::c_char,
38518            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38519            num_args: 0,
38520        };
38521        init
38522    },
38523];
38524#[no_mangle]
38525pub static mut GETDEL_Args: [redisCommandArg; 2] = [
38526    {
38527        let mut init = redisCommandArg {
38528            name: b"key\0" as *const u8 as *const libc::c_char,
38529            type_0: ARG_TYPE_KEY,
38530            key_spec_index: 0 as libc::c_int,
38531            token: 0 as *const libc::c_char,
38532            summary: 0 as *const libc::c_char,
38533            since: 0 as *const libc::c_char,
38534            flags: 0 as libc::c_int,
38535            deprecated_since: 0 as *const libc::c_char,
38536            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38537            num_args: 0,
38538        };
38539        init
38540    },
38541    {
38542        let mut init = redisCommandArg {
38543            name: 0 as *const libc::c_char,
38544            type_0: ARG_TYPE_STRING,
38545            key_spec_index: 0,
38546            token: 0 as *const libc::c_char,
38547            summary: 0 as *const libc::c_char,
38548            since: 0 as *const libc::c_char,
38549            flags: 0,
38550            deprecated_since: 0 as *const libc::c_char,
38551            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38552            num_args: 0,
38553        };
38554        init
38555    },
38556];
38557#[no_mangle]
38558pub static mut GETEX_expiration_Subargs: [redisCommandArg; 6] = [
38559    {
38560        let mut init = redisCommandArg {
38561            name: b"seconds\0" as *const u8 as *const libc::c_char,
38562            type_0: ARG_TYPE_INTEGER,
38563            key_spec_index: -(1 as libc::c_int),
38564            token: b"EX\0" as *const u8 as *const libc::c_char,
38565            summary: 0 as *const libc::c_char,
38566            since: 0 as *const libc::c_char,
38567            flags: 0 as libc::c_int,
38568            deprecated_since: 0 as *const libc::c_char,
38569            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38570            num_args: 0,
38571        };
38572        init
38573    },
38574    {
38575        let mut init = redisCommandArg {
38576            name: b"milliseconds\0" as *const u8 as *const libc::c_char,
38577            type_0: ARG_TYPE_INTEGER,
38578            key_spec_index: -(1 as libc::c_int),
38579            token: b"PX\0" as *const u8 as *const libc::c_char,
38580            summary: 0 as *const libc::c_char,
38581            since: 0 as *const libc::c_char,
38582            flags: 0 as libc::c_int,
38583            deprecated_since: 0 as *const libc::c_char,
38584            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38585            num_args: 0,
38586        };
38587        init
38588    },
38589    {
38590        let mut init = redisCommandArg {
38591            name: b"unix-time-seconds\0" as *const u8 as *const libc::c_char,
38592            type_0: ARG_TYPE_UNIX_TIME,
38593            key_spec_index: -(1 as libc::c_int),
38594            token: b"EXAT\0" as *const u8 as *const libc::c_char,
38595            summary: 0 as *const libc::c_char,
38596            since: 0 as *const libc::c_char,
38597            flags: 0 as libc::c_int,
38598            deprecated_since: 0 as *const libc::c_char,
38599            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38600            num_args: 0,
38601        };
38602        init
38603    },
38604    {
38605        let mut init = redisCommandArg {
38606            name: b"unix-time-milliseconds\0" as *const u8 as *const libc::c_char,
38607            type_0: ARG_TYPE_UNIX_TIME,
38608            key_spec_index: -(1 as libc::c_int),
38609            token: b"PXAT\0" as *const u8 as *const libc::c_char,
38610            summary: 0 as *const libc::c_char,
38611            since: 0 as *const libc::c_char,
38612            flags: 0 as libc::c_int,
38613            deprecated_since: 0 as *const libc::c_char,
38614            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38615            num_args: 0,
38616        };
38617        init
38618    },
38619    {
38620        let mut init = redisCommandArg {
38621            name: b"persist\0" as *const u8 as *const libc::c_char,
38622            type_0: ARG_TYPE_PURE_TOKEN,
38623            key_spec_index: -(1 as libc::c_int),
38624            token: b"PERSIST\0" as *const u8 as *const libc::c_char,
38625            summary: 0 as *const libc::c_char,
38626            since: 0 as *const libc::c_char,
38627            flags: 0 as libc::c_int,
38628            deprecated_since: 0 as *const libc::c_char,
38629            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38630            num_args: 0,
38631        };
38632        init
38633    },
38634    {
38635        let mut init = redisCommandArg {
38636            name: 0 as *const libc::c_char,
38637            type_0: ARG_TYPE_STRING,
38638            key_spec_index: 0,
38639            token: 0 as *const libc::c_char,
38640            summary: 0 as *const libc::c_char,
38641            since: 0 as *const libc::c_char,
38642            flags: 0,
38643            deprecated_since: 0 as *const libc::c_char,
38644            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38645            num_args: 0,
38646        };
38647        init
38648    },
38649];
38650#[no_mangle]
38651pub static mut GETEX_Args: [redisCommandArg; 3] = unsafe {
38652    [
38653        {
38654            let mut init = redisCommandArg {
38655                name: b"key\0" as *const u8 as *const libc::c_char,
38656                type_0: ARG_TYPE_KEY,
38657                key_spec_index: 0 as libc::c_int,
38658                token: 0 as *const libc::c_char,
38659                summary: 0 as *const libc::c_char,
38660                since: 0 as *const libc::c_char,
38661                flags: 0 as libc::c_int,
38662                deprecated_since: 0 as *const libc::c_char,
38663                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38664                num_args: 0,
38665            };
38666            init
38667        },
38668        {
38669            let mut init = redisCommandArg {
38670                name: b"expiration\0" as *const u8 as *const libc::c_char,
38671                type_0: ARG_TYPE_ONEOF,
38672                key_spec_index: -(1 as libc::c_int),
38673                token: 0 as *const libc::c_char,
38674                summary: 0 as *const libc::c_char,
38675                since: 0 as *const libc::c_char,
38676                flags: (1 as libc::c_int) << 0 as libc::c_int,
38677                deprecated_since: 0 as *const libc::c_char,
38678                subargs: GETEX_expiration_Subargs.as_ptr() as *mut _,
38679                num_args: 0,
38680            };
38681            init
38682        },
38683        {
38684            let mut init = redisCommandArg {
38685                name: 0 as *const libc::c_char,
38686                type_0: ARG_TYPE_STRING,
38687                key_spec_index: 0,
38688                token: 0 as *const libc::c_char,
38689                summary: 0 as *const libc::c_char,
38690                since: 0 as *const libc::c_char,
38691                flags: 0,
38692                deprecated_since: 0 as *const libc::c_char,
38693                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38694                num_args: 0,
38695            };
38696            init
38697        },
38698    ]
38699};
38700#[no_mangle]
38701pub static mut GETRANGE_Args: [redisCommandArg; 4] = [
38702    {
38703        let mut init = redisCommandArg {
38704            name: b"key\0" as *const u8 as *const libc::c_char,
38705            type_0: ARG_TYPE_KEY,
38706            key_spec_index: 0 as libc::c_int,
38707            token: 0 as *const libc::c_char,
38708            summary: 0 as *const libc::c_char,
38709            since: 0 as *const libc::c_char,
38710            flags: 0 as libc::c_int,
38711            deprecated_since: 0 as *const libc::c_char,
38712            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38713            num_args: 0,
38714        };
38715        init
38716    },
38717    {
38718        let mut init = redisCommandArg {
38719            name: b"start\0" as *const u8 as *const libc::c_char,
38720            type_0: ARG_TYPE_INTEGER,
38721            key_spec_index: -(1 as libc::c_int),
38722            token: 0 as *const libc::c_char,
38723            summary: 0 as *const libc::c_char,
38724            since: 0 as *const libc::c_char,
38725            flags: 0 as libc::c_int,
38726            deprecated_since: 0 as *const libc::c_char,
38727            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38728            num_args: 0,
38729        };
38730        init
38731    },
38732    {
38733        let mut init = redisCommandArg {
38734            name: b"end\0" as *const u8 as *const libc::c_char,
38735            type_0: ARG_TYPE_INTEGER,
38736            key_spec_index: -(1 as libc::c_int),
38737            token: 0 as *const libc::c_char,
38738            summary: 0 as *const libc::c_char,
38739            since: 0 as *const libc::c_char,
38740            flags: 0 as libc::c_int,
38741            deprecated_since: 0 as *const libc::c_char,
38742            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38743            num_args: 0,
38744        };
38745        init
38746    },
38747    {
38748        let mut init = redisCommandArg {
38749            name: 0 as *const libc::c_char,
38750            type_0: ARG_TYPE_STRING,
38751            key_spec_index: 0,
38752            token: 0 as *const libc::c_char,
38753            summary: 0 as *const libc::c_char,
38754            since: 0 as *const libc::c_char,
38755            flags: 0,
38756            deprecated_since: 0 as *const libc::c_char,
38757            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38758            num_args: 0,
38759        };
38760        init
38761    },
38762];
38763#[no_mangle]
38764pub static mut GETSET_Args: [redisCommandArg; 3] = [
38765    {
38766        let mut init = redisCommandArg {
38767            name: b"key\0" as *const u8 as *const libc::c_char,
38768            type_0: ARG_TYPE_KEY,
38769            key_spec_index: 0 as libc::c_int,
38770            token: 0 as *const libc::c_char,
38771            summary: 0 as *const libc::c_char,
38772            since: 0 as *const libc::c_char,
38773            flags: 0 as libc::c_int,
38774            deprecated_since: 0 as *const libc::c_char,
38775            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38776            num_args: 0,
38777        };
38778        init
38779    },
38780    {
38781        let mut init = redisCommandArg {
38782            name: b"value\0" as *const u8 as *const libc::c_char,
38783            type_0: ARG_TYPE_STRING,
38784            key_spec_index: -(1 as libc::c_int),
38785            token: 0 as *const libc::c_char,
38786            summary: 0 as *const libc::c_char,
38787            since: 0 as *const libc::c_char,
38788            flags: 0 as libc::c_int,
38789            deprecated_since: 0 as *const libc::c_char,
38790            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38791            num_args: 0,
38792        };
38793        init
38794    },
38795    {
38796        let mut init = redisCommandArg {
38797            name: 0 as *const libc::c_char,
38798            type_0: ARG_TYPE_STRING,
38799            key_spec_index: 0,
38800            token: 0 as *const libc::c_char,
38801            summary: 0 as *const libc::c_char,
38802            since: 0 as *const libc::c_char,
38803            flags: 0,
38804            deprecated_since: 0 as *const libc::c_char,
38805            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38806            num_args: 0,
38807        };
38808        init
38809    },
38810];
38811#[no_mangle]
38812pub static mut INCR_Args: [redisCommandArg; 2] = [
38813    {
38814        let mut init = redisCommandArg {
38815            name: b"key\0" as *const u8 as *const libc::c_char,
38816            type_0: ARG_TYPE_KEY,
38817            key_spec_index: 0 as libc::c_int,
38818            token: 0 as *const libc::c_char,
38819            summary: 0 as *const libc::c_char,
38820            since: 0 as *const libc::c_char,
38821            flags: 0 as libc::c_int,
38822            deprecated_since: 0 as *const libc::c_char,
38823            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38824            num_args: 0,
38825        };
38826        init
38827    },
38828    {
38829        let mut init = redisCommandArg {
38830            name: 0 as *const libc::c_char,
38831            type_0: ARG_TYPE_STRING,
38832            key_spec_index: 0,
38833            token: 0 as *const libc::c_char,
38834            summary: 0 as *const libc::c_char,
38835            since: 0 as *const libc::c_char,
38836            flags: 0,
38837            deprecated_since: 0 as *const libc::c_char,
38838            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38839            num_args: 0,
38840        };
38841        init
38842    },
38843];
38844#[no_mangle]
38845pub static mut INCRBY_Args: [redisCommandArg; 3] = [
38846    {
38847        let mut init = redisCommandArg {
38848            name: b"key\0" as *const u8 as *const libc::c_char,
38849            type_0: ARG_TYPE_KEY,
38850            key_spec_index: 0 as libc::c_int,
38851            token: 0 as *const libc::c_char,
38852            summary: 0 as *const libc::c_char,
38853            since: 0 as *const libc::c_char,
38854            flags: 0 as libc::c_int,
38855            deprecated_since: 0 as *const libc::c_char,
38856            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38857            num_args: 0,
38858        };
38859        init
38860    },
38861    {
38862        let mut init = redisCommandArg {
38863            name: b"increment\0" as *const u8 as *const libc::c_char,
38864            type_0: ARG_TYPE_INTEGER,
38865            key_spec_index: -(1 as libc::c_int),
38866            token: 0 as *const libc::c_char,
38867            summary: 0 as *const libc::c_char,
38868            since: 0 as *const libc::c_char,
38869            flags: 0 as libc::c_int,
38870            deprecated_since: 0 as *const libc::c_char,
38871            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38872            num_args: 0,
38873        };
38874        init
38875    },
38876    {
38877        let mut init = redisCommandArg {
38878            name: 0 as *const libc::c_char,
38879            type_0: ARG_TYPE_STRING,
38880            key_spec_index: 0,
38881            token: 0 as *const libc::c_char,
38882            summary: 0 as *const libc::c_char,
38883            since: 0 as *const libc::c_char,
38884            flags: 0,
38885            deprecated_since: 0 as *const libc::c_char,
38886            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38887            num_args: 0,
38888        };
38889        init
38890    },
38891];
38892#[no_mangle]
38893pub static mut INCRBYFLOAT_Args: [redisCommandArg; 3] = [
38894    {
38895        let mut init = redisCommandArg {
38896            name: b"key\0" as *const u8 as *const libc::c_char,
38897            type_0: ARG_TYPE_KEY,
38898            key_spec_index: 0 as libc::c_int,
38899            token: 0 as *const libc::c_char,
38900            summary: 0 as *const libc::c_char,
38901            since: 0 as *const libc::c_char,
38902            flags: 0 as libc::c_int,
38903            deprecated_since: 0 as *const libc::c_char,
38904            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38905            num_args: 0,
38906        };
38907        init
38908    },
38909    {
38910        let mut init = redisCommandArg {
38911            name: b"increment\0" as *const u8 as *const libc::c_char,
38912            type_0: ARG_TYPE_DOUBLE,
38913            key_spec_index: -(1 as libc::c_int),
38914            token: 0 as *const libc::c_char,
38915            summary: 0 as *const libc::c_char,
38916            since: 0 as *const libc::c_char,
38917            flags: 0 as libc::c_int,
38918            deprecated_since: 0 as *const libc::c_char,
38919            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38920            num_args: 0,
38921        };
38922        init
38923    },
38924    {
38925        let mut init = redisCommandArg {
38926            name: 0 as *const libc::c_char,
38927            type_0: ARG_TYPE_STRING,
38928            key_spec_index: 0,
38929            token: 0 as *const libc::c_char,
38930            summary: 0 as *const libc::c_char,
38931            since: 0 as *const libc::c_char,
38932            flags: 0,
38933            deprecated_since: 0 as *const libc::c_char,
38934            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38935            num_args: 0,
38936        };
38937        init
38938    },
38939];
38940#[no_mangle]
38941pub static mut LCS_Args: [redisCommandArg; 7] = [
38942    {
38943        let mut init = redisCommandArg {
38944            name: b"key1\0" as *const u8 as *const libc::c_char,
38945            type_0: ARG_TYPE_KEY,
38946            key_spec_index: 0 as libc::c_int,
38947            token: 0 as *const libc::c_char,
38948            summary: 0 as *const libc::c_char,
38949            since: 0 as *const libc::c_char,
38950            flags: 0 as libc::c_int,
38951            deprecated_since: 0 as *const libc::c_char,
38952            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38953            num_args: 0,
38954        };
38955        init
38956    },
38957    {
38958        let mut init = redisCommandArg {
38959            name: b"key2\0" as *const u8 as *const libc::c_char,
38960            type_0: ARG_TYPE_KEY,
38961            key_spec_index: 0 as libc::c_int,
38962            token: 0 as *const libc::c_char,
38963            summary: 0 as *const libc::c_char,
38964            since: 0 as *const libc::c_char,
38965            flags: 0 as libc::c_int,
38966            deprecated_since: 0 as *const libc::c_char,
38967            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38968            num_args: 0,
38969        };
38970        init
38971    },
38972    {
38973        let mut init = redisCommandArg {
38974            name: b"len\0" as *const u8 as *const libc::c_char,
38975            type_0: ARG_TYPE_PURE_TOKEN,
38976            key_spec_index: -(1 as libc::c_int),
38977            token: b"LEN\0" as *const u8 as *const libc::c_char,
38978            summary: 0 as *const libc::c_char,
38979            since: 0 as *const libc::c_char,
38980            flags: (1 as libc::c_int) << 0 as libc::c_int,
38981            deprecated_since: 0 as *const libc::c_char,
38982            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38983            num_args: 0,
38984        };
38985        init
38986    },
38987    {
38988        let mut init = redisCommandArg {
38989            name: b"idx\0" as *const u8 as *const libc::c_char,
38990            type_0: ARG_TYPE_PURE_TOKEN,
38991            key_spec_index: -(1 as libc::c_int),
38992            token: b"IDX\0" as *const u8 as *const libc::c_char,
38993            summary: 0 as *const libc::c_char,
38994            since: 0 as *const libc::c_char,
38995            flags: (1 as libc::c_int) << 0 as libc::c_int,
38996            deprecated_since: 0 as *const libc::c_char,
38997            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
38998            num_args: 0,
38999        };
39000        init
39001    },
39002    {
39003        let mut init = redisCommandArg {
39004            name: b"len\0" as *const u8 as *const libc::c_char,
39005            type_0: ARG_TYPE_INTEGER,
39006            key_spec_index: -(1 as libc::c_int),
39007            token: b"MINMATCHLEN\0" as *const u8 as *const libc::c_char,
39008            summary: 0 as *const libc::c_char,
39009            since: 0 as *const libc::c_char,
39010            flags: (1 as libc::c_int) << 0 as libc::c_int,
39011            deprecated_since: 0 as *const libc::c_char,
39012            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39013            num_args: 0,
39014        };
39015        init
39016    },
39017    {
39018        let mut init = redisCommandArg {
39019            name: b"withmatchlen\0" as *const u8 as *const libc::c_char,
39020            type_0: ARG_TYPE_PURE_TOKEN,
39021            key_spec_index: -(1 as libc::c_int),
39022            token: b"WITHMATCHLEN\0" as *const u8 as *const libc::c_char,
39023            summary: 0 as *const libc::c_char,
39024            since: 0 as *const libc::c_char,
39025            flags: (1 as libc::c_int) << 0 as libc::c_int,
39026            deprecated_since: 0 as *const libc::c_char,
39027            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39028            num_args: 0,
39029        };
39030        init
39031    },
39032    {
39033        let mut init = redisCommandArg {
39034            name: 0 as *const libc::c_char,
39035            type_0: ARG_TYPE_STRING,
39036            key_spec_index: 0,
39037            token: 0 as *const libc::c_char,
39038            summary: 0 as *const libc::c_char,
39039            since: 0 as *const libc::c_char,
39040            flags: 0,
39041            deprecated_since: 0 as *const libc::c_char,
39042            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39043            num_args: 0,
39044        };
39045        init
39046    },
39047];
39048#[no_mangle]
39049pub static mut MGET_tips: [*const libc::c_char; 2] = [
39050    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
39051    0 as *const libc::c_char,
39052];
39053#[no_mangle]
39054pub static mut MGET_Args: [redisCommandArg; 2] = [
39055    {
39056        let mut init = redisCommandArg {
39057            name: b"key\0" as *const u8 as *const libc::c_char,
39058            type_0: ARG_TYPE_KEY,
39059            key_spec_index: 0 as libc::c_int,
39060            token: 0 as *const libc::c_char,
39061            summary: 0 as *const libc::c_char,
39062            since: 0 as *const libc::c_char,
39063            flags: (1 as libc::c_int) << 1 as libc::c_int,
39064            deprecated_since: 0 as *const libc::c_char,
39065            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39066            num_args: 0,
39067        };
39068        init
39069    },
39070    {
39071        let mut init = redisCommandArg {
39072            name: 0 as *const libc::c_char,
39073            type_0: ARG_TYPE_STRING,
39074            key_spec_index: 0,
39075            token: 0 as *const libc::c_char,
39076            summary: 0 as *const libc::c_char,
39077            since: 0 as *const libc::c_char,
39078            flags: 0,
39079            deprecated_since: 0 as *const libc::c_char,
39080            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39081            num_args: 0,
39082        };
39083        init
39084    },
39085];
39086#[no_mangle]
39087pub static mut MSET_tips: [*const libc::c_char; 3] = [
39088    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
39089    b"response_policy:all_succeeded\0" as *const u8 as *const libc::c_char,
39090    0 as *const libc::c_char,
39091];
39092#[no_mangle]
39093pub static mut MSET_key_value_Subargs: [redisCommandArg; 3] = [
39094    {
39095        let mut init = redisCommandArg {
39096            name: b"key\0" as *const u8 as *const libc::c_char,
39097            type_0: ARG_TYPE_KEY,
39098            key_spec_index: 0 as libc::c_int,
39099            token: 0 as *const libc::c_char,
39100            summary: 0 as *const libc::c_char,
39101            since: 0 as *const libc::c_char,
39102            flags: 0 as libc::c_int,
39103            deprecated_since: 0 as *const libc::c_char,
39104            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39105            num_args: 0,
39106        };
39107        init
39108    },
39109    {
39110        let mut init = redisCommandArg {
39111            name: b"value\0" as *const u8 as *const libc::c_char,
39112            type_0: ARG_TYPE_STRING,
39113            key_spec_index: -(1 as libc::c_int),
39114            token: 0 as *const libc::c_char,
39115            summary: 0 as *const libc::c_char,
39116            since: 0 as *const libc::c_char,
39117            flags: 0 as libc::c_int,
39118            deprecated_since: 0 as *const libc::c_char,
39119            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39120            num_args: 0,
39121        };
39122        init
39123    },
39124    {
39125        let mut init = redisCommandArg {
39126            name: 0 as *const libc::c_char,
39127            type_0: ARG_TYPE_STRING,
39128            key_spec_index: 0,
39129            token: 0 as *const libc::c_char,
39130            summary: 0 as *const libc::c_char,
39131            since: 0 as *const libc::c_char,
39132            flags: 0,
39133            deprecated_since: 0 as *const libc::c_char,
39134            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39135            num_args: 0,
39136        };
39137        init
39138    },
39139];
39140#[no_mangle]
39141pub static mut MSET_Args: [redisCommandArg; 2] = unsafe {
39142    [
39143        {
39144            let mut init = redisCommandArg {
39145                name: b"key_value\0" as *const u8 as *const libc::c_char,
39146                type_0: ARG_TYPE_BLOCK,
39147                key_spec_index: -(1 as libc::c_int),
39148                token: 0 as *const libc::c_char,
39149                summary: 0 as *const libc::c_char,
39150                since: 0 as *const libc::c_char,
39151                flags: (1 as libc::c_int) << 1 as libc::c_int,
39152                deprecated_since: 0 as *const libc::c_char,
39153                subargs: MSET_key_value_Subargs.as_ptr() as *mut _,
39154                num_args: 0,
39155            };
39156            init
39157        },
39158        {
39159            let mut init = redisCommandArg {
39160                name: 0 as *const libc::c_char,
39161                type_0: ARG_TYPE_STRING,
39162                key_spec_index: 0,
39163                token: 0 as *const libc::c_char,
39164                summary: 0 as *const libc::c_char,
39165                since: 0 as *const libc::c_char,
39166                flags: 0,
39167                deprecated_since: 0 as *const libc::c_char,
39168                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39169                num_args: 0,
39170            };
39171            init
39172        },
39173    ]
39174};
39175#[no_mangle]
39176pub static mut MSETNX_tips: [*const libc::c_char; 3] = [
39177    b"request_policy:multi_shard\0" as *const u8 as *const libc::c_char,
39178    b"response_policy:agg_min\0" as *const u8 as *const libc::c_char,
39179    0 as *const libc::c_char,
39180];
39181#[no_mangle]
39182pub static mut MSETNX_key_value_Subargs: [redisCommandArg; 3] = [
39183    {
39184        let mut init = redisCommandArg {
39185            name: b"key\0" as *const u8 as *const libc::c_char,
39186            type_0: ARG_TYPE_KEY,
39187            key_spec_index: 0 as libc::c_int,
39188            token: 0 as *const libc::c_char,
39189            summary: 0 as *const libc::c_char,
39190            since: 0 as *const libc::c_char,
39191            flags: 0 as libc::c_int,
39192            deprecated_since: 0 as *const libc::c_char,
39193            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39194            num_args: 0,
39195        };
39196        init
39197    },
39198    {
39199        let mut init = redisCommandArg {
39200            name: b"value\0" as *const u8 as *const libc::c_char,
39201            type_0: ARG_TYPE_STRING,
39202            key_spec_index: -(1 as libc::c_int),
39203            token: 0 as *const libc::c_char,
39204            summary: 0 as *const libc::c_char,
39205            since: 0 as *const libc::c_char,
39206            flags: 0 as libc::c_int,
39207            deprecated_since: 0 as *const libc::c_char,
39208            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39209            num_args: 0,
39210        };
39211        init
39212    },
39213    {
39214        let mut init = redisCommandArg {
39215            name: 0 as *const libc::c_char,
39216            type_0: ARG_TYPE_STRING,
39217            key_spec_index: 0,
39218            token: 0 as *const libc::c_char,
39219            summary: 0 as *const libc::c_char,
39220            since: 0 as *const libc::c_char,
39221            flags: 0,
39222            deprecated_since: 0 as *const libc::c_char,
39223            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39224            num_args: 0,
39225        };
39226        init
39227    },
39228];
39229#[no_mangle]
39230pub static mut MSETNX_Args: [redisCommandArg; 2] = unsafe {
39231    [
39232        {
39233            let mut init = redisCommandArg {
39234                name: b"key_value\0" as *const u8 as *const libc::c_char,
39235                type_0: ARG_TYPE_BLOCK,
39236                key_spec_index: -(1 as libc::c_int),
39237                token: 0 as *const libc::c_char,
39238                summary: 0 as *const libc::c_char,
39239                since: 0 as *const libc::c_char,
39240                flags: (1 as libc::c_int) << 1 as libc::c_int,
39241                deprecated_since: 0 as *const libc::c_char,
39242                subargs: MSETNX_key_value_Subargs.as_ptr() as *mut _,
39243                num_args: 0,
39244            };
39245            init
39246        },
39247        {
39248            let mut init = redisCommandArg {
39249                name: 0 as *const libc::c_char,
39250                type_0: ARG_TYPE_STRING,
39251                key_spec_index: 0,
39252                token: 0 as *const libc::c_char,
39253                summary: 0 as *const libc::c_char,
39254                since: 0 as *const libc::c_char,
39255                flags: 0,
39256                deprecated_since: 0 as *const libc::c_char,
39257                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39258                num_args: 0,
39259            };
39260            init
39261        },
39262    ]
39263};
39264#[no_mangle]
39265pub static mut PSETEX_Args: [redisCommandArg; 4] = [
39266    {
39267        let mut init = redisCommandArg {
39268            name: b"key\0" as *const u8 as *const libc::c_char,
39269            type_0: ARG_TYPE_KEY,
39270            key_spec_index: 0 as libc::c_int,
39271            token: 0 as *const libc::c_char,
39272            summary: 0 as *const libc::c_char,
39273            since: 0 as *const libc::c_char,
39274            flags: 0 as libc::c_int,
39275            deprecated_since: 0 as *const libc::c_char,
39276            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39277            num_args: 0,
39278        };
39279        init
39280    },
39281    {
39282        let mut init = redisCommandArg {
39283            name: b"milliseconds\0" as *const u8 as *const libc::c_char,
39284            type_0: ARG_TYPE_INTEGER,
39285            key_spec_index: -(1 as libc::c_int),
39286            token: 0 as *const libc::c_char,
39287            summary: 0 as *const libc::c_char,
39288            since: 0 as *const libc::c_char,
39289            flags: 0 as libc::c_int,
39290            deprecated_since: 0 as *const libc::c_char,
39291            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39292            num_args: 0,
39293        };
39294        init
39295    },
39296    {
39297        let mut init = redisCommandArg {
39298            name: b"value\0" as *const u8 as *const libc::c_char,
39299            type_0: ARG_TYPE_STRING,
39300            key_spec_index: -(1 as libc::c_int),
39301            token: 0 as *const libc::c_char,
39302            summary: 0 as *const libc::c_char,
39303            since: 0 as *const libc::c_char,
39304            flags: 0 as libc::c_int,
39305            deprecated_since: 0 as *const libc::c_char,
39306            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39307            num_args: 0,
39308        };
39309        init
39310    },
39311    {
39312        let mut init = redisCommandArg {
39313            name: 0 as *const libc::c_char,
39314            type_0: ARG_TYPE_STRING,
39315            key_spec_index: 0,
39316            token: 0 as *const libc::c_char,
39317            summary: 0 as *const libc::c_char,
39318            since: 0 as *const libc::c_char,
39319            flags: 0,
39320            deprecated_since: 0 as *const libc::c_char,
39321            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39322            num_args: 0,
39323        };
39324        init
39325    },
39326];
39327#[no_mangle]
39328pub static mut SET_History: [commandHistory; 5] = [
39329    {
39330        let mut init = commandHistory {
39331            since: b"2.6.12\0" as *const u8 as *const libc::c_char,
39332            changes: b"Added the `EX`, `PX`, `NX` and `XX` options.\0" as *const u8
39333                as *const libc::c_char,
39334        };
39335        init
39336    },
39337    {
39338        let mut init = commandHistory {
39339            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
39340            changes: b"Added the `KEEPTTL` option.\0" as *const u8 as *const libc::c_char,
39341        };
39342        init
39343    },
39344    {
39345        let mut init = commandHistory {
39346            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
39347            changes: b"Added the `GET`, `EXAT` and `PXAT` option.\0" as *const u8
39348                as *const libc::c_char,
39349        };
39350        init
39351    },
39352    {
39353        let mut init = commandHistory {
39354            since: b"7.0.0\0" as *const u8 as *const libc::c_char,
39355            changes: b"Allowed the `NX` and `GET` options to be used together.\0"
39356                as *const u8 as *const libc::c_char,
39357        };
39358        init
39359    },
39360    {
39361        let mut init = commandHistory {
39362            since: 0 as *const libc::c_char,
39363            changes: 0 as *const libc::c_char,
39364        };
39365        init
39366    },
39367];
39368#[no_mangle]
39369pub static mut SET_condition_Subargs: [redisCommandArg; 3] = [
39370    {
39371        let mut init = redisCommandArg {
39372            name: b"nx\0" as *const u8 as *const libc::c_char,
39373            type_0: ARG_TYPE_PURE_TOKEN,
39374            key_spec_index: -(1 as libc::c_int),
39375            token: b"NX\0" as *const u8 as *const libc::c_char,
39376            summary: 0 as *const libc::c_char,
39377            since: 0 as *const libc::c_char,
39378            flags: 0 as libc::c_int,
39379            deprecated_since: 0 as *const libc::c_char,
39380            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39381            num_args: 0,
39382        };
39383        init
39384    },
39385    {
39386        let mut init = redisCommandArg {
39387            name: b"xx\0" as *const u8 as *const libc::c_char,
39388            type_0: ARG_TYPE_PURE_TOKEN,
39389            key_spec_index: -(1 as libc::c_int),
39390            token: b"XX\0" as *const u8 as *const libc::c_char,
39391            summary: 0 as *const libc::c_char,
39392            since: 0 as *const libc::c_char,
39393            flags: 0 as libc::c_int,
39394            deprecated_since: 0 as *const libc::c_char,
39395            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39396            num_args: 0,
39397        };
39398        init
39399    },
39400    {
39401        let mut init = redisCommandArg {
39402            name: 0 as *const libc::c_char,
39403            type_0: ARG_TYPE_STRING,
39404            key_spec_index: 0,
39405            token: 0 as *const libc::c_char,
39406            summary: 0 as *const libc::c_char,
39407            since: 0 as *const libc::c_char,
39408            flags: 0,
39409            deprecated_since: 0 as *const libc::c_char,
39410            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39411            num_args: 0,
39412        };
39413        init
39414    },
39415];
39416#[no_mangle]
39417pub static mut SET_expiration_Subargs: [redisCommandArg; 6] = [
39418    {
39419        let mut init = redisCommandArg {
39420            name: b"seconds\0" as *const u8 as *const libc::c_char,
39421            type_0: ARG_TYPE_INTEGER,
39422            key_spec_index: -(1 as libc::c_int),
39423            token: b"EX\0" as *const u8 as *const libc::c_char,
39424            summary: 0 as *const libc::c_char,
39425            since: b"2.6.12\0" as *const u8 as *const libc::c_char,
39426            flags: 0 as libc::c_int,
39427            deprecated_since: 0 as *const libc::c_char,
39428            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39429            num_args: 0,
39430        };
39431        init
39432    },
39433    {
39434        let mut init = redisCommandArg {
39435            name: b"milliseconds\0" as *const u8 as *const libc::c_char,
39436            type_0: ARG_TYPE_INTEGER,
39437            key_spec_index: -(1 as libc::c_int),
39438            token: b"PX\0" as *const u8 as *const libc::c_char,
39439            summary: 0 as *const libc::c_char,
39440            since: b"2.6.12\0" as *const u8 as *const libc::c_char,
39441            flags: 0 as libc::c_int,
39442            deprecated_since: 0 as *const libc::c_char,
39443            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39444            num_args: 0,
39445        };
39446        init
39447    },
39448    {
39449        let mut init = redisCommandArg {
39450            name: b"unix-time-seconds\0" as *const u8 as *const libc::c_char,
39451            type_0: ARG_TYPE_UNIX_TIME,
39452            key_spec_index: -(1 as libc::c_int),
39453            token: b"EXAT\0" as *const u8 as *const libc::c_char,
39454            summary: 0 as *const libc::c_char,
39455            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
39456            flags: 0 as libc::c_int,
39457            deprecated_since: 0 as *const libc::c_char,
39458            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39459            num_args: 0,
39460        };
39461        init
39462    },
39463    {
39464        let mut init = redisCommandArg {
39465            name: b"unix-time-milliseconds\0" as *const u8 as *const libc::c_char,
39466            type_0: ARG_TYPE_UNIX_TIME,
39467            key_spec_index: -(1 as libc::c_int),
39468            token: b"PXAT\0" as *const u8 as *const libc::c_char,
39469            summary: 0 as *const libc::c_char,
39470            since: b"6.2.0\0" as *const u8 as *const libc::c_char,
39471            flags: 0 as libc::c_int,
39472            deprecated_since: 0 as *const libc::c_char,
39473            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39474            num_args: 0,
39475        };
39476        init
39477    },
39478    {
39479        let mut init = redisCommandArg {
39480            name: b"keepttl\0" as *const u8 as *const libc::c_char,
39481            type_0: ARG_TYPE_PURE_TOKEN,
39482            key_spec_index: -(1 as libc::c_int),
39483            token: b"KEEPTTL\0" as *const u8 as *const libc::c_char,
39484            summary: 0 as *const libc::c_char,
39485            since: b"6.0.0\0" as *const u8 as *const libc::c_char,
39486            flags: 0 as libc::c_int,
39487            deprecated_since: 0 as *const libc::c_char,
39488            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39489            num_args: 0,
39490        };
39491        init
39492    },
39493    {
39494        let mut init = redisCommandArg {
39495            name: 0 as *const libc::c_char,
39496            type_0: ARG_TYPE_STRING,
39497            key_spec_index: 0,
39498            token: 0 as *const libc::c_char,
39499            summary: 0 as *const libc::c_char,
39500            since: 0 as *const libc::c_char,
39501            flags: 0,
39502            deprecated_since: 0 as *const libc::c_char,
39503            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39504            num_args: 0,
39505        };
39506        init
39507    },
39508];
39509#[no_mangle]
39510pub static mut SET_Args: [redisCommandArg; 6] = unsafe {
39511    [
39512        {
39513            let mut init = redisCommandArg {
39514                name: b"key\0" as *const u8 as *const libc::c_char,
39515                type_0: ARG_TYPE_KEY,
39516                key_spec_index: 0 as libc::c_int,
39517                token: 0 as *const libc::c_char,
39518                summary: 0 as *const libc::c_char,
39519                since: 0 as *const libc::c_char,
39520                flags: 0 as libc::c_int,
39521                deprecated_since: 0 as *const libc::c_char,
39522                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39523                num_args: 0,
39524            };
39525            init
39526        },
39527        {
39528            let mut init = redisCommandArg {
39529                name: b"value\0" as *const u8 as *const libc::c_char,
39530                type_0: ARG_TYPE_STRING,
39531                key_spec_index: -(1 as libc::c_int),
39532                token: 0 as *const libc::c_char,
39533                summary: 0 as *const libc::c_char,
39534                since: 0 as *const libc::c_char,
39535                flags: 0 as libc::c_int,
39536                deprecated_since: 0 as *const libc::c_char,
39537                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39538                num_args: 0,
39539            };
39540            init
39541        },
39542        {
39543            let mut init = redisCommandArg {
39544                name: b"condition\0" as *const u8 as *const libc::c_char,
39545                type_0: ARG_TYPE_ONEOF,
39546                key_spec_index: -(1 as libc::c_int),
39547                token: 0 as *const libc::c_char,
39548                summary: 0 as *const libc::c_char,
39549                since: b"2.6.12\0" as *const u8 as *const libc::c_char,
39550                flags: (1 as libc::c_int) << 0 as libc::c_int,
39551                deprecated_since: 0 as *const libc::c_char,
39552                subargs: SET_condition_Subargs.as_ptr() as *mut _,
39553                num_args: 0,
39554            };
39555            init
39556        },
39557        {
39558            let mut init = redisCommandArg {
39559                name: b"get\0" as *const u8 as *const libc::c_char,
39560                type_0: ARG_TYPE_PURE_TOKEN,
39561                key_spec_index: -(1 as libc::c_int),
39562                token: b"GET\0" as *const u8 as *const libc::c_char,
39563                summary: 0 as *const libc::c_char,
39564                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
39565                flags: (1 as libc::c_int) << 0 as libc::c_int,
39566                deprecated_since: 0 as *const libc::c_char,
39567                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39568                num_args: 0,
39569            };
39570            init
39571        },
39572        {
39573            let mut init = redisCommandArg {
39574                name: b"expiration\0" as *const u8 as *const libc::c_char,
39575                type_0: ARG_TYPE_ONEOF,
39576                key_spec_index: -(1 as libc::c_int),
39577                token: 0 as *const libc::c_char,
39578                summary: 0 as *const libc::c_char,
39579                since: 0 as *const libc::c_char,
39580                flags: (1 as libc::c_int) << 0 as libc::c_int,
39581                deprecated_since: 0 as *const libc::c_char,
39582                subargs: SET_expiration_Subargs.as_ptr() as *mut _,
39583                num_args: 0,
39584            };
39585            init
39586        },
39587        {
39588            let mut init = redisCommandArg {
39589                name: 0 as *const libc::c_char,
39590                type_0: ARG_TYPE_STRING,
39591                key_spec_index: 0,
39592                token: 0 as *const libc::c_char,
39593                summary: 0 as *const libc::c_char,
39594                since: 0 as *const libc::c_char,
39595                flags: 0,
39596                deprecated_since: 0 as *const libc::c_char,
39597                subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39598                num_args: 0,
39599            };
39600            init
39601        },
39602    ]
39603};
39604#[no_mangle]
39605pub static mut SETEX_Args: [redisCommandArg; 4] = [
39606    {
39607        let mut init = redisCommandArg {
39608            name: b"key\0" as *const u8 as *const libc::c_char,
39609            type_0: ARG_TYPE_KEY,
39610            key_spec_index: 0 as libc::c_int,
39611            token: 0 as *const libc::c_char,
39612            summary: 0 as *const libc::c_char,
39613            since: 0 as *const libc::c_char,
39614            flags: 0 as libc::c_int,
39615            deprecated_since: 0 as *const libc::c_char,
39616            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39617            num_args: 0,
39618        };
39619        init
39620    },
39621    {
39622        let mut init = redisCommandArg {
39623            name: b"seconds\0" as *const u8 as *const libc::c_char,
39624            type_0: ARG_TYPE_INTEGER,
39625            key_spec_index: -(1 as libc::c_int),
39626            token: 0 as *const libc::c_char,
39627            summary: 0 as *const libc::c_char,
39628            since: 0 as *const libc::c_char,
39629            flags: 0 as libc::c_int,
39630            deprecated_since: 0 as *const libc::c_char,
39631            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39632            num_args: 0,
39633        };
39634        init
39635    },
39636    {
39637        let mut init = redisCommandArg {
39638            name: b"value\0" as *const u8 as *const libc::c_char,
39639            type_0: ARG_TYPE_STRING,
39640            key_spec_index: -(1 as libc::c_int),
39641            token: 0 as *const libc::c_char,
39642            summary: 0 as *const libc::c_char,
39643            since: 0 as *const libc::c_char,
39644            flags: 0 as libc::c_int,
39645            deprecated_since: 0 as *const libc::c_char,
39646            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39647            num_args: 0,
39648        };
39649        init
39650    },
39651    {
39652        let mut init = redisCommandArg {
39653            name: 0 as *const libc::c_char,
39654            type_0: ARG_TYPE_STRING,
39655            key_spec_index: 0,
39656            token: 0 as *const libc::c_char,
39657            summary: 0 as *const libc::c_char,
39658            since: 0 as *const libc::c_char,
39659            flags: 0,
39660            deprecated_since: 0 as *const libc::c_char,
39661            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39662            num_args: 0,
39663        };
39664        init
39665    },
39666];
39667#[no_mangle]
39668pub static mut SETNX_Args: [redisCommandArg; 3] = [
39669    {
39670        let mut init = redisCommandArg {
39671            name: b"key\0" as *const u8 as *const libc::c_char,
39672            type_0: ARG_TYPE_KEY,
39673            key_spec_index: 0 as libc::c_int,
39674            token: 0 as *const libc::c_char,
39675            summary: 0 as *const libc::c_char,
39676            since: 0 as *const libc::c_char,
39677            flags: 0 as libc::c_int,
39678            deprecated_since: 0 as *const libc::c_char,
39679            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39680            num_args: 0,
39681        };
39682        init
39683    },
39684    {
39685        let mut init = redisCommandArg {
39686            name: b"value\0" as *const u8 as *const libc::c_char,
39687            type_0: ARG_TYPE_STRING,
39688            key_spec_index: -(1 as libc::c_int),
39689            token: 0 as *const libc::c_char,
39690            summary: 0 as *const libc::c_char,
39691            since: 0 as *const libc::c_char,
39692            flags: 0 as libc::c_int,
39693            deprecated_since: 0 as *const libc::c_char,
39694            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39695            num_args: 0,
39696        };
39697        init
39698    },
39699    {
39700        let mut init = redisCommandArg {
39701            name: 0 as *const libc::c_char,
39702            type_0: ARG_TYPE_STRING,
39703            key_spec_index: 0,
39704            token: 0 as *const libc::c_char,
39705            summary: 0 as *const libc::c_char,
39706            since: 0 as *const libc::c_char,
39707            flags: 0,
39708            deprecated_since: 0 as *const libc::c_char,
39709            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39710            num_args: 0,
39711        };
39712        init
39713    },
39714];
39715#[no_mangle]
39716pub static mut SETRANGE_Args: [redisCommandArg; 4] = [
39717    {
39718        let mut init = redisCommandArg {
39719            name: b"key\0" as *const u8 as *const libc::c_char,
39720            type_0: ARG_TYPE_KEY,
39721            key_spec_index: 0 as libc::c_int,
39722            token: 0 as *const libc::c_char,
39723            summary: 0 as *const libc::c_char,
39724            since: 0 as *const libc::c_char,
39725            flags: 0 as libc::c_int,
39726            deprecated_since: 0 as *const libc::c_char,
39727            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39728            num_args: 0,
39729        };
39730        init
39731    },
39732    {
39733        let mut init = redisCommandArg {
39734            name: b"offset\0" as *const u8 as *const libc::c_char,
39735            type_0: ARG_TYPE_INTEGER,
39736            key_spec_index: -(1 as libc::c_int),
39737            token: 0 as *const libc::c_char,
39738            summary: 0 as *const libc::c_char,
39739            since: 0 as *const libc::c_char,
39740            flags: 0 as libc::c_int,
39741            deprecated_since: 0 as *const libc::c_char,
39742            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39743            num_args: 0,
39744        };
39745        init
39746    },
39747    {
39748        let mut init = redisCommandArg {
39749            name: b"value\0" as *const u8 as *const libc::c_char,
39750            type_0: ARG_TYPE_STRING,
39751            key_spec_index: -(1 as libc::c_int),
39752            token: 0 as *const libc::c_char,
39753            summary: 0 as *const libc::c_char,
39754            since: 0 as *const libc::c_char,
39755            flags: 0 as libc::c_int,
39756            deprecated_since: 0 as *const libc::c_char,
39757            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39758            num_args: 0,
39759        };
39760        init
39761    },
39762    {
39763        let mut init = redisCommandArg {
39764            name: 0 as *const libc::c_char,
39765            type_0: ARG_TYPE_STRING,
39766            key_spec_index: 0,
39767            token: 0 as *const libc::c_char,
39768            summary: 0 as *const libc::c_char,
39769            since: 0 as *const libc::c_char,
39770            flags: 0,
39771            deprecated_since: 0 as *const libc::c_char,
39772            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39773            num_args: 0,
39774        };
39775        init
39776    },
39777];
39778#[no_mangle]
39779pub static mut STRLEN_Args: [redisCommandArg; 2] = [
39780    {
39781        let mut init = redisCommandArg {
39782            name: b"key\0" as *const u8 as *const libc::c_char,
39783            type_0: ARG_TYPE_KEY,
39784            key_spec_index: 0 as libc::c_int,
39785            token: 0 as *const libc::c_char,
39786            summary: 0 as *const libc::c_char,
39787            since: 0 as *const libc::c_char,
39788            flags: 0 as libc::c_int,
39789            deprecated_since: 0 as *const libc::c_char,
39790            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39791            num_args: 0,
39792        };
39793        init
39794    },
39795    {
39796        let mut init = redisCommandArg {
39797            name: 0 as *const libc::c_char,
39798            type_0: ARG_TYPE_STRING,
39799            key_spec_index: 0,
39800            token: 0 as *const libc::c_char,
39801            summary: 0 as *const libc::c_char,
39802            since: 0 as *const libc::c_char,
39803            flags: 0,
39804            deprecated_since: 0 as *const libc::c_char,
39805            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39806            num_args: 0,
39807        };
39808        init
39809    },
39810];
39811#[no_mangle]
39812pub static mut SUBSTR_Args: [redisCommandArg; 4] = [
39813    {
39814        let mut init = redisCommandArg {
39815            name: b"key\0" as *const u8 as *const libc::c_char,
39816            type_0: ARG_TYPE_KEY,
39817            key_spec_index: 0 as libc::c_int,
39818            token: 0 as *const libc::c_char,
39819            summary: 0 as *const libc::c_char,
39820            since: 0 as *const libc::c_char,
39821            flags: 0 as libc::c_int,
39822            deprecated_since: 0 as *const libc::c_char,
39823            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39824            num_args: 0,
39825        };
39826        init
39827    },
39828    {
39829        let mut init = redisCommandArg {
39830            name: b"start\0" as *const u8 as *const libc::c_char,
39831            type_0: ARG_TYPE_INTEGER,
39832            key_spec_index: -(1 as libc::c_int),
39833            token: 0 as *const libc::c_char,
39834            summary: 0 as *const libc::c_char,
39835            since: 0 as *const libc::c_char,
39836            flags: 0 as libc::c_int,
39837            deprecated_since: 0 as *const libc::c_char,
39838            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39839            num_args: 0,
39840        };
39841        init
39842    },
39843    {
39844        let mut init = redisCommandArg {
39845            name: b"end\0" as *const u8 as *const libc::c_char,
39846            type_0: ARG_TYPE_INTEGER,
39847            key_spec_index: -(1 as libc::c_int),
39848            token: 0 as *const libc::c_char,
39849            summary: 0 as *const libc::c_char,
39850            since: 0 as *const libc::c_char,
39851            flags: 0 as libc::c_int,
39852            deprecated_since: 0 as *const libc::c_char,
39853            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39854            num_args: 0,
39855        };
39856        init
39857    },
39858    {
39859        let mut init = redisCommandArg {
39860            name: 0 as *const libc::c_char,
39861            type_0: ARG_TYPE_STRING,
39862            key_spec_index: 0,
39863            token: 0 as *const libc::c_char,
39864            summary: 0 as *const libc::c_char,
39865            since: 0 as *const libc::c_char,
39866            flags: 0,
39867            deprecated_since: 0 as *const libc::c_char,
39868            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39869            num_args: 0,
39870        };
39871        init
39872    },
39873];
39874#[no_mangle]
39875pub static mut WATCH_Args: [redisCommandArg; 2] = [
39876    {
39877        let mut init = redisCommandArg {
39878            name: b"key\0" as *const u8 as *const libc::c_char,
39879            type_0: ARG_TYPE_KEY,
39880            key_spec_index: 0 as libc::c_int,
39881            token: 0 as *const libc::c_char,
39882            summary: 0 as *const libc::c_char,
39883            since: 0 as *const libc::c_char,
39884            flags: (1 as libc::c_int) << 1 as libc::c_int,
39885            deprecated_since: 0 as *const libc::c_char,
39886            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39887            num_args: 0,
39888        };
39889        init
39890    },
39891    {
39892        let mut init = redisCommandArg {
39893            name: 0 as *const libc::c_char,
39894            type_0: ARG_TYPE_STRING,
39895            key_spec_index: 0,
39896            token: 0 as *const libc::c_char,
39897            summary: 0 as *const libc::c_char,
39898            since: 0 as *const libc::c_char,
39899            flags: 0,
39900            deprecated_since: 0 as *const libc::c_char,
39901            subargs: 0 as *const redisCommandArg as *mut redisCommandArg,
39902            num_args: 0,
39903        };
39904        init
39905    },
39906];
39907#[no_mangle]
39908pub static mut redisCommandTable: [redisCommand; 242] = unsafe {
39909    [
39910        {
39911            let mut init = redisCommand {
39912                declared_name: b"bitcount\0" as *const u8 as *const libc::c_char,
39913                summary: b"Count set bits in a string\0" as *const u8
39914                    as *const libc::c_char,
39915                complexity: b"O(N)\0" as *const u8 as *const libc::c_char,
39916                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
39917                doc_flags: 0 as libc::c_int,
39918                replaced_by: 0 as *const libc::c_char,
39919                deprecated_since: 0 as *const libc::c_char,
39920                group: COMMAND_GROUP_BITMAP,
39921                history: BITCOUNT_History.as_ptr() as *mut _,
39922                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
39923                proc_0: Some(bitcountCommand as unsafe extern "C" fn(*mut client) -> ()),
39924                arity: -(2 as libc::c_int),
39925                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
39926                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
39927                    as uint64_t,
39928                key_specs_static: [
39929                    {
39930                        let mut init = keySpec {
39931                            notes: 0 as *const libc::c_char,
39932                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
39933                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
39934                            begin_search_type: KSPEC_BS_INDEX,
39935                            bs: C2RustUnnamed_3 {
39936                                index: {
39937                                    let mut init = C2RustUnnamed_5 {
39938                                        pos: 1 as libc::c_int,
39939                                    };
39940                                    init
39941                                },
39942                            },
39943                            find_keys_type: KSPEC_FK_RANGE,
39944                            fk: C2RustUnnamed_0 {
39945                                range: {
39946                                    let mut init = C2RustUnnamed_2 {
39947                                        lastkey: 0 as libc::c_int,
39948                                        keystep: 1 as libc::c_int,
39949                                        limit: 0 as libc::c_int,
39950                                    };
39951                                    init
39952                                },
39953                            },
39954                        };
39955                        init
39956                    },
39957                    keySpec {
39958                        notes: 0 as *const libc::c_char,
39959                        flags: 0,
39960                        begin_search_type: KSPEC_BS_INVALID,
39961                        bs: C2RustUnnamed_3 {
39962                            index: C2RustUnnamed_5 { pos: 0 },
39963                        },
39964                        find_keys_type: KSPEC_FK_INVALID,
39965                        fk: C2RustUnnamed_0 {
39966                            range: C2RustUnnamed_2 {
39967                                lastkey: 0,
39968                                keystep: 0,
39969                                limit: 0,
39970                            },
39971                        },
39972                    },
39973                    keySpec {
39974                        notes: 0 as *const libc::c_char,
39975                        flags: 0,
39976                        begin_search_type: KSPEC_BS_INVALID,
39977                        bs: C2RustUnnamed_3 {
39978                            index: C2RustUnnamed_5 { pos: 0 },
39979                        },
39980                        find_keys_type: KSPEC_FK_INVALID,
39981                        fk: C2RustUnnamed_0 {
39982                            range: C2RustUnnamed_2 {
39983                                lastkey: 0,
39984                                keystep: 0,
39985                                limit: 0,
39986                            },
39987                        },
39988                    },
39989                    keySpec {
39990                        notes: 0 as *const libc::c_char,
39991                        flags: 0,
39992                        begin_search_type: KSPEC_BS_INVALID,
39993                        bs: C2RustUnnamed_3 {
39994                            index: C2RustUnnamed_5 { pos: 0 },
39995                        },
39996                        find_keys_type: KSPEC_FK_INVALID,
39997                        fk: C2RustUnnamed_0 {
39998                            range: C2RustUnnamed_2 {
39999                                lastkey: 0,
40000                                keystep: 0,
40001                                limit: 0,
40002                            },
40003                        },
40004                    },
40005                ],
40006                getkeys_proc: None,
40007                subcommands: 0 as *const redisCommand as *mut redisCommand,
40008                args: BITCOUNT_Args.as_ptr() as *mut _,
40009                microseconds: 0,
40010                calls: 0,
40011                rejected_calls: 0,
40012                failed_calls: 0,
40013                id: 0,
40014                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40015                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40016                key_specs: 0 as *const keySpec as *mut keySpec,
40017                legacy_range_key_spec: keySpec {
40018                    notes: 0 as *const libc::c_char,
40019                    flags: 0,
40020                    begin_search_type: KSPEC_BS_INVALID,
40021                    bs: C2RustUnnamed_3 {
40022                        index: C2RustUnnamed_5 { pos: 0 },
40023                    },
40024                    find_keys_type: KSPEC_FK_INVALID,
40025                    fk: C2RustUnnamed_0 {
40026                        range: C2RustUnnamed_2 {
40027                            lastkey: 0,
40028                            keystep: 0,
40029                            limit: 0,
40030                        },
40031                    },
40032                },
40033                num_args: 0,
40034                num_history: 0,
40035                num_tips: 0,
40036                key_specs_num: 0,
40037                key_specs_max: 0,
40038                subcommands_dict: 0 as *const dict as *mut dict,
40039                parent: 0 as *const redisCommand as *mut redisCommand,
40040                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40041            };
40042            init
40043        },
40044        {
40045            let mut init = redisCommand {
40046                declared_name: b"bitfield\0" as *const u8 as *const libc::c_char,
40047                summary: b"Perform arbitrary bitfield integer operations on strings\0"
40048                    as *const u8 as *const libc::c_char,
40049                complexity: b"O(1) for each subcommand specified\0" as *const u8
40050                    as *const libc::c_char,
40051                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
40052                doc_flags: 0 as libc::c_int,
40053                replaced_by: 0 as *const libc::c_char,
40054                deprecated_since: 0 as *const libc::c_char,
40055                group: COMMAND_GROUP_BITMAP,
40056                history: 0 as *const commandHistory as *mut commandHistory,
40057                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40058                proc_0: Some(bitfieldCommand as unsafe extern "C" fn(*mut client) -> ()),
40059                arity: -(2 as libc::c_int),
40060                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40061                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
40062                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40063                    as uint64_t,
40064                key_specs_static: [
40065                    {
40066                        let mut init = keySpec {
40067                            notes: b"This command allows both access and modification of the key\0"
40068                                as *const u8 as *const libc::c_char,
40069                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
40070                                | (1 as libc::c_ulonglong) << 5 as libc::c_int
40071                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
40072                                | (1 as libc::c_ulonglong) << 10 as libc::c_int)
40073                                as uint64_t,
40074                            begin_search_type: KSPEC_BS_INDEX,
40075                            bs: C2RustUnnamed_3 {
40076                                index: {
40077                                    let mut init = C2RustUnnamed_5 {
40078                                        pos: 1 as libc::c_int,
40079                                    };
40080                                    init
40081                                },
40082                            },
40083                            find_keys_type: KSPEC_FK_RANGE,
40084                            fk: C2RustUnnamed_0 {
40085                                range: {
40086                                    let mut init = C2RustUnnamed_2 {
40087                                        lastkey: 0 as libc::c_int,
40088                                        keystep: 1 as libc::c_int,
40089                                        limit: 0 as libc::c_int,
40090                                    };
40091                                    init
40092                                },
40093                            },
40094                        };
40095                        init
40096                    },
40097                    keySpec {
40098                        notes: 0 as *const libc::c_char,
40099                        flags: 0,
40100                        begin_search_type: KSPEC_BS_INVALID,
40101                        bs: C2RustUnnamed_3 {
40102                            index: C2RustUnnamed_5 { pos: 0 },
40103                        },
40104                        find_keys_type: KSPEC_FK_INVALID,
40105                        fk: C2RustUnnamed_0 {
40106                            range: C2RustUnnamed_2 {
40107                                lastkey: 0,
40108                                keystep: 0,
40109                                limit: 0,
40110                            },
40111                        },
40112                    },
40113                    keySpec {
40114                        notes: 0 as *const libc::c_char,
40115                        flags: 0,
40116                        begin_search_type: KSPEC_BS_INVALID,
40117                        bs: C2RustUnnamed_3 {
40118                            index: C2RustUnnamed_5 { pos: 0 },
40119                        },
40120                        find_keys_type: KSPEC_FK_INVALID,
40121                        fk: C2RustUnnamed_0 {
40122                            range: C2RustUnnamed_2 {
40123                                lastkey: 0,
40124                                keystep: 0,
40125                                limit: 0,
40126                            },
40127                        },
40128                    },
40129                    keySpec {
40130                        notes: 0 as *const libc::c_char,
40131                        flags: 0,
40132                        begin_search_type: KSPEC_BS_INVALID,
40133                        bs: C2RustUnnamed_3 {
40134                            index: C2RustUnnamed_5 { pos: 0 },
40135                        },
40136                        find_keys_type: KSPEC_FK_INVALID,
40137                        fk: C2RustUnnamed_0 {
40138                            range: C2RustUnnamed_2 {
40139                                lastkey: 0,
40140                                keystep: 0,
40141                                limit: 0,
40142                            },
40143                        },
40144                    },
40145                ],
40146                getkeys_proc: Some(
40147                    bitfieldGetKeys
40148                        as unsafe extern "C" fn(
40149                            *mut redisCommand,
40150                            *mut *mut robj,
40151                            libc::c_int,
40152                            *mut getKeysResult,
40153                        ) -> libc::c_int,
40154                ),
40155                subcommands: 0 as *const redisCommand as *mut redisCommand,
40156                args: BITFIELD_Args.as_ptr() as *mut _,
40157                microseconds: 0,
40158                calls: 0,
40159                rejected_calls: 0,
40160                failed_calls: 0,
40161                id: 0,
40162                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40163                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40164                key_specs: 0 as *const keySpec as *mut keySpec,
40165                legacy_range_key_spec: keySpec {
40166                    notes: 0 as *const libc::c_char,
40167                    flags: 0,
40168                    begin_search_type: KSPEC_BS_INVALID,
40169                    bs: C2RustUnnamed_3 {
40170                        index: C2RustUnnamed_5 { pos: 0 },
40171                    },
40172                    find_keys_type: KSPEC_FK_INVALID,
40173                    fk: C2RustUnnamed_0 {
40174                        range: C2RustUnnamed_2 {
40175                            lastkey: 0,
40176                            keystep: 0,
40177                            limit: 0,
40178                        },
40179                    },
40180                },
40181                num_args: 0,
40182                num_history: 0,
40183                num_tips: 0,
40184                key_specs_num: 0,
40185                key_specs_max: 0,
40186                subcommands_dict: 0 as *const dict as *mut dict,
40187                parent: 0 as *const redisCommand as *mut redisCommand,
40188                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40189            };
40190            init
40191        },
40192        {
40193            let mut init = redisCommand {
40194                declared_name: b"bitfield_ro\0" as *const u8 as *const libc::c_char,
40195                summary: b"Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD\0"
40196                    as *const u8 as *const libc::c_char,
40197                complexity: b"O(1) for each subcommand specified\0" as *const u8
40198                    as *const libc::c_char,
40199                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
40200                doc_flags: 0 as libc::c_int,
40201                replaced_by: 0 as *const libc::c_char,
40202                deprecated_since: 0 as *const libc::c_char,
40203                group: COMMAND_GROUP_BITMAP,
40204                history: 0 as *const commandHistory as *mut commandHistory,
40205                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40206                proc_0: Some(
40207                    bitfieldroCommand as unsafe extern "C" fn(*mut client) -> (),
40208                ),
40209                arity: -(2 as libc::c_int),
40210                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
40211                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
40212                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40213                    as uint64_t,
40214                key_specs_static: [
40215                    {
40216                        let mut init = keySpec {
40217                            notes: 0 as *const libc::c_char,
40218                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40219                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
40220                            begin_search_type: KSPEC_BS_INDEX,
40221                            bs: C2RustUnnamed_3 {
40222                                index: {
40223                                    let mut init = C2RustUnnamed_5 {
40224                                        pos: 1 as libc::c_int,
40225                                    };
40226                                    init
40227                                },
40228                            },
40229                            find_keys_type: KSPEC_FK_RANGE,
40230                            fk: C2RustUnnamed_0 {
40231                                range: {
40232                                    let mut init = C2RustUnnamed_2 {
40233                                        lastkey: 0 as libc::c_int,
40234                                        keystep: 1 as libc::c_int,
40235                                        limit: 0 as libc::c_int,
40236                                    };
40237                                    init
40238                                },
40239                            },
40240                        };
40241                        init
40242                    },
40243                    keySpec {
40244                        notes: 0 as *const libc::c_char,
40245                        flags: 0,
40246                        begin_search_type: KSPEC_BS_INVALID,
40247                        bs: C2RustUnnamed_3 {
40248                            index: C2RustUnnamed_5 { pos: 0 },
40249                        },
40250                        find_keys_type: KSPEC_FK_INVALID,
40251                        fk: C2RustUnnamed_0 {
40252                            range: C2RustUnnamed_2 {
40253                                lastkey: 0,
40254                                keystep: 0,
40255                                limit: 0,
40256                            },
40257                        },
40258                    },
40259                    keySpec {
40260                        notes: 0 as *const libc::c_char,
40261                        flags: 0,
40262                        begin_search_type: KSPEC_BS_INVALID,
40263                        bs: C2RustUnnamed_3 {
40264                            index: C2RustUnnamed_5 { pos: 0 },
40265                        },
40266                        find_keys_type: KSPEC_FK_INVALID,
40267                        fk: C2RustUnnamed_0 {
40268                            range: C2RustUnnamed_2 {
40269                                lastkey: 0,
40270                                keystep: 0,
40271                                limit: 0,
40272                            },
40273                        },
40274                    },
40275                    keySpec {
40276                        notes: 0 as *const libc::c_char,
40277                        flags: 0,
40278                        begin_search_type: KSPEC_BS_INVALID,
40279                        bs: C2RustUnnamed_3 {
40280                            index: C2RustUnnamed_5 { pos: 0 },
40281                        },
40282                        find_keys_type: KSPEC_FK_INVALID,
40283                        fk: C2RustUnnamed_0 {
40284                            range: C2RustUnnamed_2 {
40285                                lastkey: 0,
40286                                keystep: 0,
40287                                limit: 0,
40288                            },
40289                        },
40290                    },
40291                ],
40292                getkeys_proc: None,
40293                subcommands: 0 as *const redisCommand as *mut redisCommand,
40294                args: BITFIELD_RO_Args.as_ptr() as *mut _,
40295                microseconds: 0,
40296                calls: 0,
40297                rejected_calls: 0,
40298                failed_calls: 0,
40299                id: 0,
40300                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40301                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40302                key_specs: 0 as *const keySpec as *mut keySpec,
40303                legacy_range_key_spec: keySpec {
40304                    notes: 0 as *const libc::c_char,
40305                    flags: 0,
40306                    begin_search_type: KSPEC_BS_INVALID,
40307                    bs: C2RustUnnamed_3 {
40308                        index: C2RustUnnamed_5 { pos: 0 },
40309                    },
40310                    find_keys_type: KSPEC_FK_INVALID,
40311                    fk: C2RustUnnamed_0 {
40312                        range: C2RustUnnamed_2 {
40313                            lastkey: 0,
40314                            keystep: 0,
40315                            limit: 0,
40316                        },
40317                    },
40318                },
40319                num_args: 0,
40320                num_history: 0,
40321                num_tips: 0,
40322                key_specs_num: 0,
40323                key_specs_max: 0,
40324                subcommands_dict: 0 as *const dict as *mut dict,
40325                parent: 0 as *const redisCommand as *mut redisCommand,
40326                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40327            };
40328            init
40329        },
40330        {
40331            let mut init = redisCommand {
40332                declared_name: b"bitop\0" as *const u8 as *const libc::c_char,
40333                summary: b"Perform bitwise operations between strings\0" as *const u8
40334                    as *const libc::c_char,
40335                complexity: b"O(N)\0" as *const u8 as *const libc::c_char,
40336                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
40337                doc_flags: 0 as libc::c_int,
40338                replaced_by: 0 as *const libc::c_char,
40339                deprecated_since: 0 as *const libc::c_char,
40340                group: COMMAND_GROUP_BITMAP,
40341                history: 0 as *const commandHistory as *mut commandHistory,
40342                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40343                proc_0: Some(bitopCommand as unsafe extern "C" fn(*mut client) -> ()),
40344                arity: -(4 as libc::c_int),
40345                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40346                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
40347                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40348                    as uint64_t,
40349                key_specs_static: [
40350                    {
40351                        let mut init = keySpec {
40352                            notes: 0 as *const libc::c_char,
40353                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
40354                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
40355                            begin_search_type: KSPEC_BS_INDEX,
40356                            bs: C2RustUnnamed_3 {
40357                                index: {
40358                                    let mut init = C2RustUnnamed_5 {
40359                                        pos: 2 as libc::c_int,
40360                                    };
40361                                    init
40362                                },
40363                            },
40364                            find_keys_type: KSPEC_FK_RANGE,
40365                            fk: C2RustUnnamed_0 {
40366                                range: {
40367                                    let mut init = C2RustUnnamed_2 {
40368                                        lastkey: 0 as libc::c_int,
40369                                        keystep: 1 as libc::c_int,
40370                                        limit: 0 as libc::c_int,
40371                                    };
40372                                    init
40373                                },
40374                            },
40375                        };
40376                        init
40377                    },
40378                    {
40379                        let mut init = keySpec {
40380                            notes: 0 as *const libc::c_char,
40381                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40382                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
40383                            begin_search_type: KSPEC_BS_INDEX,
40384                            bs: C2RustUnnamed_3 {
40385                                index: {
40386                                    let mut init = C2RustUnnamed_5 {
40387                                        pos: 3 as libc::c_int,
40388                                    };
40389                                    init
40390                                },
40391                            },
40392                            find_keys_type: KSPEC_FK_RANGE,
40393                            fk: C2RustUnnamed_0 {
40394                                range: {
40395                                    let mut init = C2RustUnnamed_2 {
40396                                        lastkey: -(1 as libc::c_int),
40397                                        keystep: 1 as libc::c_int,
40398                                        limit: 0 as libc::c_int,
40399                                    };
40400                                    init
40401                                },
40402                            },
40403                        };
40404                        init
40405                    },
40406                    keySpec {
40407                        notes: 0 as *const libc::c_char,
40408                        flags: 0,
40409                        begin_search_type: KSPEC_BS_INVALID,
40410                        bs: C2RustUnnamed_3 {
40411                            index: C2RustUnnamed_5 { pos: 0 },
40412                        },
40413                        find_keys_type: KSPEC_FK_INVALID,
40414                        fk: C2RustUnnamed_0 {
40415                            range: C2RustUnnamed_2 {
40416                                lastkey: 0,
40417                                keystep: 0,
40418                                limit: 0,
40419                            },
40420                        },
40421                    },
40422                    keySpec {
40423                        notes: 0 as *const libc::c_char,
40424                        flags: 0,
40425                        begin_search_type: KSPEC_BS_INVALID,
40426                        bs: C2RustUnnamed_3 {
40427                            index: C2RustUnnamed_5 { pos: 0 },
40428                        },
40429                        find_keys_type: KSPEC_FK_INVALID,
40430                        fk: C2RustUnnamed_0 {
40431                            range: C2RustUnnamed_2 {
40432                                lastkey: 0,
40433                                keystep: 0,
40434                                limit: 0,
40435                            },
40436                        },
40437                    },
40438                ],
40439                getkeys_proc: None,
40440                subcommands: 0 as *const redisCommand as *mut redisCommand,
40441                args: BITOP_Args.as_ptr() as *mut _,
40442                microseconds: 0,
40443                calls: 0,
40444                rejected_calls: 0,
40445                failed_calls: 0,
40446                id: 0,
40447                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40448                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40449                key_specs: 0 as *const keySpec as *mut keySpec,
40450                legacy_range_key_spec: keySpec {
40451                    notes: 0 as *const libc::c_char,
40452                    flags: 0,
40453                    begin_search_type: KSPEC_BS_INVALID,
40454                    bs: C2RustUnnamed_3 {
40455                        index: C2RustUnnamed_5 { pos: 0 },
40456                    },
40457                    find_keys_type: KSPEC_FK_INVALID,
40458                    fk: C2RustUnnamed_0 {
40459                        range: C2RustUnnamed_2 {
40460                            lastkey: 0,
40461                            keystep: 0,
40462                            limit: 0,
40463                        },
40464                    },
40465                },
40466                num_args: 0,
40467                num_history: 0,
40468                num_tips: 0,
40469                key_specs_num: 0,
40470                key_specs_max: 0,
40471                subcommands_dict: 0 as *const dict as *mut dict,
40472                parent: 0 as *const redisCommand as *mut redisCommand,
40473                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40474            };
40475            init
40476        },
40477        {
40478            let mut init = redisCommand {
40479                declared_name: b"bitpos\0" as *const u8 as *const libc::c_char,
40480                summary: b"Find first bit set or clear in a string\0" as *const u8
40481                    as *const libc::c_char,
40482                complexity: b"O(N)\0" as *const u8 as *const libc::c_char,
40483                since: b"2.8.7\0" as *const u8 as *const libc::c_char,
40484                doc_flags: 0 as libc::c_int,
40485                replaced_by: 0 as *const libc::c_char,
40486                deprecated_since: 0 as *const libc::c_char,
40487                group: COMMAND_GROUP_BITMAP,
40488                history: BITPOS_History.as_ptr() as *mut _,
40489                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40490                proc_0: Some(bitposCommand as unsafe extern "C" fn(*mut client) -> ()),
40491                arity: -(3 as libc::c_int),
40492                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
40493                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40494                    as uint64_t,
40495                key_specs_static: [
40496                    {
40497                        let mut init = keySpec {
40498                            notes: 0 as *const libc::c_char,
40499                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40500                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
40501                            begin_search_type: KSPEC_BS_INDEX,
40502                            bs: C2RustUnnamed_3 {
40503                                index: {
40504                                    let mut init = C2RustUnnamed_5 {
40505                                        pos: 1 as libc::c_int,
40506                                    };
40507                                    init
40508                                },
40509                            },
40510                            find_keys_type: KSPEC_FK_RANGE,
40511                            fk: C2RustUnnamed_0 {
40512                                range: {
40513                                    let mut init = C2RustUnnamed_2 {
40514                                        lastkey: 0 as libc::c_int,
40515                                        keystep: 1 as libc::c_int,
40516                                        limit: 0 as libc::c_int,
40517                                    };
40518                                    init
40519                                },
40520                            },
40521                        };
40522                        init
40523                    },
40524                    keySpec {
40525                        notes: 0 as *const libc::c_char,
40526                        flags: 0,
40527                        begin_search_type: KSPEC_BS_INVALID,
40528                        bs: C2RustUnnamed_3 {
40529                            index: C2RustUnnamed_5 { pos: 0 },
40530                        },
40531                        find_keys_type: KSPEC_FK_INVALID,
40532                        fk: C2RustUnnamed_0 {
40533                            range: C2RustUnnamed_2 {
40534                                lastkey: 0,
40535                                keystep: 0,
40536                                limit: 0,
40537                            },
40538                        },
40539                    },
40540                    keySpec {
40541                        notes: 0 as *const libc::c_char,
40542                        flags: 0,
40543                        begin_search_type: KSPEC_BS_INVALID,
40544                        bs: C2RustUnnamed_3 {
40545                            index: C2RustUnnamed_5 { pos: 0 },
40546                        },
40547                        find_keys_type: KSPEC_FK_INVALID,
40548                        fk: C2RustUnnamed_0 {
40549                            range: C2RustUnnamed_2 {
40550                                lastkey: 0,
40551                                keystep: 0,
40552                                limit: 0,
40553                            },
40554                        },
40555                    },
40556                    keySpec {
40557                        notes: 0 as *const libc::c_char,
40558                        flags: 0,
40559                        begin_search_type: KSPEC_BS_INVALID,
40560                        bs: C2RustUnnamed_3 {
40561                            index: C2RustUnnamed_5 { pos: 0 },
40562                        },
40563                        find_keys_type: KSPEC_FK_INVALID,
40564                        fk: C2RustUnnamed_0 {
40565                            range: C2RustUnnamed_2 {
40566                                lastkey: 0,
40567                                keystep: 0,
40568                                limit: 0,
40569                            },
40570                        },
40571                    },
40572                ],
40573                getkeys_proc: None,
40574                subcommands: 0 as *const redisCommand as *mut redisCommand,
40575                args: BITPOS_Args.as_ptr() as *mut _,
40576                microseconds: 0,
40577                calls: 0,
40578                rejected_calls: 0,
40579                failed_calls: 0,
40580                id: 0,
40581                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40582                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40583                key_specs: 0 as *const keySpec as *mut keySpec,
40584                legacy_range_key_spec: keySpec {
40585                    notes: 0 as *const libc::c_char,
40586                    flags: 0,
40587                    begin_search_type: KSPEC_BS_INVALID,
40588                    bs: C2RustUnnamed_3 {
40589                        index: C2RustUnnamed_5 { pos: 0 },
40590                    },
40591                    find_keys_type: KSPEC_FK_INVALID,
40592                    fk: C2RustUnnamed_0 {
40593                        range: C2RustUnnamed_2 {
40594                            lastkey: 0,
40595                            keystep: 0,
40596                            limit: 0,
40597                        },
40598                    },
40599                },
40600                num_args: 0,
40601                num_history: 0,
40602                num_tips: 0,
40603                key_specs_num: 0,
40604                key_specs_max: 0,
40605                subcommands_dict: 0 as *const dict as *mut dict,
40606                parent: 0 as *const redisCommand as *mut redisCommand,
40607                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40608            };
40609            init
40610        },
40611        {
40612            let mut init = redisCommand {
40613                declared_name: b"getbit\0" as *const u8 as *const libc::c_char,
40614                summary: b"Returns the bit value at offset in the string value stored at key\0"
40615                    as *const u8 as *const libc::c_char,
40616                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
40617                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
40618                doc_flags: 0 as libc::c_int,
40619                replaced_by: 0 as *const libc::c_char,
40620                deprecated_since: 0 as *const libc::c_char,
40621                group: COMMAND_GROUP_BITMAP,
40622                history: 0 as *const commandHistory as *mut commandHistory,
40623                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40624                proc_0: Some(getbitCommand as unsafe extern "C" fn(*mut client) -> ()),
40625                arity: 3 as libc::c_int,
40626                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
40627                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
40628                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40629                    as uint64_t,
40630                key_specs_static: [
40631                    {
40632                        let mut init = keySpec {
40633                            notes: 0 as *const libc::c_char,
40634                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40635                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
40636                            begin_search_type: KSPEC_BS_INDEX,
40637                            bs: C2RustUnnamed_3 {
40638                                index: {
40639                                    let mut init = C2RustUnnamed_5 {
40640                                        pos: 1 as libc::c_int,
40641                                    };
40642                                    init
40643                                },
40644                            },
40645                            find_keys_type: KSPEC_FK_RANGE,
40646                            fk: C2RustUnnamed_0 {
40647                                range: {
40648                                    let mut init = C2RustUnnamed_2 {
40649                                        lastkey: 0 as libc::c_int,
40650                                        keystep: 1 as libc::c_int,
40651                                        limit: 0 as libc::c_int,
40652                                    };
40653                                    init
40654                                },
40655                            },
40656                        };
40657                        init
40658                    },
40659                    keySpec {
40660                        notes: 0 as *const libc::c_char,
40661                        flags: 0,
40662                        begin_search_type: KSPEC_BS_INVALID,
40663                        bs: C2RustUnnamed_3 {
40664                            index: C2RustUnnamed_5 { pos: 0 },
40665                        },
40666                        find_keys_type: KSPEC_FK_INVALID,
40667                        fk: C2RustUnnamed_0 {
40668                            range: C2RustUnnamed_2 {
40669                                lastkey: 0,
40670                                keystep: 0,
40671                                limit: 0,
40672                            },
40673                        },
40674                    },
40675                    keySpec {
40676                        notes: 0 as *const libc::c_char,
40677                        flags: 0,
40678                        begin_search_type: KSPEC_BS_INVALID,
40679                        bs: C2RustUnnamed_3 {
40680                            index: C2RustUnnamed_5 { pos: 0 },
40681                        },
40682                        find_keys_type: KSPEC_FK_INVALID,
40683                        fk: C2RustUnnamed_0 {
40684                            range: C2RustUnnamed_2 {
40685                                lastkey: 0,
40686                                keystep: 0,
40687                                limit: 0,
40688                            },
40689                        },
40690                    },
40691                    keySpec {
40692                        notes: 0 as *const libc::c_char,
40693                        flags: 0,
40694                        begin_search_type: KSPEC_BS_INVALID,
40695                        bs: C2RustUnnamed_3 {
40696                            index: C2RustUnnamed_5 { pos: 0 },
40697                        },
40698                        find_keys_type: KSPEC_FK_INVALID,
40699                        fk: C2RustUnnamed_0 {
40700                            range: C2RustUnnamed_2 {
40701                                lastkey: 0,
40702                                keystep: 0,
40703                                limit: 0,
40704                            },
40705                        },
40706                    },
40707                ],
40708                getkeys_proc: None,
40709                subcommands: 0 as *const redisCommand as *mut redisCommand,
40710                args: GETBIT_Args.as_ptr() as *mut _,
40711                microseconds: 0,
40712                calls: 0,
40713                rejected_calls: 0,
40714                failed_calls: 0,
40715                id: 0,
40716                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40717                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40718                key_specs: 0 as *const keySpec as *mut keySpec,
40719                legacy_range_key_spec: keySpec {
40720                    notes: 0 as *const libc::c_char,
40721                    flags: 0,
40722                    begin_search_type: KSPEC_BS_INVALID,
40723                    bs: C2RustUnnamed_3 {
40724                        index: C2RustUnnamed_5 { pos: 0 },
40725                    },
40726                    find_keys_type: KSPEC_FK_INVALID,
40727                    fk: C2RustUnnamed_0 {
40728                        range: C2RustUnnamed_2 {
40729                            lastkey: 0,
40730                            keystep: 0,
40731                            limit: 0,
40732                        },
40733                    },
40734                },
40735                num_args: 0,
40736                num_history: 0,
40737                num_tips: 0,
40738                key_specs_num: 0,
40739                key_specs_max: 0,
40740                subcommands_dict: 0 as *const dict as *mut dict,
40741                parent: 0 as *const redisCommand as *mut redisCommand,
40742                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40743            };
40744            init
40745        },
40746        {
40747            let mut init = redisCommand {
40748                declared_name: b"setbit\0" as *const u8 as *const libc::c_char,
40749                summary: b"Sets or clears the bit at offset in the string value stored at key\0"
40750                    as *const u8 as *const libc::c_char,
40751                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
40752                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
40753                doc_flags: 0 as libc::c_int,
40754                replaced_by: 0 as *const libc::c_char,
40755                deprecated_since: 0 as *const libc::c_char,
40756                group: COMMAND_GROUP_BITMAP,
40757                history: 0 as *const commandHistory as *mut commandHistory,
40758                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40759                proc_0: Some(setbitCommand as unsafe extern "C" fn(*mut client) -> ()),
40760                arity: 4 as libc::c_int,
40761                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
40762                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
40763                acl_categories: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
40764                    as uint64_t,
40765                key_specs_static: [
40766                    {
40767                        let mut init = keySpec {
40768                            notes: 0 as *const libc::c_char,
40769                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
40770                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
40771                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
40772                            begin_search_type: KSPEC_BS_INDEX,
40773                            bs: C2RustUnnamed_3 {
40774                                index: {
40775                                    let mut init = C2RustUnnamed_5 {
40776                                        pos: 1 as libc::c_int,
40777                                    };
40778                                    init
40779                                },
40780                            },
40781                            find_keys_type: KSPEC_FK_RANGE,
40782                            fk: C2RustUnnamed_0 {
40783                                range: {
40784                                    let mut init = C2RustUnnamed_2 {
40785                                        lastkey: 0 as libc::c_int,
40786                                        keystep: 1 as libc::c_int,
40787                                        limit: 0 as libc::c_int,
40788                                    };
40789                                    init
40790                                },
40791                            },
40792                        };
40793                        init
40794                    },
40795                    keySpec {
40796                        notes: 0 as *const libc::c_char,
40797                        flags: 0,
40798                        begin_search_type: KSPEC_BS_INVALID,
40799                        bs: C2RustUnnamed_3 {
40800                            index: C2RustUnnamed_5 { pos: 0 },
40801                        },
40802                        find_keys_type: KSPEC_FK_INVALID,
40803                        fk: C2RustUnnamed_0 {
40804                            range: C2RustUnnamed_2 {
40805                                lastkey: 0,
40806                                keystep: 0,
40807                                limit: 0,
40808                            },
40809                        },
40810                    },
40811                    keySpec {
40812                        notes: 0 as *const libc::c_char,
40813                        flags: 0,
40814                        begin_search_type: KSPEC_BS_INVALID,
40815                        bs: C2RustUnnamed_3 {
40816                            index: C2RustUnnamed_5 { pos: 0 },
40817                        },
40818                        find_keys_type: KSPEC_FK_INVALID,
40819                        fk: C2RustUnnamed_0 {
40820                            range: C2RustUnnamed_2 {
40821                                lastkey: 0,
40822                                keystep: 0,
40823                                limit: 0,
40824                            },
40825                        },
40826                    },
40827                    keySpec {
40828                        notes: 0 as *const libc::c_char,
40829                        flags: 0,
40830                        begin_search_type: KSPEC_BS_INVALID,
40831                        bs: C2RustUnnamed_3 {
40832                            index: C2RustUnnamed_5 { pos: 0 },
40833                        },
40834                        find_keys_type: KSPEC_FK_INVALID,
40835                        fk: C2RustUnnamed_0 {
40836                            range: C2RustUnnamed_2 {
40837                                lastkey: 0,
40838                                keystep: 0,
40839                                limit: 0,
40840                            },
40841                        },
40842                    },
40843                ],
40844                getkeys_proc: None,
40845                subcommands: 0 as *const redisCommand as *mut redisCommand,
40846                args: SETBIT_Args.as_ptr() as *mut _,
40847                microseconds: 0,
40848                calls: 0,
40849                rejected_calls: 0,
40850                failed_calls: 0,
40851                id: 0,
40852                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40853                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40854                key_specs: 0 as *const keySpec as *mut keySpec,
40855                legacy_range_key_spec: keySpec {
40856                    notes: 0 as *const libc::c_char,
40857                    flags: 0,
40858                    begin_search_type: KSPEC_BS_INVALID,
40859                    bs: C2RustUnnamed_3 {
40860                        index: C2RustUnnamed_5 { pos: 0 },
40861                    },
40862                    find_keys_type: KSPEC_FK_INVALID,
40863                    fk: C2RustUnnamed_0 {
40864                        range: C2RustUnnamed_2 {
40865                            lastkey: 0,
40866                            keystep: 0,
40867                            limit: 0,
40868                        },
40869                    },
40870                },
40871                num_args: 0,
40872                num_history: 0,
40873                num_tips: 0,
40874                key_specs_num: 0,
40875                key_specs_max: 0,
40876                subcommands_dict: 0 as *const dict as *mut dict,
40877                parent: 0 as *const redisCommand as *mut redisCommand,
40878                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40879            };
40880            init
40881        },
40882        {
40883            let mut init = redisCommand {
40884                declared_name: b"asking\0" as *const u8 as *const libc::c_char,
40885                summary: b"Sent by cluster clients after an -ASK redirect\0" as *const u8
40886                    as *const libc::c_char,
40887                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
40888                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
40889                doc_flags: 0 as libc::c_int,
40890                replaced_by: 0 as *const libc::c_char,
40891                deprecated_since: 0 as *const libc::c_char,
40892                group: COMMAND_GROUP_CLUSTER,
40893                history: 0 as *const commandHistory as *mut commandHistory,
40894                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40895                proc_0: Some(askingCommand as unsafe extern "C" fn(*mut client) -> ()),
40896                arity: 1 as libc::c_int,
40897                flags: ((1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
40898                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
40899                    as uint64_t,
40900                key_specs_static: [keySpec {
40901                    notes: 0 as *const libc::c_char,
40902                    flags: 0,
40903                    begin_search_type: KSPEC_BS_INVALID,
40904                    bs: C2RustUnnamed_3 {
40905                        index: C2RustUnnamed_5 { pos: 0 },
40906                    },
40907                    find_keys_type: KSPEC_FK_INVALID,
40908                    fk: C2RustUnnamed_0 {
40909                        range: C2RustUnnamed_2 {
40910                            lastkey: 0,
40911                            keystep: 0,
40912                            limit: 0,
40913                        },
40914                    },
40915                }; 4],
40916                getkeys_proc: None,
40917                subcommands: 0 as *const redisCommand as *mut redisCommand,
40918                args: 0 as *const redisCommandArg as *mut redisCommandArg,
40919                microseconds: 0,
40920                calls: 0,
40921                rejected_calls: 0,
40922                failed_calls: 0,
40923                id: 0,
40924                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40925                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40926                key_specs: 0 as *const keySpec as *mut keySpec,
40927                legacy_range_key_spec: keySpec {
40928                    notes: 0 as *const libc::c_char,
40929                    flags: 0,
40930                    begin_search_type: KSPEC_BS_INVALID,
40931                    bs: C2RustUnnamed_3 {
40932                        index: C2RustUnnamed_5 { pos: 0 },
40933                    },
40934                    find_keys_type: KSPEC_FK_INVALID,
40935                    fk: C2RustUnnamed_0 {
40936                        range: C2RustUnnamed_2 {
40937                            lastkey: 0,
40938                            keystep: 0,
40939                            limit: 0,
40940                        },
40941                    },
40942                },
40943                num_args: 0,
40944                num_history: 0,
40945                num_tips: 0,
40946                key_specs_num: 0,
40947                key_specs_max: 0,
40948                subcommands_dict: 0 as *const dict as *mut dict,
40949                parent: 0 as *const redisCommand as *mut redisCommand,
40950                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
40951            };
40952            init
40953        },
40954        {
40955            let mut init = redisCommand {
40956                declared_name: b"cluster\0" as *const u8 as *const libc::c_char,
40957                summary: b"A container for cluster commands\0" as *const u8
40958                    as *const libc::c_char,
40959                complexity: b"Depends on subcommand.\0" as *const u8
40960                    as *const libc::c_char,
40961                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
40962                doc_flags: 0 as libc::c_int,
40963                replaced_by: 0 as *const libc::c_char,
40964                deprecated_since: 0 as *const libc::c_char,
40965                group: COMMAND_GROUP_CLUSTER,
40966                history: 0 as *const commandHistory as *mut commandHistory,
40967                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
40968                proc_0: None,
40969                arity: -(2 as libc::c_int),
40970                flags: 0 as libc::c_int as uint64_t,
40971                acl_categories: 0 as libc::c_int as uint64_t,
40972                key_specs_static: [keySpec {
40973                    notes: 0 as *const libc::c_char,
40974                    flags: 0,
40975                    begin_search_type: KSPEC_BS_INVALID,
40976                    bs: C2RustUnnamed_3 {
40977                        index: C2RustUnnamed_5 { pos: 0 },
40978                    },
40979                    find_keys_type: KSPEC_FK_INVALID,
40980                    fk: C2RustUnnamed_0 {
40981                        range: C2RustUnnamed_2 {
40982                            lastkey: 0,
40983                            keystep: 0,
40984                            limit: 0,
40985                        },
40986                    },
40987                }; 4],
40988                getkeys_proc: None,
40989                subcommands: CLUSTER_Subcommands.as_ptr() as *mut _,
40990                args: 0 as *const redisCommandArg as *mut redisCommandArg,
40991                microseconds: 0,
40992                calls: 0,
40993                rejected_calls: 0,
40994                failed_calls: 0,
40995                id: 0,
40996                fullname: 0 as *const libc::c_char as *mut libc::c_char,
40997                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
40998                key_specs: 0 as *const keySpec as *mut keySpec,
40999                legacy_range_key_spec: keySpec {
41000                    notes: 0 as *const libc::c_char,
41001                    flags: 0,
41002                    begin_search_type: KSPEC_BS_INVALID,
41003                    bs: C2RustUnnamed_3 {
41004                        index: C2RustUnnamed_5 { pos: 0 },
41005                    },
41006                    find_keys_type: KSPEC_FK_INVALID,
41007                    fk: C2RustUnnamed_0 {
41008                        range: C2RustUnnamed_2 {
41009                            lastkey: 0,
41010                            keystep: 0,
41011                            limit: 0,
41012                        },
41013                    },
41014                },
41015                num_args: 0,
41016                num_history: 0,
41017                num_tips: 0,
41018                key_specs_num: 0,
41019                key_specs_max: 0,
41020                subcommands_dict: 0 as *const dict as *mut dict,
41021                parent: 0 as *const redisCommand as *mut redisCommand,
41022                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41023            };
41024            init
41025        },
41026        {
41027            let mut init = redisCommand {
41028                declared_name: b"readonly\0" as *const u8 as *const libc::c_char,
41029                summary: b"Enables read queries for a connection to a cluster replica node\0"
41030                    as *const u8 as *const libc::c_char,
41031                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41032                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
41033                doc_flags: 0 as libc::c_int,
41034                replaced_by: 0 as *const libc::c_char,
41035                deprecated_since: 0 as *const libc::c_char,
41036                group: COMMAND_GROUP_CLUSTER,
41037                history: 0 as *const commandHistory as *mut commandHistory,
41038                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41039                proc_0: Some(readonlyCommand as unsafe extern "C" fn(*mut client) -> ()),
41040                arity: 1 as libc::c_int,
41041                flags: ((1 as libc::c_ulonglong) << 14 as libc::c_int
41042                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41043                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
41044                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41045                    as uint64_t,
41046                key_specs_static: [keySpec {
41047                    notes: 0 as *const libc::c_char,
41048                    flags: 0,
41049                    begin_search_type: KSPEC_BS_INVALID,
41050                    bs: C2RustUnnamed_3 {
41051                        index: C2RustUnnamed_5 { pos: 0 },
41052                    },
41053                    find_keys_type: KSPEC_FK_INVALID,
41054                    fk: C2RustUnnamed_0 {
41055                        range: C2RustUnnamed_2 {
41056                            lastkey: 0,
41057                            keystep: 0,
41058                            limit: 0,
41059                        },
41060                    },
41061                }; 4],
41062                getkeys_proc: None,
41063                subcommands: 0 as *const redisCommand as *mut redisCommand,
41064                args: 0 as *const redisCommandArg as *mut redisCommandArg,
41065                microseconds: 0,
41066                calls: 0,
41067                rejected_calls: 0,
41068                failed_calls: 0,
41069                id: 0,
41070                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41071                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41072                key_specs: 0 as *const keySpec as *mut keySpec,
41073                legacy_range_key_spec: keySpec {
41074                    notes: 0 as *const libc::c_char,
41075                    flags: 0,
41076                    begin_search_type: KSPEC_BS_INVALID,
41077                    bs: C2RustUnnamed_3 {
41078                        index: C2RustUnnamed_5 { pos: 0 },
41079                    },
41080                    find_keys_type: KSPEC_FK_INVALID,
41081                    fk: C2RustUnnamed_0 {
41082                        range: C2RustUnnamed_2 {
41083                            lastkey: 0,
41084                            keystep: 0,
41085                            limit: 0,
41086                        },
41087                    },
41088                },
41089                num_args: 0,
41090                num_history: 0,
41091                num_tips: 0,
41092                key_specs_num: 0,
41093                key_specs_max: 0,
41094                subcommands_dict: 0 as *const dict as *mut dict,
41095                parent: 0 as *const redisCommand as *mut redisCommand,
41096                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41097            };
41098            init
41099        },
41100        {
41101            let mut init = redisCommand {
41102                declared_name: b"readwrite\0" as *const u8 as *const libc::c_char,
41103                summary: b"Disables read queries for a connection to a cluster replica node\0"
41104                    as *const u8 as *const libc::c_char,
41105                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41106                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
41107                doc_flags: 0 as libc::c_int,
41108                replaced_by: 0 as *const libc::c_char,
41109                deprecated_since: 0 as *const libc::c_char,
41110                group: COMMAND_GROUP_CLUSTER,
41111                history: 0 as *const commandHistory as *mut commandHistory,
41112                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41113                proc_0: Some(
41114                    readwriteCommand as unsafe extern "C" fn(*mut client) -> (),
41115                ),
41116                arity: 1 as libc::c_int,
41117                flags: ((1 as libc::c_ulonglong) << 14 as libc::c_int
41118                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41119                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
41120                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41121                    as uint64_t,
41122                key_specs_static: [keySpec {
41123                    notes: 0 as *const libc::c_char,
41124                    flags: 0,
41125                    begin_search_type: KSPEC_BS_INVALID,
41126                    bs: C2RustUnnamed_3 {
41127                        index: C2RustUnnamed_5 { pos: 0 },
41128                    },
41129                    find_keys_type: KSPEC_FK_INVALID,
41130                    fk: C2RustUnnamed_0 {
41131                        range: C2RustUnnamed_2 {
41132                            lastkey: 0,
41133                            keystep: 0,
41134                            limit: 0,
41135                        },
41136                    },
41137                }; 4],
41138                getkeys_proc: None,
41139                subcommands: 0 as *const redisCommand as *mut redisCommand,
41140                args: 0 as *const redisCommandArg as *mut redisCommandArg,
41141                microseconds: 0,
41142                calls: 0,
41143                rejected_calls: 0,
41144                failed_calls: 0,
41145                id: 0,
41146                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41147                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41148                key_specs: 0 as *const keySpec as *mut keySpec,
41149                legacy_range_key_spec: keySpec {
41150                    notes: 0 as *const libc::c_char,
41151                    flags: 0,
41152                    begin_search_type: KSPEC_BS_INVALID,
41153                    bs: C2RustUnnamed_3 {
41154                        index: C2RustUnnamed_5 { pos: 0 },
41155                    },
41156                    find_keys_type: KSPEC_FK_INVALID,
41157                    fk: C2RustUnnamed_0 {
41158                        range: C2RustUnnamed_2 {
41159                            lastkey: 0,
41160                            keystep: 0,
41161                            limit: 0,
41162                        },
41163                    },
41164                },
41165                num_args: 0,
41166                num_history: 0,
41167                num_tips: 0,
41168                key_specs_num: 0,
41169                key_specs_max: 0,
41170                subcommands_dict: 0 as *const dict as *mut dict,
41171                parent: 0 as *const redisCommand as *mut redisCommand,
41172                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41173            };
41174            init
41175        },
41176        {
41177            let mut init = redisCommand {
41178                declared_name: b"auth\0" as *const u8 as *const libc::c_char,
41179                summary: b"Authenticate to the server\0" as *const u8
41180                    as *const libc::c_char,
41181                complexity: b"O(N) where N is the number of passwords defined for the user\0"
41182                    as *const u8 as *const libc::c_char,
41183                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41184                doc_flags: 0 as libc::c_int,
41185                replaced_by: 0 as *const libc::c_char,
41186                deprecated_since: 0 as *const libc::c_char,
41187                group: COMMAND_GROUP_CONNECTION,
41188                history: AUTH_History.as_ptr() as *mut _,
41189                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41190                proc_0: Some(authCommand as unsafe extern "C" fn(*mut client) -> ()),
41191                arity: -(2 as libc::c_int),
41192                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
41193                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41194                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41195                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
41196                    | (1 as libc::c_ulonglong) << 15 as libc::c_int
41197                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
41198                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
41199                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41200                    as uint64_t,
41201                key_specs_static: [keySpec {
41202                    notes: 0 as *const libc::c_char,
41203                    flags: 0,
41204                    begin_search_type: KSPEC_BS_INVALID,
41205                    bs: C2RustUnnamed_3 {
41206                        index: C2RustUnnamed_5 { pos: 0 },
41207                    },
41208                    find_keys_type: KSPEC_FK_INVALID,
41209                    fk: C2RustUnnamed_0 {
41210                        range: C2RustUnnamed_2 {
41211                            lastkey: 0,
41212                            keystep: 0,
41213                            limit: 0,
41214                        },
41215                    },
41216                }; 4],
41217                getkeys_proc: None,
41218                subcommands: 0 as *const redisCommand as *mut redisCommand,
41219                args: AUTH_Args.as_ptr() as *mut _,
41220                microseconds: 0,
41221                calls: 0,
41222                rejected_calls: 0,
41223                failed_calls: 0,
41224                id: 0,
41225                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41226                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41227                key_specs: 0 as *const keySpec as *mut keySpec,
41228                legacy_range_key_spec: keySpec {
41229                    notes: 0 as *const libc::c_char,
41230                    flags: 0,
41231                    begin_search_type: KSPEC_BS_INVALID,
41232                    bs: C2RustUnnamed_3 {
41233                        index: C2RustUnnamed_5 { pos: 0 },
41234                    },
41235                    find_keys_type: KSPEC_FK_INVALID,
41236                    fk: C2RustUnnamed_0 {
41237                        range: C2RustUnnamed_2 {
41238                            lastkey: 0,
41239                            keystep: 0,
41240                            limit: 0,
41241                        },
41242                    },
41243                },
41244                num_args: 0,
41245                num_history: 0,
41246                num_tips: 0,
41247                key_specs_num: 0,
41248                key_specs_max: 0,
41249                subcommands_dict: 0 as *const dict as *mut dict,
41250                parent: 0 as *const redisCommand as *mut redisCommand,
41251                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41252            };
41253            init
41254        },
41255        {
41256            let mut init = redisCommand {
41257                declared_name: b"client\0" as *const u8 as *const libc::c_char,
41258                summary: b"A container for client connection commands\0" as *const u8
41259                    as *const libc::c_char,
41260                complexity: b"Depends on subcommand.\0" as *const u8
41261                    as *const libc::c_char,
41262                since: b"2.4.0\0" as *const u8 as *const libc::c_char,
41263                doc_flags: 0 as libc::c_int,
41264                replaced_by: 0 as *const libc::c_char,
41265                deprecated_since: 0 as *const libc::c_char,
41266                group: COMMAND_GROUP_CONNECTION,
41267                history: 0 as *const commandHistory as *mut commandHistory,
41268                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41269                proc_0: None,
41270                arity: -(2 as libc::c_int),
41271                flags: ((1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
41272                acl_categories: 0 as libc::c_int as uint64_t,
41273                key_specs_static: [keySpec {
41274                    notes: 0 as *const libc::c_char,
41275                    flags: 0,
41276                    begin_search_type: KSPEC_BS_INVALID,
41277                    bs: C2RustUnnamed_3 {
41278                        index: C2RustUnnamed_5 { pos: 0 },
41279                    },
41280                    find_keys_type: KSPEC_FK_INVALID,
41281                    fk: C2RustUnnamed_0 {
41282                        range: C2RustUnnamed_2 {
41283                            lastkey: 0,
41284                            keystep: 0,
41285                            limit: 0,
41286                        },
41287                    },
41288                }; 4],
41289                getkeys_proc: None,
41290                subcommands: CLIENT_Subcommands.as_ptr() as *mut _,
41291                args: 0 as *const redisCommandArg as *mut redisCommandArg,
41292                microseconds: 0,
41293                calls: 0,
41294                rejected_calls: 0,
41295                failed_calls: 0,
41296                id: 0,
41297                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41298                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41299                key_specs: 0 as *const keySpec as *mut keySpec,
41300                legacy_range_key_spec: keySpec {
41301                    notes: 0 as *const libc::c_char,
41302                    flags: 0,
41303                    begin_search_type: KSPEC_BS_INVALID,
41304                    bs: C2RustUnnamed_3 {
41305                        index: C2RustUnnamed_5 { pos: 0 },
41306                    },
41307                    find_keys_type: KSPEC_FK_INVALID,
41308                    fk: C2RustUnnamed_0 {
41309                        range: C2RustUnnamed_2 {
41310                            lastkey: 0,
41311                            keystep: 0,
41312                            limit: 0,
41313                        },
41314                    },
41315                },
41316                num_args: 0,
41317                num_history: 0,
41318                num_tips: 0,
41319                key_specs_num: 0,
41320                key_specs_max: 0,
41321                subcommands_dict: 0 as *const dict as *mut dict,
41322                parent: 0 as *const redisCommand as *mut redisCommand,
41323                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41324            };
41325            init
41326        },
41327        {
41328            let mut init = redisCommand {
41329                declared_name: b"echo\0" as *const u8 as *const libc::c_char,
41330                summary: b"Echo the given string\0" as *const u8 as *const libc::c_char,
41331                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41332                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41333                doc_flags: 0 as libc::c_int,
41334                replaced_by: 0 as *const libc::c_char,
41335                deprecated_since: 0 as *const libc::c_char,
41336                group: COMMAND_GROUP_CONNECTION,
41337                history: 0 as *const commandHistory as *mut commandHistory,
41338                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41339                proc_0: Some(echoCommand as unsafe extern "C" fn(*mut client) -> ()),
41340                arity: 2 as libc::c_int,
41341                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
41342                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41343                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
41344                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41345                    as uint64_t,
41346                key_specs_static: [keySpec {
41347                    notes: 0 as *const libc::c_char,
41348                    flags: 0,
41349                    begin_search_type: KSPEC_BS_INVALID,
41350                    bs: C2RustUnnamed_3 {
41351                        index: C2RustUnnamed_5 { pos: 0 },
41352                    },
41353                    find_keys_type: KSPEC_FK_INVALID,
41354                    fk: C2RustUnnamed_0 {
41355                        range: C2RustUnnamed_2 {
41356                            lastkey: 0,
41357                            keystep: 0,
41358                            limit: 0,
41359                        },
41360                    },
41361                }; 4],
41362                getkeys_proc: None,
41363                subcommands: 0 as *const redisCommand as *mut redisCommand,
41364                args: ECHO_Args.as_ptr() as *mut _,
41365                microseconds: 0,
41366                calls: 0,
41367                rejected_calls: 0,
41368                failed_calls: 0,
41369                id: 0,
41370                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41371                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41372                key_specs: 0 as *const keySpec as *mut keySpec,
41373                legacy_range_key_spec: keySpec {
41374                    notes: 0 as *const libc::c_char,
41375                    flags: 0,
41376                    begin_search_type: KSPEC_BS_INVALID,
41377                    bs: C2RustUnnamed_3 {
41378                        index: C2RustUnnamed_5 { pos: 0 },
41379                    },
41380                    find_keys_type: KSPEC_FK_INVALID,
41381                    fk: C2RustUnnamed_0 {
41382                        range: C2RustUnnamed_2 {
41383                            lastkey: 0,
41384                            keystep: 0,
41385                            limit: 0,
41386                        },
41387                    },
41388                },
41389                num_args: 0,
41390                num_history: 0,
41391                num_tips: 0,
41392                key_specs_num: 0,
41393                key_specs_max: 0,
41394                subcommands_dict: 0 as *const dict as *mut dict,
41395                parent: 0 as *const redisCommand as *mut redisCommand,
41396                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41397            };
41398            init
41399        },
41400        {
41401            let mut init = redisCommand {
41402                declared_name: b"hello\0" as *const u8 as *const libc::c_char,
41403                summary: b"Handshake with Redis\0" as *const u8 as *const libc::c_char,
41404                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41405                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
41406                doc_flags: 0 as libc::c_int,
41407                replaced_by: 0 as *const libc::c_char,
41408                deprecated_since: 0 as *const libc::c_char,
41409                group: COMMAND_GROUP_CONNECTION,
41410                history: HELLO_History.as_ptr() as *mut _,
41411                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41412                proc_0: Some(helloCommand as unsafe extern "C" fn(*mut client) -> ()),
41413                arity: -(1 as libc::c_int),
41414                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
41415                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41416                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41417                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
41418                    | (1 as libc::c_ulonglong) << 15 as libc::c_int
41419                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
41420                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
41421                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41422                    as uint64_t,
41423                key_specs_static: [keySpec {
41424                    notes: 0 as *const libc::c_char,
41425                    flags: 0,
41426                    begin_search_type: KSPEC_BS_INVALID,
41427                    bs: C2RustUnnamed_3 {
41428                        index: C2RustUnnamed_5 { pos: 0 },
41429                    },
41430                    find_keys_type: KSPEC_FK_INVALID,
41431                    fk: C2RustUnnamed_0 {
41432                        range: C2RustUnnamed_2 {
41433                            lastkey: 0,
41434                            keystep: 0,
41435                            limit: 0,
41436                        },
41437                    },
41438                }; 4],
41439                getkeys_proc: None,
41440                subcommands: 0 as *const redisCommand as *mut redisCommand,
41441                args: HELLO_Args.as_ptr() as *mut _,
41442                microseconds: 0,
41443                calls: 0,
41444                rejected_calls: 0,
41445                failed_calls: 0,
41446                id: 0,
41447                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41448                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41449                key_specs: 0 as *const keySpec as *mut keySpec,
41450                legacy_range_key_spec: keySpec {
41451                    notes: 0 as *const libc::c_char,
41452                    flags: 0,
41453                    begin_search_type: KSPEC_BS_INVALID,
41454                    bs: C2RustUnnamed_3 {
41455                        index: C2RustUnnamed_5 { pos: 0 },
41456                    },
41457                    find_keys_type: KSPEC_FK_INVALID,
41458                    fk: C2RustUnnamed_0 {
41459                        range: C2RustUnnamed_2 {
41460                            lastkey: 0,
41461                            keystep: 0,
41462                            limit: 0,
41463                        },
41464                    },
41465                },
41466                num_args: 0,
41467                num_history: 0,
41468                num_tips: 0,
41469                key_specs_num: 0,
41470                key_specs_max: 0,
41471                subcommands_dict: 0 as *const dict as *mut dict,
41472                parent: 0 as *const redisCommand as *mut redisCommand,
41473                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41474            };
41475            init
41476        },
41477        {
41478            let mut init = redisCommand {
41479                declared_name: b"ping\0" as *const u8 as *const libc::c_char,
41480                summary: b"Ping the server\0" as *const u8 as *const libc::c_char,
41481                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41482                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41483                doc_flags: 0 as libc::c_int,
41484                replaced_by: 0 as *const libc::c_char,
41485                deprecated_since: 0 as *const libc::c_char,
41486                group: COMMAND_GROUP_CONNECTION,
41487                history: 0 as *const commandHistory as *mut commandHistory,
41488                tips: PING_tips.as_ptr() as *mut _,
41489                proc_0: Some(pingCommand as unsafe extern "C" fn(*mut client) -> ()),
41490                arity: -(1 as libc::c_int),
41491                flags: ((1 as libc::c_ulonglong) << 14 as libc::c_int
41492                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
41493                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41494                    as uint64_t,
41495                key_specs_static: [keySpec {
41496                    notes: 0 as *const libc::c_char,
41497                    flags: 0,
41498                    begin_search_type: KSPEC_BS_INVALID,
41499                    bs: C2RustUnnamed_3 {
41500                        index: C2RustUnnamed_5 { pos: 0 },
41501                    },
41502                    find_keys_type: KSPEC_FK_INVALID,
41503                    fk: C2RustUnnamed_0 {
41504                        range: C2RustUnnamed_2 {
41505                            lastkey: 0,
41506                            keystep: 0,
41507                            limit: 0,
41508                        },
41509                    },
41510                }; 4],
41511                getkeys_proc: None,
41512                subcommands: 0 as *const redisCommand as *mut redisCommand,
41513                args: PING_Args.as_ptr() as *mut _,
41514                microseconds: 0,
41515                calls: 0,
41516                rejected_calls: 0,
41517                failed_calls: 0,
41518                id: 0,
41519                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41520                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41521                key_specs: 0 as *const keySpec as *mut keySpec,
41522                legacy_range_key_spec: keySpec {
41523                    notes: 0 as *const libc::c_char,
41524                    flags: 0,
41525                    begin_search_type: KSPEC_BS_INVALID,
41526                    bs: C2RustUnnamed_3 {
41527                        index: C2RustUnnamed_5 { pos: 0 },
41528                    },
41529                    find_keys_type: KSPEC_FK_INVALID,
41530                    fk: C2RustUnnamed_0 {
41531                        range: C2RustUnnamed_2 {
41532                            lastkey: 0,
41533                            keystep: 0,
41534                            limit: 0,
41535                        },
41536                    },
41537                },
41538                num_args: 0,
41539                num_history: 0,
41540                num_tips: 0,
41541                key_specs_num: 0,
41542                key_specs_max: 0,
41543                subcommands_dict: 0 as *const dict as *mut dict,
41544                parent: 0 as *const redisCommand as *mut redisCommand,
41545                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41546            };
41547            init
41548        },
41549        {
41550            let mut init = redisCommand {
41551                declared_name: b"quit\0" as *const u8 as *const libc::c_char,
41552                summary: b"Close the connection\0" as *const u8 as *const libc::c_char,
41553                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41554                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41555                doc_flags: 0 as libc::c_int,
41556                replaced_by: 0 as *const libc::c_char,
41557                deprecated_since: 0 as *const libc::c_char,
41558                group: COMMAND_GROUP_CONNECTION,
41559                history: 0 as *const commandHistory as *mut commandHistory,
41560                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41561                proc_0: Some(quitCommand as unsafe extern "C" fn(*mut client) -> ()),
41562                arity: -(1 as libc::c_int),
41563                flags: ((1 as libc::c_ulonglong) << 26 as libc::c_int
41564                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
41565                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41566                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41567                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
41568                    | (1 as libc::c_ulonglong) << 15 as libc::c_int) as uint64_t,
41569                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41570                    as uint64_t,
41571                key_specs_static: [keySpec {
41572                    notes: 0 as *const libc::c_char,
41573                    flags: 0,
41574                    begin_search_type: KSPEC_BS_INVALID,
41575                    bs: C2RustUnnamed_3 {
41576                        index: C2RustUnnamed_5 { pos: 0 },
41577                    },
41578                    find_keys_type: KSPEC_FK_INVALID,
41579                    fk: C2RustUnnamed_0 {
41580                        range: C2RustUnnamed_2 {
41581                            lastkey: 0,
41582                            keystep: 0,
41583                            limit: 0,
41584                        },
41585                    },
41586                }; 4],
41587                getkeys_proc: None,
41588                subcommands: 0 as *const redisCommand as *mut redisCommand,
41589                args: 0 as *const redisCommandArg as *mut redisCommandArg,
41590                microseconds: 0,
41591                calls: 0,
41592                rejected_calls: 0,
41593                failed_calls: 0,
41594                id: 0,
41595                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41596                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41597                key_specs: 0 as *const keySpec as *mut keySpec,
41598                legacy_range_key_spec: keySpec {
41599                    notes: 0 as *const libc::c_char,
41600                    flags: 0,
41601                    begin_search_type: KSPEC_BS_INVALID,
41602                    bs: C2RustUnnamed_3 {
41603                        index: C2RustUnnamed_5 { pos: 0 },
41604                    },
41605                    find_keys_type: KSPEC_FK_INVALID,
41606                    fk: C2RustUnnamed_0 {
41607                        range: C2RustUnnamed_2 {
41608                            lastkey: 0,
41609                            keystep: 0,
41610                            limit: 0,
41611                        },
41612                    },
41613                },
41614                num_args: 0,
41615                num_history: 0,
41616                num_tips: 0,
41617                key_specs_num: 0,
41618                key_specs_max: 0,
41619                subcommands_dict: 0 as *const dict as *mut dict,
41620                parent: 0 as *const redisCommand as *mut redisCommand,
41621                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41622            };
41623            init
41624        },
41625        {
41626            let mut init = redisCommand {
41627                declared_name: b"reset\0" as *const u8 as *const libc::c_char,
41628                summary: b"Reset the connection\0" as *const u8 as *const libc::c_char,
41629                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41630                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
41631                doc_flags: 0 as libc::c_int,
41632                replaced_by: 0 as *const libc::c_char,
41633                deprecated_since: 0 as *const libc::c_char,
41634                group: COMMAND_GROUP_CONNECTION,
41635                history: 0 as *const commandHistory as *mut commandHistory,
41636                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41637                proc_0: Some(resetCommand as unsafe extern "C" fn(*mut client) -> ()),
41638                arity: 1 as libc::c_int,
41639                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
41640                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
41641                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41642                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
41643                    | (1 as libc::c_ulonglong) << 15 as libc::c_int
41644                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
41645                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41646                    as uint64_t,
41647                key_specs_static: [keySpec {
41648                    notes: 0 as *const libc::c_char,
41649                    flags: 0,
41650                    begin_search_type: KSPEC_BS_INVALID,
41651                    bs: C2RustUnnamed_3 {
41652                        index: C2RustUnnamed_5 { pos: 0 },
41653                    },
41654                    find_keys_type: KSPEC_FK_INVALID,
41655                    fk: C2RustUnnamed_0 {
41656                        range: C2RustUnnamed_2 {
41657                            lastkey: 0,
41658                            keystep: 0,
41659                            limit: 0,
41660                        },
41661                    },
41662                }; 4],
41663                getkeys_proc: None,
41664                subcommands: 0 as *const redisCommand as *mut redisCommand,
41665                args: 0 as *const redisCommandArg as *mut redisCommandArg,
41666                microseconds: 0,
41667                calls: 0,
41668                rejected_calls: 0,
41669                failed_calls: 0,
41670                id: 0,
41671                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41672                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41673                key_specs: 0 as *const keySpec as *mut keySpec,
41674                legacy_range_key_spec: keySpec {
41675                    notes: 0 as *const libc::c_char,
41676                    flags: 0,
41677                    begin_search_type: KSPEC_BS_INVALID,
41678                    bs: C2RustUnnamed_3 {
41679                        index: C2RustUnnamed_5 { pos: 0 },
41680                    },
41681                    find_keys_type: KSPEC_FK_INVALID,
41682                    fk: C2RustUnnamed_0 {
41683                        range: C2RustUnnamed_2 {
41684                            lastkey: 0,
41685                            keystep: 0,
41686                            limit: 0,
41687                        },
41688                    },
41689                },
41690                num_args: 0,
41691                num_history: 0,
41692                num_tips: 0,
41693                key_specs_num: 0,
41694                key_specs_max: 0,
41695                subcommands_dict: 0 as *const dict as *mut dict,
41696                parent: 0 as *const redisCommand as *mut redisCommand,
41697                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41698            };
41699            init
41700        },
41701        {
41702            let mut init = redisCommand {
41703                declared_name: b"select\0" as *const u8 as *const libc::c_char,
41704                summary: b"Change the selected database for the current connection\0"
41705                    as *const u8 as *const libc::c_char,
41706                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
41707                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41708                doc_flags: 0 as libc::c_int,
41709                replaced_by: 0 as *const libc::c_char,
41710                deprecated_since: 0 as *const libc::c_char,
41711                group: COMMAND_GROUP_CONNECTION,
41712                history: 0 as *const commandHistory as *mut commandHistory,
41713                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41714                proc_0: Some(selectCommand as unsafe extern "C" fn(*mut client) -> ()),
41715                arity: 2 as libc::c_int,
41716                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
41717                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
41718                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
41719                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
41720                    as uint64_t,
41721                key_specs_static: [keySpec {
41722                    notes: 0 as *const libc::c_char,
41723                    flags: 0,
41724                    begin_search_type: KSPEC_BS_INVALID,
41725                    bs: C2RustUnnamed_3 {
41726                        index: C2RustUnnamed_5 { pos: 0 },
41727                    },
41728                    find_keys_type: KSPEC_FK_INVALID,
41729                    fk: C2RustUnnamed_0 {
41730                        range: C2RustUnnamed_2 {
41731                            lastkey: 0,
41732                            keystep: 0,
41733                            limit: 0,
41734                        },
41735                    },
41736                }; 4],
41737                getkeys_proc: None,
41738                subcommands: 0 as *const redisCommand as *mut redisCommand,
41739                args: SELECT_Args.as_ptr() as *mut _,
41740                microseconds: 0,
41741                calls: 0,
41742                rejected_calls: 0,
41743                failed_calls: 0,
41744                id: 0,
41745                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41746                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41747                key_specs: 0 as *const keySpec as *mut keySpec,
41748                legacy_range_key_spec: keySpec {
41749                    notes: 0 as *const libc::c_char,
41750                    flags: 0,
41751                    begin_search_type: KSPEC_BS_INVALID,
41752                    bs: C2RustUnnamed_3 {
41753                        index: C2RustUnnamed_5 { pos: 0 },
41754                    },
41755                    find_keys_type: KSPEC_FK_INVALID,
41756                    fk: C2RustUnnamed_0 {
41757                        range: C2RustUnnamed_2 {
41758                            lastkey: 0,
41759                            keystep: 0,
41760                            limit: 0,
41761                        },
41762                    },
41763                },
41764                num_args: 0,
41765                num_history: 0,
41766                num_tips: 0,
41767                key_specs_num: 0,
41768                key_specs_max: 0,
41769                subcommands_dict: 0 as *const dict as *mut dict,
41770                parent: 0 as *const redisCommand as *mut redisCommand,
41771                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41772            };
41773            init
41774        },
41775        {
41776            let mut init = redisCommand {
41777                declared_name: b"copy\0" as *const u8 as *const libc::c_char,
41778                summary: b"Copy a key\0" as *const u8 as *const libc::c_char,
41779                complexity: b"O(N) worst case for collections, where N is the number of nested items. O(1) for string values.\0"
41780                    as *const u8 as *const libc::c_char,
41781                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
41782                doc_flags: 0 as libc::c_int,
41783                replaced_by: 0 as *const libc::c_char,
41784                deprecated_since: 0 as *const libc::c_char,
41785                group: COMMAND_GROUP_GENERIC,
41786                history: 0 as *const commandHistory as *mut commandHistory,
41787                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
41788                proc_0: Some(copyCommand as unsafe extern "C" fn(*mut client) -> ()),
41789                arity: -(3 as libc::c_int),
41790                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
41791                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
41792                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
41793                    as uint64_t,
41794                key_specs_static: [
41795                    {
41796                        let mut init = keySpec {
41797                            notes: 0 as *const libc::c_char,
41798                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
41799                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
41800                            begin_search_type: KSPEC_BS_INDEX,
41801                            bs: C2RustUnnamed_3 {
41802                                index: {
41803                                    let mut init = C2RustUnnamed_5 {
41804                                        pos: 1 as libc::c_int,
41805                                    };
41806                                    init
41807                                },
41808                            },
41809                            find_keys_type: KSPEC_FK_RANGE,
41810                            fk: C2RustUnnamed_0 {
41811                                range: {
41812                                    let mut init = C2RustUnnamed_2 {
41813                                        lastkey: 0 as libc::c_int,
41814                                        keystep: 1 as libc::c_int,
41815                                        limit: 0 as libc::c_int,
41816                                    };
41817                                    init
41818                                },
41819                            },
41820                        };
41821                        init
41822                    },
41823                    {
41824                        let mut init = keySpec {
41825                            notes: 0 as *const libc::c_char,
41826                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
41827                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
41828                            begin_search_type: KSPEC_BS_INDEX,
41829                            bs: C2RustUnnamed_3 {
41830                                index: {
41831                                    let mut init = C2RustUnnamed_5 {
41832                                        pos: 2 as libc::c_int,
41833                                    };
41834                                    init
41835                                },
41836                            },
41837                            find_keys_type: KSPEC_FK_RANGE,
41838                            fk: C2RustUnnamed_0 {
41839                                range: {
41840                                    let mut init = C2RustUnnamed_2 {
41841                                        lastkey: 0 as libc::c_int,
41842                                        keystep: 1 as libc::c_int,
41843                                        limit: 0 as libc::c_int,
41844                                    };
41845                                    init
41846                                },
41847                            },
41848                        };
41849                        init
41850                    },
41851                    keySpec {
41852                        notes: 0 as *const libc::c_char,
41853                        flags: 0,
41854                        begin_search_type: KSPEC_BS_INVALID,
41855                        bs: C2RustUnnamed_3 {
41856                            index: C2RustUnnamed_5 { pos: 0 },
41857                        },
41858                        find_keys_type: KSPEC_FK_INVALID,
41859                        fk: C2RustUnnamed_0 {
41860                            range: C2RustUnnamed_2 {
41861                                lastkey: 0,
41862                                keystep: 0,
41863                                limit: 0,
41864                            },
41865                        },
41866                    },
41867                    keySpec {
41868                        notes: 0 as *const libc::c_char,
41869                        flags: 0,
41870                        begin_search_type: KSPEC_BS_INVALID,
41871                        bs: C2RustUnnamed_3 {
41872                            index: C2RustUnnamed_5 { pos: 0 },
41873                        },
41874                        find_keys_type: KSPEC_FK_INVALID,
41875                        fk: C2RustUnnamed_0 {
41876                            range: C2RustUnnamed_2 {
41877                                lastkey: 0,
41878                                keystep: 0,
41879                                limit: 0,
41880                            },
41881                        },
41882                    },
41883                ],
41884                getkeys_proc: None,
41885                subcommands: 0 as *const redisCommand as *mut redisCommand,
41886                args: COPY_Args.as_ptr() as *mut _,
41887                microseconds: 0,
41888                calls: 0,
41889                rejected_calls: 0,
41890                failed_calls: 0,
41891                id: 0,
41892                fullname: 0 as *const libc::c_char as *mut libc::c_char,
41893                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
41894                key_specs: 0 as *const keySpec as *mut keySpec,
41895                legacy_range_key_spec: keySpec {
41896                    notes: 0 as *const libc::c_char,
41897                    flags: 0,
41898                    begin_search_type: KSPEC_BS_INVALID,
41899                    bs: C2RustUnnamed_3 {
41900                        index: C2RustUnnamed_5 { pos: 0 },
41901                    },
41902                    find_keys_type: KSPEC_FK_INVALID,
41903                    fk: C2RustUnnamed_0 {
41904                        range: C2RustUnnamed_2 {
41905                            lastkey: 0,
41906                            keystep: 0,
41907                            limit: 0,
41908                        },
41909                    },
41910                },
41911                num_args: 0,
41912                num_history: 0,
41913                num_tips: 0,
41914                key_specs_num: 0,
41915                key_specs_max: 0,
41916                subcommands_dict: 0 as *const dict as *mut dict,
41917                parent: 0 as *const redisCommand as *mut redisCommand,
41918                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
41919            };
41920            init
41921        },
41922        {
41923            let mut init = redisCommand {
41924                declared_name: b"del\0" as *const u8 as *const libc::c_char,
41925                summary: b"Delete a key\0" as *const u8 as *const libc::c_char,
41926                complexity: b"O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).\0"
41927                    as *const u8 as *const libc::c_char,
41928                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
41929                doc_flags: 0 as libc::c_int,
41930                replaced_by: 0 as *const libc::c_char,
41931                deprecated_since: 0 as *const libc::c_char,
41932                group: COMMAND_GROUP_GENERIC,
41933                history: 0 as *const commandHistory as *mut commandHistory,
41934                tips: DEL_tips.as_ptr() as *mut _,
41935                proc_0: Some(delCommand as unsafe extern "C" fn(*mut client) -> ()),
41936                arity: -(2 as libc::c_int),
41937                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
41938                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
41939                    as uint64_t,
41940                key_specs_static: [
41941                    {
41942                        let mut init = keySpec {
41943                            notes: 0 as *const libc::c_char,
41944                            flags: ((1 as libc::c_ulonglong) << 3 as libc::c_int
41945                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
41946                            begin_search_type: KSPEC_BS_INDEX,
41947                            bs: C2RustUnnamed_3 {
41948                                index: {
41949                                    let mut init = C2RustUnnamed_5 {
41950                                        pos: 1 as libc::c_int,
41951                                    };
41952                                    init
41953                                },
41954                            },
41955                            find_keys_type: KSPEC_FK_RANGE,
41956                            fk: C2RustUnnamed_0 {
41957                                range: {
41958                                    let mut init = C2RustUnnamed_2 {
41959                                        lastkey: -(1 as libc::c_int),
41960                                        keystep: 1 as libc::c_int,
41961                                        limit: 0 as libc::c_int,
41962                                    };
41963                                    init
41964                                },
41965                            },
41966                        };
41967                        init
41968                    },
41969                    keySpec {
41970                        notes: 0 as *const libc::c_char,
41971                        flags: 0,
41972                        begin_search_type: KSPEC_BS_INVALID,
41973                        bs: C2RustUnnamed_3 {
41974                            index: C2RustUnnamed_5 { pos: 0 },
41975                        },
41976                        find_keys_type: KSPEC_FK_INVALID,
41977                        fk: C2RustUnnamed_0 {
41978                            range: C2RustUnnamed_2 {
41979                                lastkey: 0,
41980                                keystep: 0,
41981                                limit: 0,
41982                            },
41983                        },
41984                    },
41985                    keySpec {
41986                        notes: 0 as *const libc::c_char,
41987                        flags: 0,
41988                        begin_search_type: KSPEC_BS_INVALID,
41989                        bs: C2RustUnnamed_3 {
41990                            index: C2RustUnnamed_5 { pos: 0 },
41991                        },
41992                        find_keys_type: KSPEC_FK_INVALID,
41993                        fk: C2RustUnnamed_0 {
41994                            range: C2RustUnnamed_2 {
41995                                lastkey: 0,
41996                                keystep: 0,
41997                                limit: 0,
41998                            },
41999                        },
42000                    },
42001                    keySpec {
42002                        notes: 0 as *const libc::c_char,
42003                        flags: 0,
42004                        begin_search_type: KSPEC_BS_INVALID,
42005                        bs: C2RustUnnamed_3 {
42006                            index: C2RustUnnamed_5 { pos: 0 },
42007                        },
42008                        find_keys_type: KSPEC_FK_INVALID,
42009                        fk: C2RustUnnamed_0 {
42010                            range: C2RustUnnamed_2 {
42011                                lastkey: 0,
42012                                keystep: 0,
42013                                limit: 0,
42014                            },
42015                        },
42016                    },
42017                ],
42018                getkeys_proc: None,
42019                subcommands: 0 as *const redisCommand as *mut redisCommand,
42020                args: DEL_Args.as_ptr() as *mut _,
42021                microseconds: 0,
42022                calls: 0,
42023                rejected_calls: 0,
42024                failed_calls: 0,
42025                id: 0,
42026                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42027                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42028                key_specs: 0 as *const keySpec as *mut keySpec,
42029                legacy_range_key_spec: keySpec {
42030                    notes: 0 as *const libc::c_char,
42031                    flags: 0,
42032                    begin_search_type: KSPEC_BS_INVALID,
42033                    bs: C2RustUnnamed_3 {
42034                        index: C2RustUnnamed_5 { pos: 0 },
42035                    },
42036                    find_keys_type: KSPEC_FK_INVALID,
42037                    fk: C2RustUnnamed_0 {
42038                        range: C2RustUnnamed_2 {
42039                            lastkey: 0,
42040                            keystep: 0,
42041                            limit: 0,
42042                        },
42043                    },
42044                },
42045                num_args: 0,
42046                num_history: 0,
42047                num_tips: 0,
42048                key_specs_num: 0,
42049                key_specs_max: 0,
42050                subcommands_dict: 0 as *const dict as *mut dict,
42051                parent: 0 as *const redisCommand as *mut redisCommand,
42052                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42053            };
42054            init
42055        },
42056        {
42057            let mut init = redisCommand {
42058                declared_name: b"dump\0" as *const u8 as *const libc::c_char,
42059                summary: b"Return a serialized version of the value stored at the specified key.\0"
42060                    as *const u8 as *const libc::c_char,
42061                complexity: b"O(1) to access the key and additional O(N*M) to serialize it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).\0"
42062                    as *const u8 as *const libc::c_char,
42063                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
42064                doc_flags: 0 as libc::c_int,
42065                replaced_by: 0 as *const libc::c_char,
42066                deprecated_since: 0 as *const libc::c_char,
42067                group: COMMAND_GROUP_GENERIC,
42068                history: 0 as *const commandHistory as *mut commandHistory,
42069                tips: DUMP_tips.as_ptr() as *mut _,
42070                proc_0: Some(dumpCommand as unsafe extern "C" fn(*mut client) -> ()),
42071                arity: 2 as libc::c_int,
42072                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
42073                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42074                    as uint64_t,
42075                key_specs_static: [
42076                    {
42077                        let mut init = keySpec {
42078                            notes: 0 as *const libc::c_char,
42079                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42080                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
42081                            begin_search_type: KSPEC_BS_INDEX,
42082                            bs: C2RustUnnamed_3 {
42083                                index: {
42084                                    let mut init = C2RustUnnamed_5 {
42085                                        pos: 1 as libc::c_int,
42086                                    };
42087                                    init
42088                                },
42089                            },
42090                            find_keys_type: KSPEC_FK_RANGE,
42091                            fk: C2RustUnnamed_0 {
42092                                range: {
42093                                    let mut init = C2RustUnnamed_2 {
42094                                        lastkey: 0 as libc::c_int,
42095                                        keystep: 1 as libc::c_int,
42096                                        limit: 0 as libc::c_int,
42097                                    };
42098                                    init
42099                                },
42100                            },
42101                        };
42102                        init
42103                    },
42104                    keySpec {
42105                        notes: 0 as *const libc::c_char,
42106                        flags: 0,
42107                        begin_search_type: KSPEC_BS_INVALID,
42108                        bs: C2RustUnnamed_3 {
42109                            index: C2RustUnnamed_5 { pos: 0 },
42110                        },
42111                        find_keys_type: KSPEC_FK_INVALID,
42112                        fk: C2RustUnnamed_0 {
42113                            range: C2RustUnnamed_2 {
42114                                lastkey: 0,
42115                                keystep: 0,
42116                                limit: 0,
42117                            },
42118                        },
42119                    },
42120                    keySpec {
42121                        notes: 0 as *const libc::c_char,
42122                        flags: 0,
42123                        begin_search_type: KSPEC_BS_INVALID,
42124                        bs: C2RustUnnamed_3 {
42125                            index: C2RustUnnamed_5 { pos: 0 },
42126                        },
42127                        find_keys_type: KSPEC_FK_INVALID,
42128                        fk: C2RustUnnamed_0 {
42129                            range: C2RustUnnamed_2 {
42130                                lastkey: 0,
42131                                keystep: 0,
42132                                limit: 0,
42133                            },
42134                        },
42135                    },
42136                    keySpec {
42137                        notes: 0 as *const libc::c_char,
42138                        flags: 0,
42139                        begin_search_type: KSPEC_BS_INVALID,
42140                        bs: C2RustUnnamed_3 {
42141                            index: C2RustUnnamed_5 { pos: 0 },
42142                        },
42143                        find_keys_type: KSPEC_FK_INVALID,
42144                        fk: C2RustUnnamed_0 {
42145                            range: C2RustUnnamed_2 {
42146                                lastkey: 0,
42147                                keystep: 0,
42148                                limit: 0,
42149                            },
42150                        },
42151                    },
42152                ],
42153                getkeys_proc: None,
42154                subcommands: 0 as *const redisCommand as *mut redisCommand,
42155                args: DUMP_Args.as_ptr() as *mut _,
42156                microseconds: 0,
42157                calls: 0,
42158                rejected_calls: 0,
42159                failed_calls: 0,
42160                id: 0,
42161                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42162                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42163                key_specs: 0 as *const keySpec as *mut keySpec,
42164                legacy_range_key_spec: keySpec {
42165                    notes: 0 as *const libc::c_char,
42166                    flags: 0,
42167                    begin_search_type: KSPEC_BS_INVALID,
42168                    bs: C2RustUnnamed_3 {
42169                        index: C2RustUnnamed_5 { pos: 0 },
42170                    },
42171                    find_keys_type: KSPEC_FK_INVALID,
42172                    fk: C2RustUnnamed_0 {
42173                        range: C2RustUnnamed_2 {
42174                            lastkey: 0,
42175                            keystep: 0,
42176                            limit: 0,
42177                        },
42178                    },
42179                },
42180                num_args: 0,
42181                num_history: 0,
42182                num_tips: 0,
42183                key_specs_num: 0,
42184                key_specs_max: 0,
42185                subcommands_dict: 0 as *const dict as *mut dict,
42186                parent: 0 as *const redisCommand as *mut redisCommand,
42187                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42188            };
42189            init
42190        },
42191        {
42192            let mut init = redisCommand {
42193                declared_name: b"exists\0" as *const u8 as *const libc::c_char,
42194                summary: b"Determine if a key exists\0" as *const u8
42195                    as *const libc::c_char,
42196                complexity: b"O(N) where N is the number of keys to check.\0"
42197                    as *const u8 as *const libc::c_char,
42198                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
42199                doc_flags: 0 as libc::c_int,
42200                replaced_by: 0 as *const libc::c_char,
42201                deprecated_since: 0 as *const libc::c_char,
42202                group: COMMAND_GROUP_GENERIC,
42203                history: EXISTS_History.as_ptr() as *mut _,
42204                tips: EXISTS_tips.as_ptr() as *mut _,
42205                proc_0: Some(existsCommand as unsafe extern "C" fn(*mut client) -> ()),
42206                arity: -(2 as libc::c_int),
42207                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42208                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
42209                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42210                    as uint64_t,
42211                key_specs_static: [
42212                    {
42213                        let mut init = keySpec {
42214                            notes: 0 as *const libc::c_char,
42215                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42216                                as uint64_t,
42217                            begin_search_type: KSPEC_BS_INDEX,
42218                            bs: C2RustUnnamed_3 {
42219                                index: {
42220                                    let mut init = C2RustUnnamed_5 {
42221                                        pos: 1 as libc::c_int,
42222                                    };
42223                                    init
42224                                },
42225                            },
42226                            find_keys_type: KSPEC_FK_RANGE,
42227                            fk: C2RustUnnamed_0 {
42228                                range: {
42229                                    let mut init = C2RustUnnamed_2 {
42230                                        lastkey: -(1 as libc::c_int),
42231                                        keystep: 1 as libc::c_int,
42232                                        limit: 0 as libc::c_int,
42233                                    };
42234                                    init
42235                                },
42236                            },
42237                        };
42238                        init
42239                    },
42240                    keySpec {
42241                        notes: 0 as *const libc::c_char,
42242                        flags: 0,
42243                        begin_search_type: KSPEC_BS_INVALID,
42244                        bs: C2RustUnnamed_3 {
42245                            index: C2RustUnnamed_5 { pos: 0 },
42246                        },
42247                        find_keys_type: KSPEC_FK_INVALID,
42248                        fk: C2RustUnnamed_0 {
42249                            range: C2RustUnnamed_2 {
42250                                lastkey: 0,
42251                                keystep: 0,
42252                                limit: 0,
42253                            },
42254                        },
42255                    },
42256                    keySpec {
42257                        notes: 0 as *const libc::c_char,
42258                        flags: 0,
42259                        begin_search_type: KSPEC_BS_INVALID,
42260                        bs: C2RustUnnamed_3 {
42261                            index: C2RustUnnamed_5 { pos: 0 },
42262                        },
42263                        find_keys_type: KSPEC_FK_INVALID,
42264                        fk: C2RustUnnamed_0 {
42265                            range: C2RustUnnamed_2 {
42266                                lastkey: 0,
42267                                keystep: 0,
42268                                limit: 0,
42269                            },
42270                        },
42271                    },
42272                    keySpec {
42273                        notes: 0 as *const libc::c_char,
42274                        flags: 0,
42275                        begin_search_type: KSPEC_BS_INVALID,
42276                        bs: C2RustUnnamed_3 {
42277                            index: C2RustUnnamed_5 { pos: 0 },
42278                        },
42279                        find_keys_type: KSPEC_FK_INVALID,
42280                        fk: C2RustUnnamed_0 {
42281                            range: C2RustUnnamed_2 {
42282                                lastkey: 0,
42283                                keystep: 0,
42284                                limit: 0,
42285                            },
42286                        },
42287                    },
42288                ],
42289                getkeys_proc: None,
42290                subcommands: 0 as *const redisCommand as *mut redisCommand,
42291                args: EXISTS_Args.as_ptr() as *mut _,
42292                microseconds: 0,
42293                calls: 0,
42294                rejected_calls: 0,
42295                failed_calls: 0,
42296                id: 0,
42297                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42298                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42299                key_specs: 0 as *const keySpec as *mut keySpec,
42300                legacy_range_key_spec: keySpec {
42301                    notes: 0 as *const libc::c_char,
42302                    flags: 0,
42303                    begin_search_type: KSPEC_BS_INVALID,
42304                    bs: C2RustUnnamed_3 {
42305                        index: C2RustUnnamed_5 { pos: 0 },
42306                    },
42307                    find_keys_type: KSPEC_FK_INVALID,
42308                    fk: C2RustUnnamed_0 {
42309                        range: C2RustUnnamed_2 {
42310                            lastkey: 0,
42311                            keystep: 0,
42312                            limit: 0,
42313                        },
42314                    },
42315                },
42316                num_args: 0,
42317                num_history: 0,
42318                num_tips: 0,
42319                key_specs_num: 0,
42320                key_specs_max: 0,
42321                subcommands_dict: 0 as *const dict as *mut dict,
42322                parent: 0 as *const redisCommand as *mut redisCommand,
42323                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42324            };
42325            init
42326        },
42327        {
42328            let mut init = redisCommand {
42329                declared_name: b"expire\0" as *const u8 as *const libc::c_char,
42330                summary: b"Set a key's time to live in seconds\0" as *const u8
42331                    as *const libc::c_char,
42332                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
42333                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
42334                doc_flags: 0 as libc::c_int,
42335                replaced_by: 0 as *const libc::c_char,
42336                deprecated_since: 0 as *const libc::c_char,
42337                group: COMMAND_GROUP_GENERIC,
42338                history: EXPIRE_History.as_ptr() as *mut _,
42339                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
42340                proc_0: Some(expireCommand as unsafe extern "C" fn(*mut client) -> ()),
42341                arity: -(3 as libc::c_int),
42342                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42343                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
42344                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42345                    as uint64_t,
42346                key_specs_static: [
42347                    {
42348                        let mut init = keySpec {
42349                            notes: 0 as *const libc::c_char,
42350                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42351                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
42352                            begin_search_type: KSPEC_BS_INDEX,
42353                            bs: C2RustUnnamed_3 {
42354                                index: {
42355                                    let mut init = C2RustUnnamed_5 {
42356                                        pos: 1 as libc::c_int,
42357                                    };
42358                                    init
42359                                },
42360                            },
42361                            find_keys_type: KSPEC_FK_RANGE,
42362                            fk: C2RustUnnamed_0 {
42363                                range: {
42364                                    let mut init = C2RustUnnamed_2 {
42365                                        lastkey: 0 as libc::c_int,
42366                                        keystep: 1 as libc::c_int,
42367                                        limit: 0 as libc::c_int,
42368                                    };
42369                                    init
42370                                },
42371                            },
42372                        };
42373                        init
42374                    },
42375                    keySpec {
42376                        notes: 0 as *const libc::c_char,
42377                        flags: 0,
42378                        begin_search_type: KSPEC_BS_INVALID,
42379                        bs: C2RustUnnamed_3 {
42380                            index: C2RustUnnamed_5 { pos: 0 },
42381                        },
42382                        find_keys_type: KSPEC_FK_INVALID,
42383                        fk: C2RustUnnamed_0 {
42384                            range: C2RustUnnamed_2 {
42385                                lastkey: 0,
42386                                keystep: 0,
42387                                limit: 0,
42388                            },
42389                        },
42390                    },
42391                    keySpec {
42392                        notes: 0 as *const libc::c_char,
42393                        flags: 0,
42394                        begin_search_type: KSPEC_BS_INVALID,
42395                        bs: C2RustUnnamed_3 {
42396                            index: C2RustUnnamed_5 { pos: 0 },
42397                        },
42398                        find_keys_type: KSPEC_FK_INVALID,
42399                        fk: C2RustUnnamed_0 {
42400                            range: C2RustUnnamed_2 {
42401                                lastkey: 0,
42402                                keystep: 0,
42403                                limit: 0,
42404                            },
42405                        },
42406                    },
42407                    keySpec {
42408                        notes: 0 as *const libc::c_char,
42409                        flags: 0,
42410                        begin_search_type: KSPEC_BS_INVALID,
42411                        bs: C2RustUnnamed_3 {
42412                            index: C2RustUnnamed_5 { pos: 0 },
42413                        },
42414                        find_keys_type: KSPEC_FK_INVALID,
42415                        fk: C2RustUnnamed_0 {
42416                            range: C2RustUnnamed_2 {
42417                                lastkey: 0,
42418                                keystep: 0,
42419                                limit: 0,
42420                            },
42421                        },
42422                    },
42423                ],
42424                getkeys_proc: None,
42425                subcommands: 0 as *const redisCommand as *mut redisCommand,
42426                args: EXPIRE_Args.as_ptr() as *mut _,
42427                microseconds: 0,
42428                calls: 0,
42429                rejected_calls: 0,
42430                failed_calls: 0,
42431                id: 0,
42432                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42433                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42434                key_specs: 0 as *const keySpec as *mut keySpec,
42435                legacy_range_key_spec: keySpec {
42436                    notes: 0 as *const libc::c_char,
42437                    flags: 0,
42438                    begin_search_type: KSPEC_BS_INVALID,
42439                    bs: C2RustUnnamed_3 {
42440                        index: C2RustUnnamed_5 { pos: 0 },
42441                    },
42442                    find_keys_type: KSPEC_FK_INVALID,
42443                    fk: C2RustUnnamed_0 {
42444                        range: C2RustUnnamed_2 {
42445                            lastkey: 0,
42446                            keystep: 0,
42447                            limit: 0,
42448                        },
42449                    },
42450                },
42451                num_args: 0,
42452                num_history: 0,
42453                num_tips: 0,
42454                key_specs_num: 0,
42455                key_specs_max: 0,
42456                subcommands_dict: 0 as *const dict as *mut dict,
42457                parent: 0 as *const redisCommand as *mut redisCommand,
42458                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42459            };
42460            init
42461        },
42462        {
42463            let mut init = redisCommand {
42464                declared_name: b"expireat\0" as *const u8 as *const libc::c_char,
42465                summary: b"Set the expiration for a key as a UNIX timestamp\0"
42466                    as *const u8 as *const libc::c_char,
42467                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
42468                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
42469                doc_flags: 0 as libc::c_int,
42470                replaced_by: 0 as *const libc::c_char,
42471                deprecated_since: 0 as *const libc::c_char,
42472                group: COMMAND_GROUP_GENERIC,
42473                history: EXPIREAT_History.as_ptr() as *mut _,
42474                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
42475                proc_0: Some(expireatCommand as unsafe extern "C" fn(*mut client) -> ()),
42476                arity: -(3 as libc::c_int),
42477                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42478                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
42479                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42480                    as uint64_t,
42481                key_specs_static: [
42482                    {
42483                        let mut init = keySpec {
42484                            notes: 0 as *const libc::c_char,
42485                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42486                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
42487                            begin_search_type: KSPEC_BS_INDEX,
42488                            bs: C2RustUnnamed_3 {
42489                                index: {
42490                                    let mut init = C2RustUnnamed_5 {
42491                                        pos: 1 as libc::c_int,
42492                                    };
42493                                    init
42494                                },
42495                            },
42496                            find_keys_type: KSPEC_FK_RANGE,
42497                            fk: C2RustUnnamed_0 {
42498                                range: {
42499                                    let mut init = C2RustUnnamed_2 {
42500                                        lastkey: 0 as libc::c_int,
42501                                        keystep: 1 as libc::c_int,
42502                                        limit: 0 as libc::c_int,
42503                                    };
42504                                    init
42505                                },
42506                            },
42507                        };
42508                        init
42509                    },
42510                    keySpec {
42511                        notes: 0 as *const libc::c_char,
42512                        flags: 0,
42513                        begin_search_type: KSPEC_BS_INVALID,
42514                        bs: C2RustUnnamed_3 {
42515                            index: C2RustUnnamed_5 { pos: 0 },
42516                        },
42517                        find_keys_type: KSPEC_FK_INVALID,
42518                        fk: C2RustUnnamed_0 {
42519                            range: C2RustUnnamed_2 {
42520                                lastkey: 0,
42521                                keystep: 0,
42522                                limit: 0,
42523                            },
42524                        },
42525                    },
42526                    keySpec {
42527                        notes: 0 as *const libc::c_char,
42528                        flags: 0,
42529                        begin_search_type: KSPEC_BS_INVALID,
42530                        bs: C2RustUnnamed_3 {
42531                            index: C2RustUnnamed_5 { pos: 0 },
42532                        },
42533                        find_keys_type: KSPEC_FK_INVALID,
42534                        fk: C2RustUnnamed_0 {
42535                            range: C2RustUnnamed_2 {
42536                                lastkey: 0,
42537                                keystep: 0,
42538                                limit: 0,
42539                            },
42540                        },
42541                    },
42542                    keySpec {
42543                        notes: 0 as *const libc::c_char,
42544                        flags: 0,
42545                        begin_search_type: KSPEC_BS_INVALID,
42546                        bs: C2RustUnnamed_3 {
42547                            index: C2RustUnnamed_5 { pos: 0 },
42548                        },
42549                        find_keys_type: KSPEC_FK_INVALID,
42550                        fk: C2RustUnnamed_0 {
42551                            range: C2RustUnnamed_2 {
42552                                lastkey: 0,
42553                                keystep: 0,
42554                                limit: 0,
42555                            },
42556                        },
42557                    },
42558                ],
42559                getkeys_proc: None,
42560                subcommands: 0 as *const redisCommand as *mut redisCommand,
42561                args: EXPIREAT_Args.as_ptr() as *mut _,
42562                microseconds: 0,
42563                calls: 0,
42564                rejected_calls: 0,
42565                failed_calls: 0,
42566                id: 0,
42567                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42568                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42569                key_specs: 0 as *const keySpec as *mut keySpec,
42570                legacy_range_key_spec: keySpec {
42571                    notes: 0 as *const libc::c_char,
42572                    flags: 0,
42573                    begin_search_type: KSPEC_BS_INVALID,
42574                    bs: C2RustUnnamed_3 {
42575                        index: C2RustUnnamed_5 { pos: 0 },
42576                    },
42577                    find_keys_type: KSPEC_FK_INVALID,
42578                    fk: C2RustUnnamed_0 {
42579                        range: C2RustUnnamed_2 {
42580                            lastkey: 0,
42581                            keystep: 0,
42582                            limit: 0,
42583                        },
42584                    },
42585                },
42586                num_args: 0,
42587                num_history: 0,
42588                num_tips: 0,
42589                key_specs_num: 0,
42590                key_specs_max: 0,
42591                subcommands_dict: 0 as *const dict as *mut dict,
42592                parent: 0 as *const redisCommand as *mut redisCommand,
42593                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42594            };
42595            init
42596        },
42597        {
42598            let mut init = redisCommand {
42599                declared_name: b"expiretime\0" as *const u8 as *const libc::c_char,
42600                summary: b"Get the expiration Unix timestamp for a key\0" as *const u8
42601                    as *const libc::c_char,
42602                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
42603                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
42604                doc_flags: 0 as libc::c_int,
42605                replaced_by: 0 as *const libc::c_char,
42606                deprecated_since: 0 as *const libc::c_char,
42607                group: COMMAND_GROUP_GENERIC,
42608                history: 0 as *const commandHistory as *mut commandHistory,
42609                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
42610                proc_0: Some(
42611                    expiretimeCommand as unsafe extern "C" fn(*mut client) -> (),
42612                ),
42613                arity: 2 as libc::c_int,
42614                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42615                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
42616                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42617                    as uint64_t,
42618                key_specs_static: [
42619                    {
42620                        let mut init = keySpec {
42621                            notes: 0 as *const libc::c_char,
42622                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42623                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
42624                            begin_search_type: KSPEC_BS_INDEX,
42625                            bs: C2RustUnnamed_3 {
42626                                index: {
42627                                    let mut init = C2RustUnnamed_5 {
42628                                        pos: 1 as libc::c_int,
42629                                    };
42630                                    init
42631                                },
42632                            },
42633                            find_keys_type: KSPEC_FK_RANGE,
42634                            fk: C2RustUnnamed_0 {
42635                                range: {
42636                                    let mut init = C2RustUnnamed_2 {
42637                                        lastkey: 0 as libc::c_int,
42638                                        keystep: 1 as libc::c_int,
42639                                        limit: 0 as libc::c_int,
42640                                    };
42641                                    init
42642                                },
42643                            },
42644                        };
42645                        init
42646                    },
42647                    keySpec {
42648                        notes: 0 as *const libc::c_char,
42649                        flags: 0,
42650                        begin_search_type: KSPEC_BS_INVALID,
42651                        bs: C2RustUnnamed_3 {
42652                            index: C2RustUnnamed_5 { pos: 0 },
42653                        },
42654                        find_keys_type: KSPEC_FK_INVALID,
42655                        fk: C2RustUnnamed_0 {
42656                            range: C2RustUnnamed_2 {
42657                                lastkey: 0,
42658                                keystep: 0,
42659                                limit: 0,
42660                            },
42661                        },
42662                    },
42663                    keySpec {
42664                        notes: 0 as *const libc::c_char,
42665                        flags: 0,
42666                        begin_search_type: KSPEC_BS_INVALID,
42667                        bs: C2RustUnnamed_3 {
42668                            index: C2RustUnnamed_5 { pos: 0 },
42669                        },
42670                        find_keys_type: KSPEC_FK_INVALID,
42671                        fk: C2RustUnnamed_0 {
42672                            range: C2RustUnnamed_2 {
42673                                lastkey: 0,
42674                                keystep: 0,
42675                                limit: 0,
42676                            },
42677                        },
42678                    },
42679                    keySpec {
42680                        notes: 0 as *const libc::c_char,
42681                        flags: 0,
42682                        begin_search_type: KSPEC_BS_INVALID,
42683                        bs: C2RustUnnamed_3 {
42684                            index: C2RustUnnamed_5 { pos: 0 },
42685                        },
42686                        find_keys_type: KSPEC_FK_INVALID,
42687                        fk: C2RustUnnamed_0 {
42688                            range: C2RustUnnamed_2 {
42689                                lastkey: 0,
42690                                keystep: 0,
42691                                limit: 0,
42692                            },
42693                        },
42694                    },
42695                ],
42696                getkeys_proc: None,
42697                subcommands: 0 as *const redisCommand as *mut redisCommand,
42698                args: EXPIRETIME_Args.as_ptr() as *mut _,
42699                microseconds: 0,
42700                calls: 0,
42701                rejected_calls: 0,
42702                failed_calls: 0,
42703                id: 0,
42704                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42705                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42706                key_specs: 0 as *const keySpec as *mut keySpec,
42707                legacy_range_key_spec: keySpec {
42708                    notes: 0 as *const libc::c_char,
42709                    flags: 0,
42710                    begin_search_type: KSPEC_BS_INVALID,
42711                    bs: C2RustUnnamed_3 {
42712                        index: C2RustUnnamed_5 { pos: 0 },
42713                    },
42714                    find_keys_type: KSPEC_FK_INVALID,
42715                    fk: C2RustUnnamed_0 {
42716                        range: C2RustUnnamed_2 {
42717                            lastkey: 0,
42718                            keystep: 0,
42719                            limit: 0,
42720                        },
42721                    },
42722                },
42723                num_args: 0,
42724                num_history: 0,
42725                num_tips: 0,
42726                key_specs_num: 0,
42727                key_specs_max: 0,
42728                subcommands_dict: 0 as *const dict as *mut dict,
42729                parent: 0 as *const redisCommand as *mut redisCommand,
42730                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42731            };
42732            init
42733        },
42734        {
42735            let mut init = redisCommand {
42736                declared_name: b"keys\0" as *const u8 as *const libc::c_char,
42737                summary: b"Find all keys matching the given pattern\0" as *const u8
42738                    as *const libc::c_char,
42739                complexity: b"O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.\0"
42740                    as *const u8 as *const libc::c_char,
42741                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
42742                doc_flags: 0 as libc::c_int,
42743                replaced_by: 0 as *const libc::c_char,
42744                deprecated_since: 0 as *const libc::c_char,
42745                group: COMMAND_GROUP_GENERIC,
42746                history: 0 as *const commandHistory as *mut commandHistory,
42747                tips: KEYS_tips.as_ptr() as *mut _,
42748                proc_0: Some(keysCommand as unsafe extern "C" fn(*mut client) -> ()),
42749                arity: 2 as libc::c_int,
42750                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
42751                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42752                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
42753                key_specs_static: [keySpec {
42754                    notes: 0 as *const libc::c_char,
42755                    flags: 0,
42756                    begin_search_type: KSPEC_BS_INVALID,
42757                    bs: C2RustUnnamed_3 {
42758                        index: C2RustUnnamed_5 { pos: 0 },
42759                    },
42760                    find_keys_type: KSPEC_FK_INVALID,
42761                    fk: C2RustUnnamed_0 {
42762                        range: C2RustUnnamed_2 {
42763                            lastkey: 0,
42764                            keystep: 0,
42765                            limit: 0,
42766                        },
42767                    },
42768                }; 4],
42769                getkeys_proc: None,
42770                subcommands: 0 as *const redisCommand as *mut redisCommand,
42771                args: KEYS_Args.as_ptr() as *mut _,
42772                microseconds: 0,
42773                calls: 0,
42774                rejected_calls: 0,
42775                failed_calls: 0,
42776                id: 0,
42777                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42778                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42779                key_specs: 0 as *const keySpec as *mut keySpec,
42780                legacy_range_key_spec: keySpec {
42781                    notes: 0 as *const libc::c_char,
42782                    flags: 0,
42783                    begin_search_type: KSPEC_BS_INVALID,
42784                    bs: C2RustUnnamed_3 {
42785                        index: C2RustUnnamed_5 { pos: 0 },
42786                    },
42787                    find_keys_type: KSPEC_FK_INVALID,
42788                    fk: C2RustUnnamed_0 {
42789                        range: C2RustUnnamed_2 {
42790                            lastkey: 0,
42791                            keystep: 0,
42792                            limit: 0,
42793                        },
42794                    },
42795                },
42796                num_args: 0,
42797                num_history: 0,
42798                num_tips: 0,
42799                key_specs_num: 0,
42800                key_specs_max: 0,
42801                subcommands_dict: 0 as *const dict as *mut dict,
42802                parent: 0 as *const redisCommand as *mut redisCommand,
42803                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42804            };
42805            init
42806        },
42807        {
42808            let mut init = redisCommand {
42809                declared_name: b"migrate\0" as *const u8 as *const libc::c_char,
42810                summary: b"Atomically transfer a key from a Redis instance to another one.\0"
42811                    as *const u8 as *const libc::c_char,
42812                complexity: b"This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.\0"
42813                    as *const u8 as *const libc::c_char,
42814                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
42815                doc_flags: 0 as libc::c_int,
42816                replaced_by: 0 as *const libc::c_char,
42817                deprecated_since: 0 as *const libc::c_char,
42818                group: COMMAND_GROUP_GENERIC,
42819                history: MIGRATE_History.as_ptr() as *mut _,
42820                tips: MIGRATE_tips.as_ptr() as *mut _,
42821                proc_0: Some(migrateCommand as unsafe extern "C" fn(*mut client) -> ()),
42822                arity: -(6 as libc::c_int),
42823                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
42824                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42825                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
42826                key_specs_static: [
42827                    {
42828                        let mut init = keySpec {
42829                            notes: 0 as *const libc::c_char,
42830                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42831                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
42832                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
42833                            begin_search_type: KSPEC_BS_INDEX,
42834                            bs: C2RustUnnamed_3 {
42835                                index: {
42836                                    let mut init = C2RustUnnamed_5 {
42837                                        pos: 3 as libc::c_int,
42838                                    };
42839                                    init
42840                                },
42841                            },
42842                            find_keys_type: KSPEC_FK_RANGE,
42843                            fk: C2RustUnnamed_0 {
42844                                range: {
42845                                    let mut init = C2RustUnnamed_2 {
42846                                        lastkey: 0 as libc::c_int,
42847                                        keystep: 1 as libc::c_int,
42848                                        limit: 0 as libc::c_int,
42849                                    };
42850                                    init
42851                                },
42852                            },
42853                        };
42854                        init
42855                    },
42856                    {
42857                        let mut init = keySpec {
42858                            notes: 0 as *const libc::c_char,
42859                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42860                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
42861                                | (1 as libc::c_ulonglong) << 7 as libc::c_int
42862                                | (1 as libc::c_ulonglong) << 9 as libc::c_int) as uint64_t,
42863                            begin_search_type: KSPEC_BS_KEYWORD,
42864                            bs: C2RustUnnamed_3 {
42865                                keyword: {
42866                                    let mut init = C2RustUnnamed_4 {
42867                                        keyword: b"KEYS\0" as *const u8 as *const libc::c_char,
42868                                        startfrom: -(2 as libc::c_int),
42869                                    };
42870                                    init
42871                                },
42872                            },
42873                            find_keys_type: KSPEC_FK_RANGE,
42874                            fk: C2RustUnnamed_0 {
42875                                range: {
42876                                    let mut init = C2RustUnnamed_2 {
42877                                        lastkey: -(1 as libc::c_int),
42878                                        keystep: 1 as libc::c_int,
42879                                        limit: 0 as libc::c_int,
42880                                    };
42881                                    init
42882                                },
42883                            },
42884                        };
42885                        init
42886                    },
42887                    keySpec {
42888                        notes: 0 as *const libc::c_char,
42889                        flags: 0,
42890                        begin_search_type: KSPEC_BS_INVALID,
42891                        bs: C2RustUnnamed_3 {
42892                            index: C2RustUnnamed_5 { pos: 0 },
42893                        },
42894                        find_keys_type: KSPEC_FK_INVALID,
42895                        fk: C2RustUnnamed_0 {
42896                            range: C2RustUnnamed_2 {
42897                                lastkey: 0,
42898                                keystep: 0,
42899                                limit: 0,
42900                            },
42901                        },
42902                    },
42903                    keySpec {
42904                        notes: 0 as *const libc::c_char,
42905                        flags: 0,
42906                        begin_search_type: KSPEC_BS_INVALID,
42907                        bs: C2RustUnnamed_3 {
42908                            index: C2RustUnnamed_5 { pos: 0 },
42909                        },
42910                        find_keys_type: KSPEC_FK_INVALID,
42911                        fk: C2RustUnnamed_0 {
42912                            range: C2RustUnnamed_2 {
42913                                lastkey: 0,
42914                                keystep: 0,
42915                                limit: 0,
42916                            },
42917                        },
42918                    },
42919                ],
42920                getkeys_proc: Some(
42921                    migrateGetKeys
42922                        as unsafe extern "C" fn(
42923                            *mut redisCommand,
42924                            *mut *mut robj,
42925                            libc::c_int,
42926                            *mut getKeysResult,
42927                        ) -> libc::c_int,
42928                ),
42929                subcommands: 0 as *const redisCommand as *mut redisCommand,
42930                args: MIGRATE_Args.as_ptr() as *mut _,
42931                microseconds: 0,
42932                calls: 0,
42933                rejected_calls: 0,
42934                failed_calls: 0,
42935                id: 0,
42936                fullname: 0 as *const libc::c_char as *mut libc::c_char,
42937                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
42938                key_specs: 0 as *const keySpec as *mut keySpec,
42939                legacy_range_key_spec: keySpec {
42940                    notes: 0 as *const libc::c_char,
42941                    flags: 0,
42942                    begin_search_type: KSPEC_BS_INVALID,
42943                    bs: C2RustUnnamed_3 {
42944                        index: C2RustUnnamed_5 { pos: 0 },
42945                    },
42946                    find_keys_type: KSPEC_FK_INVALID,
42947                    fk: C2RustUnnamed_0 {
42948                        range: C2RustUnnamed_2 {
42949                            lastkey: 0,
42950                            keystep: 0,
42951                            limit: 0,
42952                        },
42953                    },
42954                },
42955                num_args: 0,
42956                num_history: 0,
42957                num_tips: 0,
42958                key_specs_num: 0,
42959                key_specs_max: 0,
42960                subcommands_dict: 0 as *const dict as *mut dict,
42961                parent: 0 as *const redisCommand as *mut redisCommand,
42962                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
42963            };
42964            init
42965        },
42966        {
42967            let mut init = redisCommand {
42968                declared_name: b"move\0" as *const u8 as *const libc::c_char,
42969                summary: b"Move a key to another database\0" as *const u8
42970                    as *const libc::c_char,
42971                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
42972                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
42973                doc_flags: 0 as libc::c_int,
42974                replaced_by: 0 as *const libc::c_char,
42975                deprecated_since: 0 as *const libc::c_char,
42976                group: COMMAND_GROUP_GENERIC,
42977                history: 0 as *const commandHistory as *mut commandHistory,
42978                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
42979                proc_0: Some(moveCommand as unsafe extern "C" fn(*mut client) -> ()),
42980                arity: 3 as libc::c_int,
42981                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
42982                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
42983                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
42984                    as uint64_t,
42985                key_specs_static: [
42986                    {
42987                        let mut init = keySpec {
42988                            notes: 0 as *const libc::c_char,
42989                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
42990                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
42991                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
42992                            begin_search_type: KSPEC_BS_INDEX,
42993                            bs: C2RustUnnamed_3 {
42994                                index: {
42995                                    let mut init = C2RustUnnamed_5 {
42996                                        pos: 1 as libc::c_int,
42997                                    };
42998                                    init
42999                                },
43000                            },
43001                            find_keys_type: KSPEC_FK_RANGE,
43002                            fk: C2RustUnnamed_0 {
43003                                range: {
43004                                    let mut init = C2RustUnnamed_2 {
43005                                        lastkey: 0 as libc::c_int,
43006                                        keystep: 1 as libc::c_int,
43007                                        limit: 0 as libc::c_int,
43008                                    };
43009                                    init
43010                                },
43011                            },
43012                        };
43013                        init
43014                    },
43015                    keySpec {
43016                        notes: 0 as *const libc::c_char,
43017                        flags: 0,
43018                        begin_search_type: KSPEC_BS_INVALID,
43019                        bs: C2RustUnnamed_3 {
43020                            index: C2RustUnnamed_5 { pos: 0 },
43021                        },
43022                        find_keys_type: KSPEC_FK_INVALID,
43023                        fk: C2RustUnnamed_0 {
43024                            range: C2RustUnnamed_2 {
43025                                lastkey: 0,
43026                                keystep: 0,
43027                                limit: 0,
43028                            },
43029                        },
43030                    },
43031                    keySpec {
43032                        notes: 0 as *const libc::c_char,
43033                        flags: 0,
43034                        begin_search_type: KSPEC_BS_INVALID,
43035                        bs: C2RustUnnamed_3 {
43036                            index: C2RustUnnamed_5 { pos: 0 },
43037                        },
43038                        find_keys_type: KSPEC_FK_INVALID,
43039                        fk: C2RustUnnamed_0 {
43040                            range: C2RustUnnamed_2 {
43041                                lastkey: 0,
43042                                keystep: 0,
43043                                limit: 0,
43044                            },
43045                        },
43046                    },
43047                    keySpec {
43048                        notes: 0 as *const libc::c_char,
43049                        flags: 0,
43050                        begin_search_type: KSPEC_BS_INVALID,
43051                        bs: C2RustUnnamed_3 {
43052                            index: C2RustUnnamed_5 { pos: 0 },
43053                        },
43054                        find_keys_type: KSPEC_FK_INVALID,
43055                        fk: C2RustUnnamed_0 {
43056                            range: C2RustUnnamed_2 {
43057                                lastkey: 0,
43058                                keystep: 0,
43059                                limit: 0,
43060                            },
43061                        },
43062                    },
43063                ],
43064                getkeys_proc: None,
43065                subcommands: 0 as *const redisCommand as *mut redisCommand,
43066                args: MOVE_Args.as_ptr() as *mut _,
43067                microseconds: 0,
43068                calls: 0,
43069                rejected_calls: 0,
43070                failed_calls: 0,
43071                id: 0,
43072                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43073                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43074                key_specs: 0 as *const keySpec as *mut keySpec,
43075                legacy_range_key_spec: keySpec {
43076                    notes: 0 as *const libc::c_char,
43077                    flags: 0,
43078                    begin_search_type: KSPEC_BS_INVALID,
43079                    bs: C2RustUnnamed_3 {
43080                        index: C2RustUnnamed_5 { pos: 0 },
43081                    },
43082                    find_keys_type: KSPEC_FK_INVALID,
43083                    fk: C2RustUnnamed_0 {
43084                        range: C2RustUnnamed_2 {
43085                            lastkey: 0,
43086                            keystep: 0,
43087                            limit: 0,
43088                        },
43089                    },
43090                },
43091                num_args: 0,
43092                num_history: 0,
43093                num_tips: 0,
43094                key_specs_num: 0,
43095                key_specs_max: 0,
43096                subcommands_dict: 0 as *const dict as *mut dict,
43097                parent: 0 as *const redisCommand as *mut redisCommand,
43098                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43099            };
43100            init
43101        },
43102        {
43103            let mut init = redisCommand {
43104                declared_name: b"object\0" as *const u8 as *const libc::c_char,
43105                summary: b"A container for object introspection commands\0" as *const u8
43106                    as *const libc::c_char,
43107                complexity: b"Depends on subcommand.\0" as *const u8
43108                    as *const libc::c_char,
43109                since: b"2.2.3\0" as *const u8 as *const libc::c_char,
43110                doc_flags: 0 as libc::c_int,
43111                replaced_by: 0 as *const libc::c_char,
43112                deprecated_since: 0 as *const libc::c_char,
43113                group: COMMAND_GROUP_GENERIC,
43114                history: 0 as *const commandHistory as *mut commandHistory,
43115                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43116                proc_0: None,
43117                arity: -(2 as libc::c_int),
43118                flags: 0 as libc::c_int as uint64_t,
43119                acl_categories: 0 as libc::c_int as uint64_t,
43120                key_specs_static: [keySpec {
43121                    notes: 0 as *const libc::c_char,
43122                    flags: 0,
43123                    begin_search_type: KSPEC_BS_INVALID,
43124                    bs: C2RustUnnamed_3 {
43125                        index: C2RustUnnamed_5 { pos: 0 },
43126                    },
43127                    find_keys_type: KSPEC_FK_INVALID,
43128                    fk: C2RustUnnamed_0 {
43129                        range: C2RustUnnamed_2 {
43130                            lastkey: 0,
43131                            keystep: 0,
43132                            limit: 0,
43133                        },
43134                    },
43135                }; 4],
43136                getkeys_proc: None,
43137                subcommands: OBJECT_Subcommands.as_ptr() as *mut _,
43138                args: 0 as *const redisCommandArg as *mut redisCommandArg,
43139                microseconds: 0,
43140                calls: 0,
43141                rejected_calls: 0,
43142                failed_calls: 0,
43143                id: 0,
43144                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43145                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43146                key_specs: 0 as *const keySpec as *mut keySpec,
43147                legacy_range_key_spec: keySpec {
43148                    notes: 0 as *const libc::c_char,
43149                    flags: 0,
43150                    begin_search_type: KSPEC_BS_INVALID,
43151                    bs: C2RustUnnamed_3 {
43152                        index: C2RustUnnamed_5 { pos: 0 },
43153                    },
43154                    find_keys_type: KSPEC_FK_INVALID,
43155                    fk: C2RustUnnamed_0 {
43156                        range: C2RustUnnamed_2 {
43157                            lastkey: 0,
43158                            keystep: 0,
43159                            limit: 0,
43160                        },
43161                    },
43162                },
43163                num_args: 0,
43164                num_history: 0,
43165                num_tips: 0,
43166                key_specs_num: 0,
43167                key_specs_max: 0,
43168                subcommands_dict: 0 as *const dict as *mut dict,
43169                parent: 0 as *const redisCommand as *mut redisCommand,
43170                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43171            };
43172            init
43173        },
43174        {
43175            let mut init = redisCommand {
43176                declared_name: b"persist\0" as *const u8 as *const libc::c_char,
43177                summary: b"Remove the expiration from a key\0" as *const u8
43178                    as *const libc::c_char,
43179                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43180                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
43181                doc_flags: 0 as libc::c_int,
43182                replaced_by: 0 as *const libc::c_char,
43183                deprecated_since: 0 as *const libc::c_char,
43184                group: COMMAND_GROUP_GENERIC,
43185                history: 0 as *const commandHistory as *mut commandHistory,
43186                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43187                proc_0: Some(persistCommand as unsafe extern "C" fn(*mut client) -> ()),
43188                arity: 2 as libc::c_int,
43189                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
43190                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
43191                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43192                    as uint64_t,
43193                key_specs_static: [
43194                    {
43195                        let mut init = keySpec {
43196                            notes: 0 as *const libc::c_char,
43197                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43198                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
43199                            begin_search_type: KSPEC_BS_INDEX,
43200                            bs: C2RustUnnamed_3 {
43201                                index: {
43202                                    let mut init = C2RustUnnamed_5 {
43203                                        pos: 1 as libc::c_int,
43204                                    };
43205                                    init
43206                                },
43207                            },
43208                            find_keys_type: KSPEC_FK_RANGE,
43209                            fk: C2RustUnnamed_0 {
43210                                range: {
43211                                    let mut init = C2RustUnnamed_2 {
43212                                        lastkey: 0 as libc::c_int,
43213                                        keystep: 1 as libc::c_int,
43214                                        limit: 0 as libc::c_int,
43215                                    };
43216                                    init
43217                                },
43218                            },
43219                        };
43220                        init
43221                    },
43222                    keySpec {
43223                        notes: 0 as *const libc::c_char,
43224                        flags: 0,
43225                        begin_search_type: KSPEC_BS_INVALID,
43226                        bs: C2RustUnnamed_3 {
43227                            index: C2RustUnnamed_5 { pos: 0 },
43228                        },
43229                        find_keys_type: KSPEC_FK_INVALID,
43230                        fk: C2RustUnnamed_0 {
43231                            range: C2RustUnnamed_2 {
43232                                lastkey: 0,
43233                                keystep: 0,
43234                                limit: 0,
43235                            },
43236                        },
43237                    },
43238                    keySpec {
43239                        notes: 0 as *const libc::c_char,
43240                        flags: 0,
43241                        begin_search_type: KSPEC_BS_INVALID,
43242                        bs: C2RustUnnamed_3 {
43243                            index: C2RustUnnamed_5 { pos: 0 },
43244                        },
43245                        find_keys_type: KSPEC_FK_INVALID,
43246                        fk: C2RustUnnamed_0 {
43247                            range: C2RustUnnamed_2 {
43248                                lastkey: 0,
43249                                keystep: 0,
43250                                limit: 0,
43251                            },
43252                        },
43253                    },
43254                    keySpec {
43255                        notes: 0 as *const libc::c_char,
43256                        flags: 0,
43257                        begin_search_type: KSPEC_BS_INVALID,
43258                        bs: C2RustUnnamed_3 {
43259                            index: C2RustUnnamed_5 { pos: 0 },
43260                        },
43261                        find_keys_type: KSPEC_FK_INVALID,
43262                        fk: C2RustUnnamed_0 {
43263                            range: C2RustUnnamed_2 {
43264                                lastkey: 0,
43265                                keystep: 0,
43266                                limit: 0,
43267                            },
43268                        },
43269                    },
43270                ],
43271                getkeys_proc: None,
43272                subcommands: 0 as *const redisCommand as *mut redisCommand,
43273                args: PERSIST_Args.as_ptr() as *mut _,
43274                microseconds: 0,
43275                calls: 0,
43276                rejected_calls: 0,
43277                failed_calls: 0,
43278                id: 0,
43279                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43280                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43281                key_specs: 0 as *const keySpec as *mut keySpec,
43282                legacy_range_key_spec: keySpec {
43283                    notes: 0 as *const libc::c_char,
43284                    flags: 0,
43285                    begin_search_type: KSPEC_BS_INVALID,
43286                    bs: C2RustUnnamed_3 {
43287                        index: C2RustUnnamed_5 { pos: 0 },
43288                    },
43289                    find_keys_type: KSPEC_FK_INVALID,
43290                    fk: C2RustUnnamed_0 {
43291                        range: C2RustUnnamed_2 {
43292                            lastkey: 0,
43293                            keystep: 0,
43294                            limit: 0,
43295                        },
43296                    },
43297                },
43298                num_args: 0,
43299                num_history: 0,
43300                num_tips: 0,
43301                key_specs_num: 0,
43302                key_specs_max: 0,
43303                subcommands_dict: 0 as *const dict as *mut dict,
43304                parent: 0 as *const redisCommand as *mut redisCommand,
43305                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43306            };
43307            init
43308        },
43309        {
43310            let mut init = redisCommand {
43311                declared_name: b"pexpire\0" as *const u8 as *const libc::c_char,
43312                summary: b"Set a key's time to live in milliseconds\0" as *const u8
43313                    as *const libc::c_char,
43314                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43315                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
43316                doc_flags: 0 as libc::c_int,
43317                replaced_by: 0 as *const libc::c_char,
43318                deprecated_since: 0 as *const libc::c_char,
43319                group: COMMAND_GROUP_GENERIC,
43320                history: PEXPIRE_History.as_ptr() as *mut _,
43321                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43322                proc_0: Some(pexpireCommand as unsafe extern "C" fn(*mut client) -> ()),
43323                arity: -(3 as libc::c_int),
43324                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
43325                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
43326                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43327                    as uint64_t,
43328                key_specs_static: [
43329                    {
43330                        let mut init = keySpec {
43331                            notes: 0 as *const libc::c_char,
43332                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43333                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
43334                            begin_search_type: KSPEC_BS_INDEX,
43335                            bs: C2RustUnnamed_3 {
43336                                index: {
43337                                    let mut init = C2RustUnnamed_5 {
43338                                        pos: 1 as libc::c_int,
43339                                    };
43340                                    init
43341                                },
43342                            },
43343                            find_keys_type: KSPEC_FK_RANGE,
43344                            fk: C2RustUnnamed_0 {
43345                                range: {
43346                                    let mut init = C2RustUnnamed_2 {
43347                                        lastkey: 0 as libc::c_int,
43348                                        keystep: 1 as libc::c_int,
43349                                        limit: 0 as libc::c_int,
43350                                    };
43351                                    init
43352                                },
43353                            },
43354                        };
43355                        init
43356                    },
43357                    keySpec {
43358                        notes: 0 as *const libc::c_char,
43359                        flags: 0,
43360                        begin_search_type: KSPEC_BS_INVALID,
43361                        bs: C2RustUnnamed_3 {
43362                            index: C2RustUnnamed_5 { pos: 0 },
43363                        },
43364                        find_keys_type: KSPEC_FK_INVALID,
43365                        fk: C2RustUnnamed_0 {
43366                            range: C2RustUnnamed_2 {
43367                                lastkey: 0,
43368                                keystep: 0,
43369                                limit: 0,
43370                            },
43371                        },
43372                    },
43373                    keySpec {
43374                        notes: 0 as *const libc::c_char,
43375                        flags: 0,
43376                        begin_search_type: KSPEC_BS_INVALID,
43377                        bs: C2RustUnnamed_3 {
43378                            index: C2RustUnnamed_5 { pos: 0 },
43379                        },
43380                        find_keys_type: KSPEC_FK_INVALID,
43381                        fk: C2RustUnnamed_0 {
43382                            range: C2RustUnnamed_2 {
43383                                lastkey: 0,
43384                                keystep: 0,
43385                                limit: 0,
43386                            },
43387                        },
43388                    },
43389                    keySpec {
43390                        notes: 0 as *const libc::c_char,
43391                        flags: 0,
43392                        begin_search_type: KSPEC_BS_INVALID,
43393                        bs: C2RustUnnamed_3 {
43394                            index: C2RustUnnamed_5 { pos: 0 },
43395                        },
43396                        find_keys_type: KSPEC_FK_INVALID,
43397                        fk: C2RustUnnamed_0 {
43398                            range: C2RustUnnamed_2 {
43399                                lastkey: 0,
43400                                keystep: 0,
43401                                limit: 0,
43402                            },
43403                        },
43404                    },
43405                ],
43406                getkeys_proc: None,
43407                subcommands: 0 as *const redisCommand as *mut redisCommand,
43408                args: PEXPIRE_Args.as_ptr() as *mut _,
43409                microseconds: 0,
43410                calls: 0,
43411                rejected_calls: 0,
43412                failed_calls: 0,
43413                id: 0,
43414                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43415                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43416                key_specs: 0 as *const keySpec as *mut keySpec,
43417                legacy_range_key_spec: keySpec {
43418                    notes: 0 as *const libc::c_char,
43419                    flags: 0,
43420                    begin_search_type: KSPEC_BS_INVALID,
43421                    bs: C2RustUnnamed_3 {
43422                        index: C2RustUnnamed_5 { pos: 0 },
43423                    },
43424                    find_keys_type: KSPEC_FK_INVALID,
43425                    fk: C2RustUnnamed_0 {
43426                        range: C2RustUnnamed_2 {
43427                            lastkey: 0,
43428                            keystep: 0,
43429                            limit: 0,
43430                        },
43431                    },
43432                },
43433                num_args: 0,
43434                num_history: 0,
43435                num_tips: 0,
43436                key_specs_num: 0,
43437                key_specs_max: 0,
43438                subcommands_dict: 0 as *const dict as *mut dict,
43439                parent: 0 as *const redisCommand as *mut redisCommand,
43440                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43441            };
43442            init
43443        },
43444        {
43445            let mut init = redisCommand {
43446                declared_name: b"pexpireat\0" as *const u8 as *const libc::c_char,
43447                summary: b"Set the expiration for a key as a UNIX timestamp specified in milliseconds\0"
43448                    as *const u8 as *const libc::c_char,
43449                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43450                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
43451                doc_flags: 0 as libc::c_int,
43452                replaced_by: 0 as *const libc::c_char,
43453                deprecated_since: 0 as *const libc::c_char,
43454                group: COMMAND_GROUP_GENERIC,
43455                history: PEXPIREAT_History.as_ptr() as *mut _,
43456                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43457                proc_0: Some(
43458                    pexpireatCommand as unsafe extern "C" fn(*mut client) -> (),
43459                ),
43460                arity: -(3 as libc::c_int),
43461                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
43462                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
43463                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43464                    as uint64_t,
43465                key_specs_static: [
43466                    {
43467                        let mut init = keySpec {
43468                            notes: 0 as *const libc::c_char,
43469                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43470                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
43471                            begin_search_type: KSPEC_BS_INDEX,
43472                            bs: C2RustUnnamed_3 {
43473                                index: {
43474                                    let mut init = C2RustUnnamed_5 {
43475                                        pos: 1 as libc::c_int,
43476                                    };
43477                                    init
43478                                },
43479                            },
43480                            find_keys_type: KSPEC_FK_RANGE,
43481                            fk: C2RustUnnamed_0 {
43482                                range: {
43483                                    let mut init = C2RustUnnamed_2 {
43484                                        lastkey: 0 as libc::c_int,
43485                                        keystep: 1 as libc::c_int,
43486                                        limit: 0 as libc::c_int,
43487                                    };
43488                                    init
43489                                },
43490                            },
43491                        };
43492                        init
43493                    },
43494                    keySpec {
43495                        notes: 0 as *const libc::c_char,
43496                        flags: 0,
43497                        begin_search_type: KSPEC_BS_INVALID,
43498                        bs: C2RustUnnamed_3 {
43499                            index: C2RustUnnamed_5 { pos: 0 },
43500                        },
43501                        find_keys_type: KSPEC_FK_INVALID,
43502                        fk: C2RustUnnamed_0 {
43503                            range: C2RustUnnamed_2 {
43504                                lastkey: 0,
43505                                keystep: 0,
43506                                limit: 0,
43507                            },
43508                        },
43509                    },
43510                    keySpec {
43511                        notes: 0 as *const libc::c_char,
43512                        flags: 0,
43513                        begin_search_type: KSPEC_BS_INVALID,
43514                        bs: C2RustUnnamed_3 {
43515                            index: C2RustUnnamed_5 { pos: 0 },
43516                        },
43517                        find_keys_type: KSPEC_FK_INVALID,
43518                        fk: C2RustUnnamed_0 {
43519                            range: C2RustUnnamed_2 {
43520                                lastkey: 0,
43521                                keystep: 0,
43522                                limit: 0,
43523                            },
43524                        },
43525                    },
43526                    keySpec {
43527                        notes: 0 as *const libc::c_char,
43528                        flags: 0,
43529                        begin_search_type: KSPEC_BS_INVALID,
43530                        bs: C2RustUnnamed_3 {
43531                            index: C2RustUnnamed_5 { pos: 0 },
43532                        },
43533                        find_keys_type: KSPEC_FK_INVALID,
43534                        fk: C2RustUnnamed_0 {
43535                            range: C2RustUnnamed_2 {
43536                                lastkey: 0,
43537                                keystep: 0,
43538                                limit: 0,
43539                            },
43540                        },
43541                    },
43542                ],
43543                getkeys_proc: None,
43544                subcommands: 0 as *const redisCommand as *mut redisCommand,
43545                args: PEXPIREAT_Args.as_ptr() as *mut _,
43546                microseconds: 0,
43547                calls: 0,
43548                rejected_calls: 0,
43549                failed_calls: 0,
43550                id: 0,
43551                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43552                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43553                key_specs: 0 as *const keySpec as *mut keySpec,
43554                legacy_range_key_spec: keySpec {
43555                    notes: 0 as *const libc::c_char,
43556                    flags: 0,
43557                    begin_search_type: KSPEC_BS_INVALID,
43558                    bs: C2RustUnnamed_3 {
43559                        index: C2RustUnnamed_5 { pos: 0 },
43560                    },
43561                    find_keys_type: KSPEC_FK_INVALID,
43562                    fk: C2RustUnnamed_0 {
43563                        range: C2RustUnnamed_2 {
43564                            lastkey: 0,
43565                            keystep: 0,
43566                            limit: 0,
43567                        },
43568                    },
43569                },
43570                num_args: 0,
43571                num_history: 0,
43572                num_tips: 0,
43573                key_specs_num: 0,
43574                key_specs_max: 0,
43575                subcommands_dict: 0 as *const dict as *mut dict,
43576                parent: 0 as *const redisCommand as *mut redisCommand,
43577                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43578            };
43579            init
43580        },
43581        {
43582            let mut init = redisCommand {
43583                declared_name: b"pexpiretime\0" as *const u8 as *const libc::c_char,
43584                summary: b"Get the expiration Unix timestamp for a key in milliseconds\0"
43585                    as *const u8 as *const libc::c_char,
43586                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43587                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
43588                doc_flags: 0 as libc::c_int,
43589                replaced_by: 0 as *const libc::c_char,
43590                deprecated_since: 0 as *const libc::c_char,
43591                group: COMMAND_GROUP_GENERIC,
43592                history: 0 as *const commandHistory as *mut commandHistory,
43593                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43594                proc_0: Some(
43595                    pexpiretimeCommand as unsafe extern "C" fn(*mut client) -> (),
43596                ),
43597                arity: 2 as libc::c_int,
43598                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43599                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
43600                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43601                    as uint64_t,
43602                key_specs_static: [
43603                    {
43604                        let mut init = keySpec {
43605                            notes: 0 as *const libc::c_char,
43606                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
43607                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
43608                            begin_search_type: KSPEC_BS_INDEX,
43609                            bs: C2RustUnnamed_3 {
43610                                index: {
43611                                    let mut init = C2RustUnnamed_5 {
43612                                        pos: 1 as libc::c_int,
43613                                    };
43614                                    init
43615                                },
43616                            },
43617                            find_keys_type: KSPEC_FK_RANGE,
43618                            fk: C2RustUnnamed_0 {
43619                                range: {
43620                                    let mut init = C2RustUnnamed_2 {
43621                                        lastkey: 0 as libc::c_int,
43622                                        keystep: 1 as libc::c_int,
43623                                        limit: 0 as libc::c_int,
43624                                    };
43625                                    init
43626                                },
43627                            },
43628                        };
43629                        init
43630                    },
43631                    keySpec {
43632                        notes: 0 as *const libc::c_char,
43633                        flags: 0,
43634                        begin_search_type: KSPEC_BS_INVALID,
43635                        bs: C2RustUnnamed_3 {
43636                            index: C2RustUnnamed_5 { pos: 0 },
43637                        },
43638                        find_keys_type: KSPEC_FK_INVALID,
43639                        fk: C2RustUnnamed_0 {
43640                            range: C2RustUnnamed_2 {
43641                                lastkey: 0,
43642                                keystep: 0,
43643                                limit: 0,
43644                            },
43645                        },
43646                    },
43647                    keySpec {
43648                        notes: 0 as *const libc::c_char,
43649                        flags: 0,
43650                        begin_search_type: KSPEC_BS_INVALID,
43651                        bs: C2RustUnnamed_3 {
43652                            index: C2RustUnnamed_5 { pos: 0 },
43653                        },
43654                        find_keys_type: KSPEC_FK_INVALID,
43655                        fk: C2RustUnnamed_0 {
43656                            range: C2RustUnnamed_2 {
43657                                lastkey: 0,
43658                                keystep: 0,
43659                                limit: 0,
43660                            },
43661                        },
43662                    },
43663                    keySpec {
43664                        notes: 0 as *const libc::c_char,
43665                        flags: 0,
43666                        begin_search_type: KSPEC_BS_INVALID,
43667                        bs: C2RustUnnamed_3 {
43668                            index: C2RustUnnamed_5 { pos: 0 },
43669                        },
43670                        find_keys_type: KSPEC_FK_INVALID,
43671                        fk: C2RustUnnamed_0 {
43672                            range: C2RustUnnamed_2 {
43673                                lastkey: 0,
43674                                keystep: 0,
43675                                limit: 0,
43676                            },
43677                        },
43678                    },
43679                ],
43680                getkeys_proc: None,
43681                subcommands: 0 as *const redisCommand as *mut redisCommand,
43682                args: PEXPIRETIME_Args.as_ptr() as *mut _,
43683                microseconds: 0,
43684                calls: 0,
43685                rejected_calls: 0,
43686                failed_calls: 0,
43687                id: 0,
43688                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43689                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43690                key_specs: 0 as *const keySpec as *mut keySpec,
43691                legacy_range_key_spec: keySpec {
43692                    notes: 0 as *const libc::c_char,
43693                    flags: 0,
43694                    begin_search_type: KSPEC_BS_INVALID,
43695                    bs: C2RustUnnamed_3 {
43696                        index: C2RustUnnamed_5 { pos: 0 },
43697                    },
43698                    find_keys_type: KSPEC_FK_INVALID,
43699                    fk: C2RustUnnamed_0 {
43700                        range: C2RustUnnamed_2 {
43701                            lastkey: 0,
43702                            keystep: 0,
43703                            limit: 0,
43704                        },
43705                    },
43706                },
43707                num_args: 0,
43708                num_history: 0,
43709                num_tips: 0,
43710                key_specs_num: 0,
43711                key_specs_max: 0,
43712                subcommands_dict: 0 as *const dict as *mut dict,
43713                parent: 0 as *const redisCommand as *mut redisCommand,
43714                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43715            };
43716            init
43717        },
43718        {
43719            let mut init = redisCommand {
43720                declared_name: b"pttl\0" as *const u8 as *const libc::c_char,
43721                summary: b"Get the time to live for a key in milliseconds\0" as *const u8
43722                    as *const libc::c_char,
43723                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43724                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
43725                doc_flags: 0 as libc::c_int,
43726                replaced_by: 0 as *const libc::c_char,
43727                deprecated_since: 0 as *const libc::c_char,
43728                group: COMMAND_GROUP_GENERIC,
43729                history: PTTL_History.as_ptr() as *mut _,
43730                tips: PTTL_tips.as_ptr() as *mut _,
43731                proc_0: Some(pttlCommand as unsafe extern "C" fn(*mut client) -> ()),
43732                arity: 2 as libc::c_int,
43733                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43734                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
43735                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43736                    as uint64_t,
43737                key_specs_static: [
43738                    {
43739                        let mut init = keySpec {
43740                            notes: 0 as *const libc::c_char,
43741                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
43742                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
43743                            begin_search_type: KSPEC_BS_INDEX,
43744                            bs: C2RustUnnamed_3 {
43745                                index: {
43746                                    let mut init = C2RustUnnamed_5 {
43747                                        pos: 1 as libc::c_int,
43748                                    };
43749                                    init
43750                                },
43751                            },
43752                            find_keys_type: KSPEC_FK_RANGE,
43753                            fk: C2RustUnnamed_0 {
43754                                range: {
43755                                    let mut init = C2RustUnnamed_2 {
43756                                        lastkey: 0 as libc::c_int,
43757                                        keystep: 1 as libc::c_int,
43758                                        limit: 0 as libc::c_int,
43759                                    };
43760                                    init
43761                                },
43762                            },
43763                        };
43764                        init
43765                    },
43766                    keySpec {
43767                        notes: 0 as *const libc::c_char,
43768                        flags: 0,
43769                        begin_search_type: KSPEC_BS_INVALID,
43770                        bs: C2RustUnnamed_3 {
43771                            index: C2RustUnnamed_5 { pos: 0 },
43772                        },
43773                        find_keys_type: KSPEC_FK_INVALID,
43774                        fk: C2RustUnnamed_0 {
43775                            range: C2RustUnnamed_2 {
43776                                lastkey: 0,
43777                                keystep: 0,
43778                                limit: 0,
43779                            },
43780                        },
43781                    },
43782                    keySpec {
43783                        notes: 0 as *const libc::c_char,
43784                        flags: 0,
43785                        begin_search_type: KSPEC_BS_INVALID,
43786                        bs: C2RustUnnamed_3 {
43787                            index: C2RustUnnamed_5 { pos: 0 },
43788                        },
43789                        find_keys_type: KSPEC_FK_INVALID,
43790                        fk: C2RustUnnamed_0 {
43791                            range: C2RustUnnamed_2 {
43792                                lastkey: 0,
43793                                keystep: 0,
43794                                limit: 0,
43795                            },
43796                        },
43797                    },
43798                    keySpec {
43799                        notes: 0 as *const libc::c_char,
43800                        flags: 0,
43801                        begin_search_type: KSPEC_BS_INVALID,
43802                        bs: C2RustUnnamed_3 {
43803                            index: C2RustUnnamed_5 { pos: 0 },
43804                        },
43805                        find_keys_type: KSPEC_FK_INVALID,
43806                        fk: C2RustUnnamed_0 {
43807                            range: C2RustUnnamed_2 {
43808                                lastkey: 0,
43809                                keystep: 0,
43810                                limit: 0,
43811                            },
43812                        },
43813                    },
43814                ],
43815                getkeys_proc: None,
43816                subcommands: 0 as *const redisCommand as *mut redisCommand,
43817                args: PTTL_Args.as_ptr() as *mut _,
43818                microseconds: 0,
43819                calls: 0,
43820                rejected_calls: 0,
43821                failed_calls: 0,
43822                id: 0,
43823                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43824                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43825                key_specs: 0 as *const keySpec as *mut keySpec,
43826                legacy_range_key_spec: keySpec {
43827                    notes: 0 as *const libc::c_char,
43828                    flags: 0,
43829                    begin_search_type: KSPEC_BS_INVALID,
43830                    bs: C2RustUnnamed_3 {
43831                        index: C2RustUnnamed_5 { pos: 0 },
43832                    },
43833                    find_keys_type: KSPEC_FK_INVALID,
43834                    fk: C2RustUnnamed_0 {
43835                        range: C2RustUnnamed_2 {
43836                            lastkey: 0,
43837                            keystep: 0,
43838                            limit: 0,
43839                        },
43840                    },
43841                },
43842                num_args: 0,
43843                num_history: 0,
43844                num_tips: 0,
43845                key_specs_num: 0,
43846                key_specs_max: 0,
43847                subcommands_dict: 0 as *const dict as *mut dict,
43848                parent: 0 as *const redisCommand as *mut redisCommand,
43849                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43850            };
43851            init
43852        },
43853        {
43854            let mut init = redisCommand {
43855                declared_name: b"randomkey\0" as *const u8 as *const libc::c_char,
43856                summary: b"Return a random key from the keyspace\0" as *const u8
43857                    as *const libc::c_char,
43858                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43859                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
43860                doc_flags: 0 as libc::c_int,
43861                replaced_by: 0 as *const libc::c_char,
43862                deprecated_since: 0 as *const libc::c_char,
43863                group: COMMAND_GROUP_GENERIC,
43864                history: 0 as *const commandHistory as *mut commandHistory,
43865                tips: RANDOMKEY_tips.as_ptr() as *mut _,
43866                proc_0: Some(
43867                    randomkeyCommand as unsafe extern "C" fn(*mut client) -> (),
43868                ),
43869                arity: 1 as libc::c_int,
43870                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
43871                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43872                    as uint64_t,
43873                key_specs_static: [keySpec {
43874                    notes: 0 as *const libc::c_char,
43875                    flags: 0,
43876                    begin_search_type: KSPEC_BS_INVALID,
43877                    bs: C2RustUnnamed_3 {
43878                        index: C2RustUnnamed_5 { pos: 0 },
43879                    },
43880                    find_keys_type: KSPEC_FK_INVALID,
43881                    fk: C2RustUnnamed_0 {
43882                        range: C2RustUnnamed_2 {
43883                            lastkey: 0,
43884                            keystep: 0,
43885                            limit: 0,
43886                        },
43887                    },
43888                }; 4],
43889                getkeys_proc: None,
43890                subcommands: 0 as *const redisCommand as *mut redisCommand,
43891                args: 0 as *const redisCommandArg as *mut redisCommandArg,
43892                microseconds: 0,
43893                calls: 0,
43894                rejected_calls: 0,
43895                failed_calls: 0,
43896                id: 0,
43897                fullname: 0 as *const libc::c_char as *mut libc::c_char,
43898                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
43899                key_specs: 0 as *const keySpec as *mut keySpec,
43900                legacy_range_key_spec: keySpec {
43901                    notes: 0 as *const libc::c_char,
43902                    flags: 0,
43903                    begin_search_type: KSPEC_BS_INVALID,
43904                    bs: C2RustUnnamed_3 {
43905                        index: C2RustUnnamed_5 { pos: 0 },
43906                    },
43907                    find_keys_type: KSPEC_FK_INVALID,
43908                    fk: C2RustUnnamed_0 {
43909                        range: C2RustUnnamed_2 {
43910                            lastkey: 0,
43911                            keystep: 0,
43912                            limit: 0,
43913                        },
43914                    },
43915                },
43916                num_args: 0,
43917                num_history: 0,
43918                num_tips: 0,
43919                key_specs_num: 0,
43920                key_specs_max: 0,
43921                subcommands_dict: 0 as *const dict as *mut dict,
43922                parent: 0 as *const redisCommand as *mut redisCommand,
43923                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
43924            };
43925            init
43926        },
43927        {
43928            let mut init = redisCommand {
43929                declared_name: b"rename\0" as *const u8 as *const libc::c_char,
43930                summary: b"Rename a key\0" as *const u8 as *const libc::c_char,
43931                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
43932                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
43933                doc_flags: 0 as libc::c_int,
43934                replaced_by: 0 as *const libc::c_char,
43935                deprecated_since: 0 as *const libc::c_char,
43936                group: COMMAND_GROUP_GENERIC,
43937                history: 0 as *const commandHistory as *mut commandHistory,
43938                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
43939                proc_0: Some(renameCommand as unsafe extern "C" fn(*mut client) -> ()),
43940                arity: 3 as libc::c_int,
43941                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
43942                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
43943                    as uint64_t,
43944                key_specs_static: [
43945                    {
43946                        let mut init = keySpec {
43947                            notes: 0 as *const libc::c_char,
43948                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
43949                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
43950                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
43951                            begin_search_type: KSPEC_BS_INDEX,
43952                            bs: C2RustUnnamed_3 {
43953                                index: {
43954                                    let mut init = C2RustUnnamed_5 {
43955                                        pos: 1 as libc::c_int,
43956                                    };
43957                                    init
43958                                },
43959                            },
43960                            find_keys_type: KSPEC_FK_RANGE,
43961                            fk: C2RustUnnamed_0 {
43962                                range: {
43963                                    let mut init = C2RustUnnamed_2 {
43964                                        lastkey: 0 as libc::c_int,
43965                                        keystep: 1 as libc::c_int,
43966                                        limit: 0 as libc::c_int,
43967                                    };
43968                                    init
43969                                },
43970                            },
43971                        };
43972                        init
43973                    },
43974                    {
43975                        let mut init = keySpec {
43976                            notes: 0 as *const libc::c_char,
43977                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
43978                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
43979                            begin_search_type: KSPEC_BS_INDEX,
43980                            bs: C2RustUnnamed_3 {
43981                                index: {
43982                                    let mut init = C2RustUnnamed_5 {
43983                                        pos: 2 as libc::c_int,
43984                                    };
43985                                    init
43986                                },
43987                            },
43988                            find_keys_type: KSPEC_FK_RANGE,
43989                            fk: C2RustUnnamed_0 {
43990                                range: {
43991                                    let mut init = C2RustUnnamed_2 {
43992                                        lastkey: 0 as libc::c_int,
43993                                        keystep: 1 as libc::c_int,
43994                                        limit: 0 as libc::c_int,
43995                                    };
43996                                    init
43997                                },
43998                            },
43999                        };
44000                        init
44001                    },
44002                    keySpec {
44003                        notes: 0 as *const libc::c_char,
44004                        flags: 0,
44005                        begin_search_type: KSPEC_BS_INVALID,
44006                        bs: C2RustUnnamed_3 {
44007                            index: C2RustUnnamed_5 { pos: 0 },
44008                        },
44009                        find_keys_type: KSPEC_FK_INVALID,
44010                        fk: C2RustUnnamed_0 {
44011                            range: C2RustUnnamed_2 {
44012                                lastkey: 0,
44013                                keystep: 0,
44014                                limit: 0,
44015                            },
44016                        },
44017                    },
44018                    keySpec {
44019                        notes: 0 as *const libc::c_char,
44020                        flags: 0,
44021                        begin_search_type: KSPEC_BS_INVALID,
44022                        bs: C2RustUnnamed_3 {
44023                            index: C2RustUnnamed_5 { pos: 0 },
44024                        },
44025                        find_keys_type: KSPEC_FK_INVALID,
44026                        fk: C2RustUnnamed_0 {
44027                            range: C2RustUnnamed_2 {
44028                                lastkey: 0,
44029                                keystep: 0,
44030                                limit: 0,
44031                            },
44032                        },
44033                    },
44034                ],
44035                getkeys_proc: None,
44036                subcommands: 0 as *const redisCommand as *mut redisCommand,
44037                args: RENAME_Args.as_ptr() as *mut _,
44038                microseconds: 0,
44039                calls: 0,
44040                rejected_calls: 0,
44041                failed_calls: 0,
44042                id: 0,
44043                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44044                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44045                key_specs: 0 as *const keySpec as *mut keySpec,
44046                legacy_range_key_spec: keySpec {
44047                    notes: 0 as *const libc::c_char,
44048                    flags: 0,
44049                    begin_search_type: KSPEC_BS_INVALID,
44050                    bs: C2RustUnnamed_3 {
44051                        index: C2RustUnnamed_5 { pos: 0 },
44052                    },
44053                    find_keys_type: KSPEC_FK_INVALID,
44054                    fk: C2RustUnnamed_0 {
44055                        range: C2RustUnnamed_2 {
44056                            lastkey: 0,
44057                            keystep: 0,
44058                            limit: 0,
44059                        },
44060                    },
44061                },
44062                num_args: 0,
44063                num_history: 0,
44064                num_tips: 0,
44065                key_specs_num: 0,
44066                key_specs_max: 0,
44067                subcommands_dict: 0 as *const dict as *mut dict,
44068                parent: 0 as *const redisCommand as *mut redisCommand,
44069                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44070            };
44071            init
44072        },
44073        {
44074            let mut init = redisCommand {
44075                declared_name: b"renamenx\0" as *const u8 as *const libc::c_char,
44076                summary: b"Rename a key, only if the new key does not exist\0"
44077                    as *const u8 as *const libc::c_char,
44078                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
44079                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
44080                doc_flags: 0 as libc::c_int,
44081                replaced_by: 0 as *const libc::c_char,
44082                deprecated_since: 0 as *const libc::c_char,
44083                group: COMMAND_GROUP_GENERIC,
44084                history: RENAMENX_History.as_ptr() as *mut _,
44085                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
44086                proc_0: Some(renamenxCommand as unsafe extern "C" fn(*mut client) -> ()),
44087                arity: 3 as libc::c_int,
44088                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44089                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
44090                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
44091                    as uint64_t,
44092                key_specs_static: [
44093                    {
44094                        let mut init = keySpec {
44095                            notes: 0 as *const libc::c_char,
44096                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
44097                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
44098                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
44099                            begin_search_type: KSPEC_BS_INDEX,
44100                            bs: C2RustUnnamed_3 {
44101                                index: {
44102                                    let mut init = C2RustUnnamed_5 {
44103                                        pos: 1 as libc::c_int,
44104                                    };
44105                                    init
44106                                },
44107                            },
44108                            find_keys_type: KSPEC_FK_RANGE,
44109                            fk: C2RustUnnamed_0 {
44110                                range: {
44111                                    let mut init = C2RustUnnamed_2 {
44112                                        lastkey: 0 as libc::c_int,
44113                                        keystep: 1 as libc::c_int,
44114                                        limit: 0 as libc::c_int,
44115                                    };
44116                                    init
44117                                },
44118                            },
44119                        };
44120                        init
44121                    },
44122                    {
44123                        let mut init = keySpec {
44124                            notes: 0 as *const libc::c_char,
44125                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
44126                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
44127                            begin_search_type: KSPEC_BS_INDEX,
44128                            bs: C2RustUnnamed_3 {
44129                                index: {
44130                                    let mut init = C2RustUnnamed_5 {
44131                                        pos: 2 as libc::c_int,
44132                                    };
44133                                    init
44134                                },
44135                            },
44136                            find_keys_type: KSPEC_FK_RANGE,
44137                            fk: C2RustUnnamed_0 {
44138                                range: {
44139                                    let mut init = C2RustUnnamed_2 {
44140                                        lastkey: 0 as libc::c_int,
44141                                        keystep: 1 as libc::c_int,
44142                                        limit: 0 as libc::c_int,
44143                                    };
44144                                    init
44145                                },
44146                            },
44147                        };
44148                        init
44149                    },
44150                    keySpec {
44151                        notes: 0 as *const libc::c_char,
44152                        flags: 0,
44153                        begin_search_type: KSPEC_BS_INVALID,
44154                        bs: C2RustUnnamed_3 {
44155                            index: C2RustUnnamed_5 { pos: 0 },
44156                        },
44157                        find_keys_type: KSPEC_FK_INVALID,
44158                        fk: C2RustUnnamed_0 {
44159                            range: C2RustUnnamed_2 {
44160                                lastkey: 0,
44161                                keystep: 0,
44162                                limit: 0,
44163                            },
44164                        },
44165                    },
44166                    keySpec {
44167                        notes: 0 as *const libc::c_char,
44168                        flags: 0,
44169                        begin_search_type: KSPEC_BS_INVALID,
44170                        bs: C2RustUnnamed_3 {
44171                            index: C2RustUnnamed_5 { pos: 0 },
44172                        },
44173                        find_keys_type: KSPEC_FK_INVALID,
44174                        fk: C2RustUnnamed_0 {
44175                            range: C2RustUnnamed_2 {
44176                                lastkey: 0,
44177                                keystep: 0,
44178                                limit: 0,
44179                            },
44180                        },
44181                    },
44182                ],
44183                getkeys_proc: None,
44184                subcommands: 0 as *const redisCommand as *mut redisCommand,
44185                args: RENAMENX_Args.as_ptr() as *mut _,
44186                microseconds: 0,
44187                calls: 0,
44188                rejected_calls: 0,
44189                failed_calls: 0,
44190                id: 0,
44191                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44192                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44193                key_specs: 0 as *const keySpec as *mut keySpec,
44194                legacy_range_key_spec: keySpec {
44195                    notes: 0 as *const libc::c_char,
44196                    flags: 0,
44197                    begin_search_type: KSPEC_BS_INVALID,
44198                    bs: C2RustUnnamed_3 {
44199                        index: C2RustUnnamed_5 { pos: 0 },
44200                    },
44201                    find_keys_type: KSPEC_FK_INVALID,
44202                    fk: C2RustUnnamed_0 {
44203                        range: C2RustUnnamed_2 {
44204                            lastkey: 0,
44205                            keystep: 0,
44206                            limit: 0,
44207                        },
44208                    },
44209                },
44210                num_args: 0,
44211                num_history: 0,
44212                num_tips: 0,
44213                key_specs_num: 0,
44214                key_specs_max: 0,
44215                subcommands_dict: 0 as *const dict as *mut dict,
44216                parent: 0 as *const redisCommand as *mut redisCommand,
44217                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44218            };
44219            init
44220        },
44221        {
44222            let mut init = redisCommand {
44223                declared_name: b"restore\0" as *const u8 as *const libc::c_char,
44224                summary: b"Create a key using the provided serialized value, previously obtained using DUMP.\0"
44225                    as *const u8 as *const libc::c_char,
44226                complexity: b"O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).\0"
44227                    as *const u8 as *const libc::c_char,
44228                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
44229                doc_flags: 0 as libc::c_int,
44230                replaced_by: 0 as *const libc::c_char,
44231                deprecated_since: 0 as *const libc::c_char,
44232                group: COMMAND_GROUP_GENERIC,
44233                history: RESTORE_History.as_ptr() as *mut _,
44234                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
44235                proc_0: Some(restoreCommand as unsafe extern "C" fn(*mut client) -> ()),
44236                arity: -(4 as libc::c_int),
44237                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44238                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
44239                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44240                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
44241                key_specs_static: [
44242                    {
44243                        let mut init = keySpec {
44244                            notes: 0 as *const libc::c_char,
44245                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
44246                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
44247                            begin_search_type: KSPEC_BS_INDEX,
44248                            bs: C2RustUnnamed_3 {
44249                                index: {
44250                                    let mut init = C2RustUnnamed_5 {
44251                                        pos: 1 as libc::c_int,
44252                                    };
44253                                    init
44254                                },
44255                            },
44256                            find_keys_type: KSPEC_FK_RANGE,
44257                            fk: C2RustUnnamed_0 {
44258                                range: {
44259                                    let mut init = C2RustUnnamed_2 {
44260                                        lastkey: 0 as libc::c_int,
44261                                        keystep: 1 as libc::c_int,
44262                                        limit: 0 as libc::c_int,
44263                                    };
44264                                    init
44265                                },
44266                            },
44267                        };
44268                        init
44269                    },
44270                    keySpec {
44271                        notes: 0 as *const libc::c_char,
44272                        flags: 0,
44273                        begin_search_type: KSPEC_BS_INVALID,
44274                        bs: C2RustUnnamed_3 {
44275                            index: C2RustUnnamed_5 { pos: 0 },
44276                        },
44277                        find_keys_type: KSPEC_FK_INVALID,
44278                        fk: C2RustUnnamed_0 {
44279                            range: C2RustUnnamed_2 {
44280                                lastkey: 0,
44281                                keystep: 0,
44282                                limit: 0,
44283                            },
44284                        },
44285                    },
44286                    keySpec {
44287                        notes: 0 as *const libc::c_char,
44288                        flags: 0,
44289                        begin_search_type: KSPEC_BS_INVALID,
44290                        bs: C2RustUnnamed_3 {
44291                            index: C2RustUnnamed_5 { pos: 0 },
44292                        },
44293                        find_keys_type: KSPEC_FK_INVALID,
44294                        fk: C2RustUnnamed_0 {
44295                            range: C2RustUnnamed_2 {
44296                                lastkey: 0,
44297                                keystep: 0,
44298                                limit: 0,
44299                            },
44300                        },
44301                    },
44302                    keySpec {
44303                        notes: 0 as *const libc::c_char,
44304                        flags: 0,
44305                        begin_search_type: KSPEC_BS_INVALID,
44306                        bs: C2RustUnnamed_3 {
44307                            index: C2RustUnnamed_5 { pos: 0 },
44308                        },
44309                        find_keys_type: KSPEC_FK_INVALID,
44310                        fk: C2RustUnnamed_0 {
44311                            range: C2RustUnnamed_2 {
44312                                lastkey: 0,
44313                                keystep: 0,
44314                                limit: 0,
44315                            },
44316                        },
44317                    },
44318                ],
44319                getkeys_proc: None,
44320                subcommands: 0 as *const redisCommand as *mut redisCommand,
44321                args: RESTORE_Args.as_ptr() as *mut _,
44322                microseconds: 0,
44323                calls: 0,
44324                rejected_calls: 0,
44325                failed_calls: 0,
44326                id: 0,
44327                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44328                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44329                key_specs: 0 as *const keySpec as *mut keySpec,
44330                legacy_range_key_spec: keySpec {
44331                    notes: 0 as *const libc::c_char,
44332                    flags: 0,
44333                    begin_search_type: KSPEC_BS_INVALID,
44334                    bs: C2RustUnnamed_3 {
44335                        index: C2RustUnnamed_5 { pos: 0 },
44336                    },
44337                    find_keys_type: KSPEC_FK_INVALID,
44338                    fk: C2RustUnnamed_0 {
44339                        range: C2RustUnnamed_2 {
44340                            lastkey: 0,
44341                            keystep: 0,
44342                            limit: 0,
44343                        },
44344                    },
44345                },
44346                num_args: 0,
44347                num_history: 0,
44348                num_tips: 0,
44349                key_specs_num: 0,
44350                key_specs_max: 0,
44351                subcommands_dict: 0 as *const dict as *mut dict,
44352                parent: 0 as *const redisCommand as *mut redisCommand,
44353                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44354            };
44355            init
44356        },
44357        {
44358            let mut init = redisCommand {
44359                declared_name: b"scan\0" as *const u8 as *const libc::c_char,
44360                summary: b"Incrementally iterate the keys space\0" as *const u8
44361                    as *const libc::c_char,
44362                complexity: b"O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.\0"
44363                    as *const u8 as *const libc::c_char,
44364                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
44365                doc_flags: 0 as libc::c_int,
44366                replaced_by: 0 as *const libc::c_char,
44367                deprecated_since: 0 as *const libc::c_char,
44368                group: COMMAND_GROUP_GENERIC,
44369                history: SCAN_History.as_ptr() as *mut _,
44370                tips: SCAN_tips.as_ptr() as *mut _,
44371                proc_0: Some(scanCommand as unsafe extern "C" fn(*mut client) -> ()),
44372                arity: -(2 as libc::c_int),
44373                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
44374                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
44375                    as uint64_t,
44376                key_specs_static: [keySpec {
44377                    notes: 0 as *const libc::c_char,
44378                    flags: 0,
44379                    begin_search_type: KSPEC_BS_INVALID,
44380                    bs: C2RustUnnamed_3 {
44381                        index: C2RustUnnamed_5 { pos: 0 },
44382                    },
44383                    find_keys_type: KSPEC_FK_INVALID,
44384                    fk: C2RustUnnamed_0 {
44385                        range: C2RustUnnamed_2 {
44386                            lastkey: 0,
44387                            keystep: 0,
44388                            limit: 0,
44389                        },
44390                    },
44391                }; 4],
44392                getkeys_proc: None,
44393                subcommands: 0 as *const redisCommand as *mut redisCommand,
44394                args: SCAN_Args.as_ptr() as *mut _,
44395                microseconds: 0,
44396                calls: 0,
44397                rejected_calls: 0,
44398                failed_calls: 0,
44399                id: 0,
44400                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44401                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44402                key_specs: 0 as *const keySpec as *mut keySpec,
44403                legacy_range_key_spec: keySpec {
44404                    notes: 0 as *const libc::c_char,
44405                    flags: 0,
44406                    begin_search_type: KSPEC_BS_INVALID,
44407                    bs: C2RustUnnamed_3 {
44408                        index: C2RustUnnamed_5 { pos: 0 },
44409                    },
44410                    find_keys_type: KSPEC_FK_INVALID,
44411                    fk: C2RustUnnamed_0 {
44412                        range: C2RustUnnamed_2 {
44413                            lastkey: 0,
44414                            keystep: 0,
44415                            limit: 0,
44416                        },
44417                    },
44418                },
44419                num_args: 0,
44420                num_history: 0,
44421                num_tips: 0,
44422                key_specs_num: 0,
44423                key_specs_max: 0,
44424                subcommands_dict: 0 as *const dict as *mut dict,
44425                parent: 0 as *const redisCommand as *mut redisCommand,
44426                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44427            };
44428            init
44429        },
44430        {
44431            let mut init = redisCommand {
44432                declared_name: b"sort\0" as *const u8 as *const libc::c_char,
44433                summary: b"Sort the elements in a list, set or sorted set\0" as *const u8
44434                    as *const libc::c_char,
44435                complexity: b"O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).\0"
44436                    as *const u8 as *const libc::c_char,
44437                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
44438                doc_flags: 0 as libc::c_int,
44439                replaced_by: 0 as *const libc::c_char,
44440                deprecated_since: 0 as *const libc::c_char,
44441                group: COMMAND_GROUP_GENERIC,
44442                history: 0 as *const commandHistory as *mut commandHistory,
44443                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
44444                proc_0: Some(sortCommand as unsafe extern "C" fn(*mut client) -> ()),
44445                arity: -(2 as libc::c_int),
44446                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44447                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
44448                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int
44449                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
44450                    | (1 as libc::c_ulonglong) << 5 as libc::c_int
44451                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
44452                key_specs_static: [
44453                    {
44454                        let mut init = keySpec {
44455                            notes: 0 as *const libc::c_char,
44456                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44457                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
44458                            begin_search_type: KSPEC_BS_INDEX,
44459                            bs: C2RustUnnamed_3 {
44460                                index: {
44461                                    let mut init = C2RustUnnamed_5 {
44462                                        pos: 1 as libc::c_int,
44463                                    };
44464                                    init
44465                                },
44466                            },
44467                            find_keys_type: KSPEC_FK_RANGE,
44468                            fk: C2RustUnnamed_0 {
44469                                range: {
44470                                    let mut init = C2RustUnnamed_2 {
44471                                        lastkey: 0 as libc::c_int,
44472                                        keystep: 1 as libc::c_int,
44473                                        limit: 0 as libc::c_int,
44474                                    };
44475                                    init
44476                                },
44477                            },
44478                        };
44479                        init
44480                    },
44481                    {
44482                        let mut init = keySpec {
44483                            notes: b"For the optional BY/GET keyword. It is marked 'unknown' because the key names derive from the content of the key we sort\0"
44484                                as *const u8 as *const libc::c_char,
44485                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44486                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
44487                            begin_search_type: KSPEC_BS_UNKNOWN,
44488                            bs: C2RustUnnamed_3 {
44489                                index: {
44490                                    let mut init = C2RustUnnamed_5 {
44491                                        pos: 0 as libc::c_int,
44492                                    };
44493                                    init
44494                                },
44495                            },
44496                            find_keys_type: KSPEC_FK_UNKNOWN,
44497                            fk: C2RustUnnamed_0 {
44498                                range: {
44499                                    let mut init = C2RustUnnamed_2 {
44500                                        lastkey: 0 as libc::c_int,
44501                                        keystep: 0,
44502                                        limit: 0,
44503                                    };
44504                                    init
44505                                },
44506                            },
44507                        };
44508                        init
44509                    },
44510                    {
44511                        let mut init = keySpec {
44512                            notes: b"For the optional STORE keyword. It is marked 'unknown' because the keyword can appear anywhere in the argument array\0"
44513                                as *const u8 as *const libc::c_char,
44514                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
44515                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
44516                            begin_search_type: KSPEC_BS_UNKNOWN,
44517                            bs: C2RustUnnamed_3 {
44518                                index: {
44519                                    let mut init = C2RustUnnamed_5 {
44520                                        pos: 0 as libc::c_int,
44521                                    };
44522                                    init
44523                                },
44524                            },
44525                            find_keys_type: KSPEC_FK_UNKNOWN,
44526                            fk: C2RustUnnamed_0 {
44527                                range: {
44528                                    let mut init = C2RustUnnamed_2 {
44529                                        lastkey: 0 as libc::c_int,
44530                                        keystep: 0,
44531                                        limit: 0,
44532                                    };
44533                                    init
44534                                },
44535                            },
44536                        };
44537                        init
44538                    },
44539                    keySpec {
44540                        notes: 0 as *const libc::c_char,
44541                        flags: 0,
44542                        begin_search_type: KSPEC_BS_INVALID,
44543                        bs: C2RustUnnamed_3 {
44544                            index: C2RustUnnamed_5 { pos: 0 },
44545                        },
44546                        find_keys_type: KSPEC_FK_INVALID,
44547                        fk: C2RustUnnamed_0 {
44548                            range: C2RustUnnamed_2 {
44549                                lastkey: 0,
44550                                keystep: 0,
44551                                limit: 0,
44552                            },
44553                        },
44554                    },
44555                ],
44556                getkeys_proc: Some(
44557                    sortGetKeys
44558                        as unsafe extern "C" fn(
44559                            *mut redisCommand,
44560                            *mut *mut robj,
44561                            libc::c_int,
44562                            *mut getKeysResult,
44563                        ) -> libc::c_int,
44564                ),
44565                subcommands: 0 as *const redisCommand as *mut redisCommand,
44566                args: SORT_Args.as_ptr() as *mut _,
44567                microseconds: 0,
44568                calls: 0,
44569                rejected_calls: 0,
44570                failed_calls: 0,
44571                id: 0,
44572                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44573                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44574                key_specs: 0 as *const keySpec as *mut keySpec,
44575                legacy_range_key_spec: keySpec {
44576                    notes: 0 as *const libc::c_char,
44577                    flags: 0,
44578                    begin_search_type: KSPEC_BS_INVALID,
44579                    bs: C2RustUnnamed_3 {
44580                        index: C2RustUnnamed_5 { pos: 0 },
44581                    },
44582                    find_keys_type: KSPEC_FK_INVALID,
44583                    fk: C2RustUnnamed_0 {
44584                        range: C2RustUnnamed_2 {
44585                            lastkey: 0,
44586                            keystep: 0,
44587                            limit: 0,
44588                        },
44589                    },
44590                },
44591                num_args: 0,
44592                num_history: 0,
44593                num_tips: 0,
44594                key_specs_num: 0,
44595                key_specs_max: 0,
44596                subcommands_dict: 0 as *const dict as *mut dict,
44597                parent: 0 as *const redisCommand as *mut redisCommand,
44598                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44599            };
44600            init
44601        },
44602        {
44603            let mut init = redisCommand {
44604                declared_name: b"sort_ro\0" as *const u8 as *const libc::c_char,
44605                summary: b"Sort the elements in a list, set or sorted set. Read-only variant of SORT.\0"
44606                    as *const u8 as *const libc::c_char,
44607                complexity: b"O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).\0"
44608                    as *const u8 as *const libc::c_char,
44609                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
44610                doc_flags: 0 as libc::c_int,
44611                replaced_by: 0 as *const libc::c_char,
44612                deprecated_since: 0 as *const libc::c_char,
44613                group: COMMAND_GROUP_GENERIC,
44614                history: 0 as *const commandHistory as *mut commandHistory,
44615                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
44616                proc_0: Some(sortroCommand as unsafe extern "C" fn(*mut client) -> ()),
44617                arity: -(2 as libc::c_int),
44618                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
44619                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int
44620                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
44621                    | (1 as libc::c_ulonglong) << 5 as libc::c_int
44622                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
44623                key_specs_static: [
44624                    {
44625                        let mut init = keySpec {
44626                            notes: 0 as *const libc::c_char,
44627                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44628                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
44629                            begin_search_type: KSPEC_BS_INDEX,
44630                            bs: C2RustUnnamed_3 {
44631                                index: {
44632                                    let mut init = C2RustUnnamed_5 {
44633                                        pos: 1 as libc::c_int,
44634                                    };
44635                                    init
44636                                },
44637                            },
44638                            find_keys_type: KSPEC_FK_RANGE,
44639                            fk: C2RustUnnamed_0 {
44640                                range: {
44641                                    let mut init = C2RustUnnamed_2 {
44642                                        lastkey: 0 as libc::c_int,
44643                                        keystep: 1 as libc::c_int,
44644                                        limit: 0 as libc::c_int,
44645                                    };
44646                                    init
44647                                },
44648                            },
44649                        };
44650                        init
44651                    },
44652                    {
44653                        let mut init = keySpec {
44654                            notes: b"For the optional BY/GET keyword. It is marked 'unknown' because the key names derive from the content of the key we sort\0"
44655                                as *const u8 as *const libc::c_char,
44656                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44657                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
44658                            begin_search_type: KSPEC_BS_UNKNOWN,
44659                            bs: C2RustUnnamed_3 {
44660                                index: {
44661                                    let mut init = C2RustUnnamed_5 {
44662                                        pos: 0 as libc::c_int,
44663                                    };
44664                                    init
44665                                },
44666                            },
44667                            find_keys_type: KSPEC_FK_UNKNOWN,
44668                            fk: C2RustUnnamed_0 {
44669                                range: {
44670                                    let mut init = C2RustUnnamed_2 {
44671                                        lastkey: 0 as libc::c_int,
44672                                        keystep: 0,
44673                                        limit: 0,
44674                                    };
44675                                    init
44676                                },
44677                            },
44678                        };
44679                        init
44680                    },
44681                    keySpec {
44682                        notes: 0 as *const libc::c_char,
44683                        flags: 0,
44684                        begin_search_type: KSPEC_BS_INVALID,
44685                        bs: C2RustUnnamed_3 {
44686                            index: C2RustUnnamed_5 { pos: 0 },
44687                        },
44688                        find_keys_type: KSPEC_FK_INVALID,
44689                        fk: C2RustUnnamed_0 {
44690                            range: C2RustUnnamed_2 {
44691                                lastkey: 0,
44692                                keystep: 0,
44693                                limit: 0,
44694                            },
44695                        },
44696                    },
44697                    keySpec {
44698                        notes: 0 as *const libc::c_char,
44699                        flags: 0,
44700                        begin_search_type: KSPEC_BS_INVALID,
44701                        bs: C2RustUnnamed_3 {
44702                            index: C2RustUnnamed_5 { pos: 0 },
44703                        },
44704                        find_keys_type: KSPEC_FK_INVALID,
44705                        fk: C2RustUnnamed_0 {
44706                            range: C2RustUnnamed_2 {
44707                                lastkey: 0,
44708                                keystep: 0,
44709                                limit: 0,
44710                            },
44711                        },
44712                    },
44713                ],
44714                getkeys_proc: Some(
44715                    sortROGetKeys
44716                        as unsafe extern "C" fn(
44717                            *mut redisCommand,
44718                            *mut *mut robj,
44719                            libc::c_int,
44720                            *mut getKeysResult,
44721                        ) -> libc::c_int,
44722                ),
44723                subcommands: 0 as *const redisCommand as *mut redisCommand,
44724                args: SORT_RO_Args.as_ptr() as *mut _,
44725                microseconds: 0,
44726                calls: 0,
44727                rejected_calls: 0,
44728                failed_calls: 0,
44729                id: 0,
44730                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44731                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44732                key_specs: 0 as *const keySpec as *mut keySpec,
44733                legacy_range_key_spec: keySpec {
44734                    notes: 0 as *const libc::c_char,
44735                    flags: 0,
44736                    begin_search_type: KSPEC_BS_INVALID,
44737                    bs: C2RustUnnamed_3 {
44738                        index: C2RustUnnamed_5 { pos: 0 },
44739                    },
44740                    find_keys_type: KSPEC_FK_INVALID,
44741                    fk: C2RustUnnamed_0 {
44742                        range: C2RustUnnamed_2 {
44743                            lastkey: 0,
44744                            keystep: 0,
44745                            limit: 0,
44746                        },
44747                    },
44748                },
44749                num_args: 0,
44750                num_history: 0,
44751                num_tips: 0,
44752                key_specs_num: 0,
44753                key_specs_max: 0,
44754                subcommands_dict: 0 as *const dict as *mut dict,
44755                parent: 0 as *const redisCommand as *mut redisCommand,
44756                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44757            };
44758            init
44759        },
44760        {
44761            let mut init = redisCommand {
44762                declared_name: b"touch\0" as *const u8 as *const libc::c_char,
44763                summary: b"Alters the last access time of a key(s). Returns the number of existing keys specified.\0"
44764                    as *const u8 as *const libc::c_char,
44765                complexity: b"O(N) where N is the number of keys that will be touched.\0"
44766                    as *const u8 as *const libc::c_char,
44767                since: b"3.2.1\0" as *const u8 as *const libc::c_char,
44768                doc_flags: 0 as libc::c_int,
44769                replaced_by: 0 as *const libc::c_char,
44770                deprecated_since: 0 as *const libc::c_char,
44771                group: COMMAND_GROUP_GENERIC,
44772                history: 0 as *const commandHistory as *mut commandHistory,
44773                tips: TOUCH_tips.as_ptr() as *mut _,
44774                proc_0: Some(touchCommand as unsafe extern "C" fn(*mut client) -> ()),
44775                arity: -(2 as libc::c_int),
44776                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
44777                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
44778                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
44779                    as uint64_t,
44780                key_specs_static: [
44781                    {
44782                        let mut init = keySpec {
44783                            notes: 0 as *const libc::c_char,
44784                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
44785                                as uint64_t,
44786                            begin_search_type: KSPEC_BS_INDEX,
44787                            bs: C2RustUnnamed_3 {
44788                                index: {
44789                                    let mut init = C2RustUnnamed_5 {
44790                                        pos: 1 as libc::c_int,
44791                                    };
44792                                    init
44793                                },
44794                            },
44795                            find_keys_type: KSPEC_FK_RANGE,
44796                            fk: C2RustUnnamed_0 {
44797                                range: {
44798                                    let mut init = C2RustUnnamed_2 {
44799                                        lastkey: -(1 as libc::c_int),
44800                                        keystep: 1 as libc::c_int,
44801                                        limit: 0 as libc::c_int,
44802                                    };
44803                                    init
44804                                },
44805                            },
44806                        };
44807                        init
44808                    },
44809                    keySpec {
44810                        notes: 0 as *const libc::c_char,
44811                        flags: 0,
44812                        begin_search_type: KSPEC_BS_INVALID,
44813                        bs: C2RustUnnamed_3 {
44814                            index: C2RustUnnamed_5 { pos: 0 },
44815                        },
44816                        find_keys_type: KSPEC_FK_INVALID,
44817                        fk: C2RustUnnamed_0 {
44818                            range: C2RustUnnamed_2 {
44819                                lastkey: 0,
44820                                keystep: 0,
44821                                limit: 0,
44822                            },
44823                        },
44824                    },
44825                    keySpec {
44826                        notes: 0 as *const libc::c_char,
44827                        flags: 0,
44828                        begin_search_type: KSPEC_BS_INVALID,
44829                        bs: C2RustUnnamed_3 {
44830                            index: C2RustUnnamed_5 { pos: 0 },
44831                        },
44832                        find_keys_type: KSPEC_FK_INVALID,
44833                        fk: C2RustUnnamed_0 {
44834                            range: C2RustUnnamed_2 {
44835                                lastkey: 0,
44836                                keystep: 0,
44837                                limit: 0,
44838                            },
44839                        },
44840                    },
44841                    keySpec {
44842                        notes: 0 as *const libc::c_char,
44843                        flags: 0,
44844                        begin_search_type: KSPEC_BS_INVALID,
44845                        bs: C2RustUnnamed_3 {
44846                            index: C2RustUnnamed_5 { pos: 0 },
44847                        },
44848                        find_keys_type: KSPEC_FK_INVALID,
44849                        fk: C2RustUnnamed_0 {
44850                            range: C2RustUnnamed_2 {
44851                                lastkey: 0,
44852                                keystep: 0,
44853                                limit: 0,
44854                            },
44855                        },
44856                    },
44857                ],
44858                getkeys_proc: None,
44859                subcommands: 0 as *const redisCommand as *mut redisCommand,
44860                args: TOUCH_Args.as_ptr() as *mut _,
44861                microseconds: 0,
44862                calls: 0,
44863                rejected_calls: 0,
44864                failed_calls: 0,
44865                id: 0,
44866                fullname: 0 as *const libc::c_char as *mut libc::c_char,
44867                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
44868                key_specs: 0 as *const keySpec as *mut keySpec,
44869                legacy_range_key_spec: keySpec {
44870                    notes: 0 as *const libc::c_char,
44871                    flags: 0,
44872                    begin_search_type: KSPEC_BS_INVALID,
44873                    bs: C2RustUnnamed_3 {
44874                        index: C2RustUnnamed_5 { pos: 0 },
44875                    },
44876                    find_keys_type: KSPEC_FK_INVALID,
44877                    fk: C2RustUnnamed_0 {
44878                        range: C2RustUnnamed_2 {
44879                            lastkey: 0,
44880                            keystep: 0,
44881                            limit: 0,
44882                        },
44883                    },
44884                },
44885                num_args: 0,
44886                num_history: 0,
44887                num_tips: 0,
44888                key_specs_num: 0,
44889                key_specs_max: 0,
44890                subcommands_dict: 0 as *const dict as *mut dict,
44891                parent: 0 as *const redisCommand as *mut redisCommand,
44892                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
44893            };
44894            init
44895        },
44896        {
44897            let mut init = redisCommand {
44898                declared_name: b"ttl\0" as *const u8 as *const libc::c_char,
44899                summary: b"Get the time to live for a key in seconds\0" as *const u8
44900                    as *const libc::c_char,
44901                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
44902                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
44903                doc_flags: 0 as libc::c_int,
44904                replaced_by: 0 as *const libc::c_char,
44905                deprecated_since: 0 as *const libc::c_char,
44906                group: COMMAND_GROUP_GENERIC,
44907                history: TTL_History.as_ptr() as *mut _,
44908                tips: TTL_tips.as_ptr() as *mut _,
44909                proc_0: Some(ttlCommand as unsafe extern "C" fn(*mut client) -> ()),
44910                arity: 2 as libc::c_int,
44911                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
44912                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
44913                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
44914                    as uint64_t,
44915                key_specs_static: [
44916                    {
44917                        let mut init = keySpec {
44918                            notes: 0 as *const libc::c_char,
44919                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
44920                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
44921                            begin_search_type: KSPEC_BS_INDEX,
44922                            bs: C2RustUnnamed_3 {
44923                                index: {
44924                                    let mut init = C2RustUnnamed_5 {
44925                                        pos: 1 as libc::c_int,
44926                                    };
44927                                    init
44928                                },
44929                            },
44930                            find_keys_type: KSPEC_FK_RANGE,
44931                            fk: C2RustUnnamed_0 {
44932                                range: {
44933                                    let mut init = C2RustUnnamed_2 {
44934                                        lastkey: 0 as libc::c_int,
44935                                        keystep: 1 as libc::c_int,
44936                                        limit: 0 as libc::c_int,
44937                                    };
44938                                    init
44939                                },
44940                            },
44941                        };
44942                        init
44943                    },
44944                    keySpec {
44945                        notes: 0 as *const libc::c_char,
44946                        flags: 0,
44947                        begin_search_type: KSPEC_BS_INVALID,
44948                        bs: C2RustUnnamed_3 {
44949                            index: C2RustUnnamed_5 { pos: 0 },
44950                        },
44951                        find_keys_type: KSPEC_FK_INVALID,
44952                        fk: C2RustUnnamed_0 {
44953                            range: C2RustUnnamed_2 {
44954                                lastkey: 0,
44955                                keystep: 0,
44956                                limit: 0,
44957                            },
44958                        },
44959                    },
44960                    keySpec {
44961                        notes: 0 as *const libc::c_char,
44962                        flags: 0,
44963                        begin_search_type: KSPEC_BS_INVALID,
44964                        bs: C2RustUnnamed_3 {
44965                            index: C2RustUnnamed_5 { pos: 0 },
44966                        },
44967                        find_keys_type: KSPEC_FK_INVALID,
44968                        fk: C2RustUnnamed_0 {
44969                            range: C2RustUnnamed_2 {
44970                                lastkey: 0,
44971                                keystep: 0,
44972                                limit: 0,
44973                            },
44974                        },
44975                    },
44976                    keySpec {
44977                        notes: 0 as *const libc::c_char,
44978                        flags: 0,
44979                        begin_search_type: KSPEC_BS_INVALID,
44980                        bs: C2RustUnnamed_3 {
44981                            index: C2RustUnnamed_5 { pos: 0 },
44982                        },
44983                        find_keys_type: KSPEC_FK_INVALID,
44984                        fk: C2RustUnnamed_0 {
44985                            range: C2RustUnnamed_2 {
44986                                lastkey: 0,
44987                                keystep: 0,
44988                                limit: 0,
44989                            },
44990                        },
44991                    },
44992                ],
44993                getkeys_proc: None,
44994                subcommands: 0 as *const redisCommand as *mut redisCommand,
44995                args: TTL_Args.as_ptr() as *mut _,
44996                microseconds: 0,
44997                calls: 0,
44998                rejected_calls: 0,
44999                failed_calls: 0,
45000                id: 0,
45001                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45002                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45003                key_specs: 0 as *const keySpec as *mut keySpec,
45004                legacy_range_key_spec: keySpec {
45005                    notes: 0 as *const libc::c_char,
45006                    flags: 0,
45007                    begin_search_type: KSPEC_BS_INVALID,
45008                    bs: C2RustUnnamed_3 {
45009                        index: C2RustUnnamed_5 { pos: 0 },
45010                    },
45011                    find_keys_type: KSPEC_FK_INVALID,
45012                    fk: C2RustUnnamed_0 {
45013                        range: C2RustUnnamed_2 {
45014                            lastkey: 0,
45015                            keystep: 0,
45016                            limit: 0,
45017                        },
45018                    },
45019                },
45020                num_args: 0,
45021                num_history: 0,
45022                num_tips: 0,
45023                key_specs_num: 0,
45024                key_specs_max: 0,
45025                subcommands_dict: 0 as *const dict as *mut dict,
45026                parent: 0 as *const redisCommand as *mut redisCommand,
45027                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45028            };
45029            init
45030        },
45031        {
45032            let mut init = redisCommand {
45033                declared_name: b"type\0" as *const u8 as *const libc::c_char,
45034                summary: b"Determine the type stored at key\0" as *const u8
45035                    as *const libc::c_char,
45036                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
45037                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
45038                doc_flags: 0 as libc::c_int,
45039                replaced_by: 0 as *const libc::c_char,
45040                deprecated_since: 0 as *const libc::c_char,
45041                group: COMMAND_GROUP_GENERIC,
45042                history: 0 as *const commandHistory as *mut commandHistory,
45043                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45044                proc_0: Some(typeCommand as unsafe extern "C" fn(*mut client) -> ()),
45045                arity: 2 as libc::c_int,
45046                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
45047                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
45048                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
45049                    as uint64_t,
45050                key_specs_static: [
45051                    {
45052                        let mut init = keySpec {
45053                            notes: 0 as *const libc::c_char,
45054                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
45055                                as uint64_t,
45056                            begin_search_type: KSPEC_BS_INDEX,
45057                            bs: C2RustUnnamed_3 {
45058                                index: {
45059                                    let mut init = C2RustUnnamed_5 {
45060                                        pos: 1 as libc::c_int,
45061                                    };
45062                                    init
45063                                },
45064                            },
45065                            find_keys_type: KSPEC_FK_RANGE,
45066                            fk: C2RustUnnamed_0 {
45067                                range: {
45068                                    let mut init = C2RustUnnamed_2 {
45069                                        lastkey: 0 as libc::c_int,
45070                                        keystep: 1 as libc::c_int,
45071                                        limit: 0 as libc::c_int,
45072                                    };
45073                                    init
45074                                },
45075                            },
45076                        };
45077                        init
45078                    },
45079                    keySpec {
45080                        notes: 0 as *const libc::c_char,
45081                        flags: 0,
45082                        begin_search_type: KSPEC_BS_INVALID,
45083                        bs: C2RustUnnamed_3 {
45084                            index: C2RustUnnamed_5 { pos: 0 },
45085                        },
45086                        find_keys_type: KSPEC_FK_INVALID,
45087                        fk: C2RustUnnamed_0 {
45088                            range: C2RustUnnamed_2 {
45089                                lastkey: 0,
45090                                keystep: 0,
45091                                limit: 0,
45092                            },
45093                        },
45094                    },
45095                    keySpec {
45096                        notes: 0 as *const libc::c_char,
45097                        flags: 0,
45098                        begin_search_type: KSPEC_BS_INVALID,
45099                        bs: C2RustUnnamed_3 {
45100                            index: C2RustUnnamed_5 { pos: 0 },
45101                        },
45102                        find_keys_type: KSPEC_FK_INVALID,
45103                        fk: C2RustUnnamed_0 {
45104                            range: C2RustUnnamed_2 {
45105                                lastkey: 0,
45106                                keystep: 0,
45107                                limit: 0,
45108                            },
45109                        },
45110                    },
45111                    keySpec {
45112                        notes: 0 as *const libc::c_char,
45113                        flags: 0,
45114                        begin_search_type: KSPEC_BS_INVALID,
45115                        bs: C2RustUnnamed_3 {
45116                            index: C2RustUnnamed_5 { pos: 0 },
45117                        },
45118                        find_keys_type: KSPEC_FK_INVALID,
45119                        fk: C2RustUnnamed_0 {
45120                            range: C2RustUnnamed_2 {
45121                                lastkey: 0,
45122                                keystep: 0,
45123                                limit: 0,
45124                            },
45125                        },
45126                    },
45127                ],
45128                getkeys_proc: None,
45129                subcommands: 0 as *const redisCommand as *mut redisCommand,
45130                args: TYPE_Args.as_ptr() as *mut _,
45131                microseconds: 0,
45132                calls: 0,
45133                rejected_calls: 0,
45134                failed_calls: 0,
45135                id: 0,
45136                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45137                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45138                key_specs: 0 as *const keySpec as *mut keySpec,
45139                legacy_range_key_spec: keySpec {
45140                    notes: 0 as *const libc::c_char,
45141                    flags: 0,
45142                    begin_search_type: KSPEC_BS_INVALID,
45143                    bs: C2RustUnnamed_3 {
45144                        index: C2RustUnnamed_5 { pos: 0 },
45145                    },
45146                    find_keys_type: KSPEC_FK_INVALID,
45147                    fk: C2RustUnnamed_0 {
45148                        range: C2RustUnnamed_2 {
45149                            lastkey: 0,
45150                            keystep: 0,
45151                            limit: 0,
45152                        },
45153                    },
45154                },
45155                num_args: 0,
45156                num_history: 0,
45157                num_tips: 0,
45158                key_specs_num: 0,
45159                key_specs_max: 0,
45160                subcommands_dict: 0 as *const dict as *mut dict,
45161                parent: 0 as *const redisCommand as *mut redisCommand,
45162                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45163            };
45164            init
45165        },
45166        {
45167            let mut init = redisCommand {
45168                declared_name: b"unlink\0" as *const u8 as *const libc::c_char,
45169                summary: b"Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.\0"
45170                    as *const u8 as *const libc::c_char,
45171                complexity: b"O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.\0"
45172                    as *const u8 as *const libc::c_char,
45173                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
45174                doc_flags: 0 as libc::c_int,
45175                replaced_by: 0 as *const libc::c_char,
45176                deprecated_since: 0 as *const libc::c_char,
45177                group: COMMAND_GROUP_GENERIC,
45178                history: 0 as *const commandHistory as *mut commandHistory,
45179                tips: UNLINK_tips.as_ptr() as *mut _,
45180                proc_0: Some(unlinkCommand as unsafe extern "C" fn(*mut client) -> ()),
45181                arity: -(2 as libc::c_int),
45182                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45183                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
45184                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
45185                    as uint64_t,
45186                key_specs_static: [
45187                    {
45188                        let mut init = keySpec {
45189                            notes: 0 as *const libc::c_char,
45190                            flags: ((1 as libc::c_ulonglong) << 3 as libc::c_int
45191                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
45192                            begin_search_type: KSPEC_BS_INDEX,
45193                            bs: C2RustUnnamed_3 {
45194                                index: {
45195                                    let mut init = C2RustUnnamed_5 {
45196                                        pos: 1 as libc::c_int,
45197                                    };
45198                                    init
45199                                },
45200                            },
45201                            find_keys_type: KSPEC_FK_RANGE,
45202                            fk: C2RustUnnamed_0 {
45203                                range: {
45204                                    let mut init = C2RustUnnamed_2 {
45205                                        lastkey: -(1 as libc::c_int),
45206                                        keystep: 1 as libc::c_int,
45207                                        limit: 0 as libc::c_int,
45208                                    };
45209                                    init
45210                                },
45211                            },
45212                        };
45213                        init
45214                    },
45215                    keySpec {
45216                        notes: 0 as *const libc::c_char,
45217                        flags: 0,
45218                        begin_search_type: KSPEC_BS_INVALID,
45219                        bs: C2RustUnnamed_3 {
45220                            index: C2RustUnnamed_5 { pos: 0 },
45221                        },
45222                        find_keys_type: KSPEC_FK_INVALID,
45223                        fk: C2RustUnnamed_0 {
45224                            range: C2RustUnnamed_2 {
45225                                lastkey: 0,
45226                                keystep: 0,
45227                                limit: 0,
45228                            },
45229                        },
45230                    },
45231                    keySpec {
45232                        notes: 0 as *const libc::c_char,
45233                        flags: 0,
45234                        begin_search_type: KSPEC_BS_INVALID,
45235                        bs: C2RustUnnamed_3 {
45236                            index: C2RustUnnamed_5 { pos: 0 },
45237                        },
45238                        find_keys_type: KSPEC_FK_INVALID,
45239                        fk: C2RustUnnamed_0 {
45240                            range: C2RustUnnamed_2 {
45241                                lastkey: 0,
45242                                keystep: 0,
45243                                limit: 0,
45244                            },
45245                        },
45246                    },
45247                    keySpec {
45248                        notes: 0 as *const libc::c_char,
45249                        flags: 0,
45250                        begin_search_type: KSPEC_BS_INVALID,
45251                        bs: C2RustUnnamed_3 {
45252                            index: C2RustUnnamed_5 { pos: 0 },
45253                        },
45254                        find_keys_type: KSPEC_FK_INVALID,
45255                        fk: C2RustUnnamed_0 {
45256                            range: C2RustUnnamed_2 {
45257                                lastkey: 0,
45258                                keystep: 0,
45259                                limit: 0,
45260                            },
45261                        },
45262                    },
45263                ],
45264                getkeys_proc: None,
45265                subcommands: 0 as *const redisCommand as *mut redisCommand,
45266                args: UNLINK_Args.as_ptr() as *mut _,
45267                microseconds: 0,
45268                calls: 0,
45269                rejected_calls: 0,
45270                failed_calls: 0,
45271                id: 0,
45272                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45273                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45274                key_specs: 0 as *const keySpec as *mut keySpec,
45275                legacy_range_key_spec: keySpec {
45276                    notes: 0 as *const libc::c_char,
45277                    flags: 0,
45278                    begin_search_type: KSPEC_BS_INVALID,
45279                    bs: C2RustUnnamed_3 {
45280                        index: C2RustUnnamed_5 { pos: 0 },
45281                    },
45282                    find_keys_type: KSPEC_FK_INVALID,
45283                    fk: C2RustUnnamed_0 {
45284                        range: C2RustUnnamed_2 {
45285                            lastkey: 0,
45286                            keystep: 0,
45287                            limit: 0,
45288                        },
45289                    },
45290                },
45291                num_args: 0,
45292                num_history: 0,
45293                num_tips: 0,
45294                key_specs_num: 0,
45295                key_specs_max: 0,
45296                subcommands_dict: 0 as *const dict as *mut dict,
45297                parent: 0 as *const redisCommand as *mut redisCommand,
45298                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45299            };
45300            init
45301        },
45302        {
45303            let mut init = redisCommand {
45304                declared_name: b"wait\0" as *const u8 as *const libc::c_char,
45305                summary: b"Wait for the synchronous replication of all the write commands sent in the context of the current connection\0"
45306                    as *const u8 as *const libc::c_char,
45307                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
45308                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
45309                doc_flags: 0 as libc::c_int,
45310                replaced_by: 0 as *const libc::c_char,
45311                deprecated_since: 0 as *const libc::c_char,
45312                group: COMMAND_GROUP_GENERIC,
45313                history: 0 as *const commandHistory as *mut commandHistory,
45314                tips: WAIT_tips.as_ptr() as *mut _,
45315                proc_0: Some(waitCommand as unsafe extern "C" fn(*mut client) -> ()),
45316                arity: 3 as libc::c_int,
45317                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
45318                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
45319                    as uint64_t,
45320                key_specs_static: [keySpec {
45321                    notes: 0 as *const libc::c_char,
45322                    flags: 0,
45323                    begin_search_type: KSPEC_BS_INVALID,
45324                    bs: C2RustUnnamed_3 {
45325                        index: C2RustUnnamed_5 { pos: 0 },
45326                    },
45327                    find_keys_type: KSPEC_FK_INVALID,
45328                    fk: C2RustUnnamed_0 {
45329                        range: C2RustUnnamed_2 {
45330                            lastkey: 0,
45331                            keystep: 0,
45332                            limit: 0,
45333                        },
45334                    },
45335                }; 4],
45336                getkeys_proc: None,
45337                subcommands: 0 as *const redisCommand as *mut redisCommand,
45338                args: WAIT_Args.as_ptr() as *mut _,
45339                microseconds: 0,
45340                calls: 0,
45341                rejected_calls: 0,
45342                failed_calls: 0,
45343                id: 0,
45344                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45345                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45346                key_specs: 0 as *const keySpec as *mut keySpec,
45347                legacy_range_key_spec: keySpec {
45348                    notes: 0 as *const libc::c_char,
45349                    flags: 0,
45350                    begin_search_type: KSPEC_BS_INVALID,
45351                    bs: C2RustUnnamed_3 {
45352                        index: C2RustUnnamed_5 { pos: 0 },
45353                    },
45354                    find_keys_type: KSPEC_FK_INVALID,
45355                    fk: C2RustUnnamed_0 {
45356                        range: C2RustUnnamed_2 {
45357                            lastkey: 0,
45358                            keystep: 0,
45359                            limit: 0,
45360                        },
45361                    },
45362                },
45363                num_args: 0,
45364                num_history: 0,
45365                num_tips: 0,
45366                key_specs_num: 0,
45367                key_specs_max: 0,
45368                subcommands_dict: 0 as *const dict as *mut dict,
45369                parent: 0 as *const redisCommand as *mut redisCommand,
45370                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45371            };
45372            init
45373        },
45374        {
45375            let mut init = redisCommand {
45376                declared_name: b"geoadd\0" as *const u8 as *const libc::c_char,
45377                summary: b"Add one or more geospatial items in the geospatial index represented using a sorted set\0"
45378                    as *const u8 as *const libc::c_char,
45379                complexity: b"O(log(N)) for each item added, where N is the number of elements in the sorted set.\0"
45380                    as *const u8 as *const libc::c_char,
45381                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
45382                doc_flags: 0 as libc::c_int,
45383                replaced_by: 0 as *const libc::c_char,
45384                deprecated_since: 0 as *const libc::c_char,
45385                group: COMMAND_GROUP_GEO,
45386                history: GEOADD_History.as_ptr() as *mut _,
45387                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45388                proc_0: Some(geoaddCommand as unsafe extern "C" fn(*mut client) -> ()),
45389                arity: -(5 as libc::c_int),
45390                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45391                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
45392                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
45393                    as uint64_t,
45394                key_specs_static: [
45395                    {
45396                        let mut init = keySpec {
45397                            notes: 0 as *const libc::c_char,
45398                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
45399                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
45400                            begin_search_type: KSPEC_BS_INDEX,
45401                            bs: C2RustUnnamed_3 {
45402                                index: {
45403                                    let mut init = C2RustUnnamed_5 {
45404                                        pos: 1 as libc::c_int,
45405                                    };
45406                                    init
45407                                },
45408                            },
45409                            find_keys_type: KSPEC_FK_RANGE,
45410                            fk: C2RustUnnamed_0 {
45411                                range: {
45412                                    let mut init = C2RustUnnamed_2 {
45413                                        lastkey: 0 as libc::c_int,
45414                                        keystep: 1 as libc::c_int,
45415                                        limit: 0 as libc::c_int,
45416                                    };
45417                                    init
45418                                },
45419                            },
45420                        };
45421                        init
45422                    },
45423                    keySpec {
45424                        notes: 0 as *const libc::c_char,
45425                        flags: 0,
45426                        begin_search_type: KSPEC_BS_INVALID,
45427                        bs: C2RustUnnamed_3 {
45428                            index: C2RustUnnamed_5 { pos: 0 },
45429                        },
45430                        find_keys_type: KSPEC_FK_INVALID,
45431                        fk: C2RustUnnamed_0 {
45432                            range: C2RustUnnamed_2 {
45433                                lastkey: 0,
45434                                keystep: 0,
45435                                limit: 0,
45436                            },
45437                        },
45438                    },
45439                    keySpec {
45440                        notes: 0 as *const libc::c_char,
45441                        flags: 0,
45442                        begin_search_type: KSPEC_BS_INVALID,
45443                        bs: C2RustUnnamed_3 {
45444                            index: C2RustUnnamed_5 { pos: 0 },
45445                        },
45446                        find_keys_type: KSPEC_FK_INVALID,
45447                        fk: C2RustUnnamed_0 {
45448                            range: C2RustUnnamed_2 {
45449                                lastkey: 0,
45450                                keystep: 0,
45451                                limit: 0,
45452                            },
45453                        },
45454                    },
45455                    keySpec {
45456                        notes: 0 as *const libc::c_char,
45457                        flags: 0,
45458                        begin_search_type: KSPEC_BS_INVALID,
45459                        bs: C2RustUnnamed_3 {
45460                            index: C2RustUnnamed_5 { pos: 0 },
45461                        },
45462                        find_keys_type: KSPEC_FK_INVALID,
45463                        fk: C2RustUnnamed_0 {
45464                            range: C2RustUnnamed_2 {
45465                                lastkey: 0,
45466                                keystep: 0,
45467                                limit: 0,
45468                            },
45469                        },
45470                    },
45471                ],
45472                getkeys_proc: None,
45473                subcommands: 0 as *const redisCommand as *mut redisCommand,
45474                args: GEOADD_Args.as_ptr() as *mut _,
45475                microseconds: 0,
45476                calls: 0,
45477                rejected_calls: 0,
45478                failed_calls: 0,
45479                id: 0,
45480                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45481                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45482                key_specs: 0 as *const keySpec as *mut keySpec,
45483                legacy_range_key_spec: keySpec {
45484                    notes: 0 as *const libc::c_char,
45485                    flags: 0,
45486                    begin_search_type: KSPEC_BS_INVALID,
45487                    bs: C2RustUnnamed_3 {
45488                        index: C2RustUnnamed_5 { pos: 0 },
45489                    },
45490                    find_keys_type: KSPEC_FK_INVALID,
45491                    fk: C2RustUnnamed_0 {
45492                        range: C2RustUnnamed_2 {
45493                            lastkey: 0,
45494                            keystep: 0,
45495                            limit: 0,
45496                        },
45497                    },
45498                },
45499                num_args: 0,
45500                num_history: 0,
45501                num_tips: 0,
45502                key_specs_num: 0,
45503                key_specs_max: 0,
45504                subcommands_dict: 0 as *const dict as *mut dict,
45505                parent: 0 as *const redisCommand as *mut redisCommand,
45506                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45507            };
45508            init
45509        },
45510        {
45511            let mut init = redisCommand {
45512                declared_name: b"geodist\0" as *const u8 as *const libc::c_char,
45513                summary: b"Returns the distance between two members of a geospatial index\0"
45514                    as *const u8 as *const libc::c_char,
45515                complexity: b"O(log(N))\0" as *const u8 as *const libc::c_char,
45516                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
45517                doc_flags: 0 as libc::c_int,
45518                replaced_by: 0 as *const libc::c_char,
45519                deprecated_since: 0 as *const libc::c_char,
45520                group: COMMAND_GROUP_GEO,
45521                history: 0 as *const commandHistory as *mut commandHistory,
45522                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45523                proc_0: Some(geodistCommand as unsafe extern "C" fn(*mut client) -> ()),
45524                arity: -(4 as libc::c_int),
45525                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
45526                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
45527                    as uint64_t,
45528                key_specs_static: [
45529                    {
45530                        let mut init = keySpec {
45531                            notes: 0 as *const libc::c_char,
45532                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45533                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
45534                            begin_search_type: KSPEC_BS_INDEX,
45535                            bs: C2RustUnnamed_3 {
45536                                index: {
45537                                    let mut init = C2RustUnnamed_5 {
45538                                        pos: 1 as libc::c_int,
45539                                    };
45540                                    init
45541                                },
45542                            },
45543                            find_keys_type: KSPEC_FK_RANGE,
45544                            fk: C2RustUnnamed_0 {
45545                                range: {
45546                                    let mut init = C2RustUnnamed_2 {
45547                                        lastkey: 0 as libc::c_int,
45548                                        keystep: 1 as libc::c_int,
45549                                        limit: 0 as libc::c_int,
45550                                    };
45551                                    init
45552                                },
45553                            },
45554                        };
45555                        init
45556                    },
45557                    keySpec {
45558                        notes: 0 as *const libc::c_char,
45559                        flags: 0,
45560                        begin_search_type: KSPEC_BS_INVALID,
45561                        bs: C2RustUnnamed_3 {
45562                            index: C2RustUnnamed_5 { pos: 0 },
45563                        },
45564                        find_keys_type: KSPEC_FK_INVALID,
45565                        fk: C2RustUnnamed_0 {
45566                            range: C2RustUnnamed_2 {
45567                                lastkey: 0,
45568                                keystep: 0,
45569                                limit: 0,
45570                            },
45571                        },
45572                    },
45573                    keySpec {
45574                        notes: 0 as *const libc::c_char,
45575                        flags: 0,
45576                        begin_search_type: KSPEC_BS_INVALID,
45577                        bs: C2RustUnnamed_3 {
45578                            index: C2RustUnnamed_5 { pos: 0 },
45579                        },
45580                        find_keys_type: KSPEC_FK_INVALID,
45581                        fk: C2RustUnnamed_0 {
45582                            range: C2RustUnnamed_2 {
45583                                lastkey: 0,
45584                                keystep: 0,
45585                                limit: 0,
45586                            },
45587                        },
45588                    },
45589                    keySpec {
45590                        notes: 0 as *const libc::c_char,
45591                        flags: 0,
45592                        begin_search_type: KSPEC_BS_INVALID,
45593                        bs: C2RustUnnamed_3 {
45594                            index: C2RustUnnamed_5 { pos: 0 },
45595                        },
45596                        find_keys_type: KSPEC_FK_INVALID,
45597                        fk: C2RustUnnamed_0 {
45598                            range: C2RustUnnamed_2 {
45599                                lastkey: 0,
45600                                keystep: 0,
45601                                limit: 0,
45602                            },
45603                        },
45604                    },
45605                ],
45606                getkeys_proc: None,
45607                subcommands: 0 as *const redisCommand as *mut redisCommand,
45608                args: GEODIST_Args.as_ptr() as *mut _,
45609                microseconds: 0,
45610                calls: 0,
45611                rejected_calls: 0,
45612                failed_calls: 0,
45613                id: 0,
45614                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45615                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45616                key_specs: 0 as *const keySpec as *mut keySpec,
45617                legacy_range_key_spec: keySpec {
45618                    notes: 0 as *const libc::c_char,
45619                    flags: 0,
45620                    begin_search_type: KSPEC_BS_INVALID,
45621                    bs: C2RustUnnamed_3 {
45622                        index: C2RustUnnamed_5 { pos: 0 },
45623                    },
45624                    find_keys_type: KSPEC_FK_INVALID,
45625                    fk: C2RustUnnamed_0 {
45626                        range: C2RustUnnamed_2 {
45627                            lastkey: 0,
45628                            keystep: 0,
45629                            limit: 0,
45630                        },
45631                    },
45632                },
45633                num_args: 0,
45634                num_history: 0,
45635                num_tips: 0,
45636                key_specs_num: 0,
45637                key_specs_max: 0,
45638                subcommands_dict: 0 as *const dict as *mut dict,
45639                parent: 0 as *const redisCommand as *mut redisCommand,
45640                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45641            };
45642            init
45643        },
45644        {
45645            let mut init = redisCommand {
45646                declared_name: b"geohash\0" as *const u8 as *const libc::c_char,
45647                summary: b"Returns members of a geospatial index as standard geohash strings\0"
45648                    as *const u8 as *const libc::c_char,
45649                complexity: b"O(log(N)) for each member requested, where N is the number of elements in the sorted set.\0"
45650                    as *const u8 as *const libc::c_char,
45651                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
45652                doc_flags: 0 as libc::c_int,
45653                replaced_by: 0 as *const libc::c_char,
45654                deprecated_since: 0 as *const libc::c_char,
45655                group: COMMAND_GROUP_GEO,
45656                history: 0 as *const commandHistory as *mut commandHistory,
45657                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45658                proc_0: Some(geohashCommand as unsafe extern "C" fn(*mut client) -> ()),
45659                arity: -(2 as libc::c_int),
45660                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
45661                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
45662                    as uint64_t,
45663                key_specs_static: [
45664                    {
45665                        let mut init = keySpec {
45666                            notes: 0 as *const libc::c_char,
45667                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45668                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
45669                            begin_search_type: KSPEC_BS_INDEX,
45670                            bs: C2RustUnnamed_3 {
45671                                index: {
45672                                    let mut init = C2RustUnnamed_5 {
45673                                        pos: 1 as libc::c_int,
45674                                    };
45675                                    init
45676                                },
45677                            },
45678                            find_keys_type: KSPEC_FK_RANGE,
45679                            fk: C2RustUnnamed_0 {
45680                                range: {
45681                                    let mut init = C2RustUnnamed_2 {
45682                                        lastkey: 0 as libc::c_int,
45683                                        keystep: 1 as libc::c_int,
45684                                        limit: 0 as libc::c_int,
45685                                    };
45686                                    init
45687                                },
45688                            },
45689                        };
45690                        init
45691                    },
45692                    keySpec {
45693                        notes: 0 as *const libc::c_char,
45694                        flags: 0,
45695                        begin_search_type: KSPEC_BS_INVALID,
45696                        bs: C2RustUnnamed_3 {
45697                            index: C2RustUnnamed_5 { pos: 0 },
45698                        },
45699                        find_keys_type: KSPEC_FK_INVALID,
45700                        fk: C2RustUnnamed_0 {
45701                            range: C2RustUnnamed_2 {
45702                                lastkey: 0,
45703                                keystep: 0,
45704                                limit: 0,
45705                            },
45706                        },
45707                    },
45708                    keySpec {
45709                        notes: 0 as *const libc::c_char,
45710                        flags: 0,
45711                        begin_search_type: KSPEC_BS_INVALID,
45712                        bs: C2RustUnnamed_3 {
45713                            index: C2RustUnnamed_5 { pos: 0 },
45714                        },
45715                        find_keys_type: KSPEC_FK_INVALID,
45716                        fk: C2RustUnnamed_0 {
45717                            range: C2RustUnnamed_2 {
45718                                lastkey: 0,
45719                                keystep: 0,
45720                                limit: 0,
45721                            },
45722                        },
45723                    },
45724                    keySpec {
45725                        notes: 0 as *const libc::c_char,
45726                        flags: 0,
45727                        begin_search_type: KSPEC_BS_INVALID,
45728                        bs: C2RustUnnamed_3 {
45729                            index: C2RustUnnamed_5 { pos: 0 },
45730                        },
45731                        find_keys_type: KSPEC_FK_INVALID,
45732                        fk: C2RustUnnamed_0 {
45733                            range: C2RustUnnamed_2 {
45734                                lastkey: 0,
45735                                keystep: 0,
45736                                limit: 0,
45737                            },
45738                        },
45739                    },
45740                ],
45741                getkeys_proc: None,
45742                subcommands: 0 as *const redisCommand as *mut redisCommand,
45743                args: GEOHASH_Args.as_ptr() as *mut _,
45744                microseconds: 0,
45745                calls: 0,
45746                rejected_calls: 0,
45747                failed_calls: 0,
45748                id: 0,
45749                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45750                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45751                key_specs: 0 as *const keySpec as *mut keySpec,
45752                legacy_range_key_spec: keySpec {
45753                    notes: 0 as *const libc::c_char,
45754                    flags: 0,
45755                    begin_search_type: KSPEC_BS_INVALID,
45756                    bs: C2RustUnnamed_3 {
45757                        index: C2RustUnnamed_5 { pos: 0 },
45758                    },
45759                    find_keys_type: KSPEC_FK_INVALID,
45760                    fk: C2RustUnnamed_0 {
45761                        range: C2RustUnnamed_2 {
45762                            lastkey: 0,
45763                            keystep: 0,
45764                            limit: 0,
45765                        },
45766                    },
45767                },
45768                num_args: 0,
45769                num_history: 0,
45770                num_tips: 0,
45771                key_specs_num: 0,
45772                key_specs_max: 0,
45773                subcommands_dict: 0 as *const dict as *mut dict,
45774                parent: 0 as *const redisCommand as *mut redisCommand,
45775                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45776            };
45777            init
45778        },
45779        {
45780            let mut init = redisCommand {
45781                declared_name: b"geopos\0" as *const u8 as *const libc::c_char,
45782                summary: b"Returns longitude and latitude of members of a geospatial index\0"
45783                    as *const u8 as *const libc::c_char,
45784                complexity: b"O(N) where N is the number of members requested.\0"
45785                    as *const u8 as *const libc::c_char,
45786                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
45787                doc_flags: 0 as libc::c_int,
45788                replaced_by: 0 as *const libc::c_char,
45789                deprecated_since: 0 as *const libc::c_char,
45790                group: COMMAND_GROUP_GEO,
45791                history: 0 as *const commandHistory as *mut commandHistory,
45792                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45793                proc_0: Some(geoposCommand as unsafe extern "C" fn(*mut client) -> ()),
45794                arity: -(2 as libc::c_int),
45795                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
45796                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
45797                    as uint64_t,
45798                key_specs_static: [
45799                    {
45800                        let mut init = keySpec {
45801                            notes: 0 as *const libc::c_char,
45802                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45803                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
45804                            begin_search_type: KSPEC_BS_INDEX,
45805                            bs: C2RustUnnamed_3 {
45806                                index: {
45807                                    let mut init = C2RustUnnamed_5 {
45808                                        pos: 1 as libc::c_int,
45809                                    };
45810                                    init
45811                                },
45812                            },
45813                            find_keys_type: KSPEC_FK_RANGE,
45814                            fk: C2RustUnnamed_0 {
45815                                range: {
45816                                    let mut init = C2RustUnnamed_2 {
45817                                        lastkey: 0 as libc::c_int,
45818                                        keystep: 1 as libc::c_int,
45819                                        limit: 0 as libc::c_int,
45820                                    };
45821                                    init
45822                                },
45823                            },
45824                        };
45825                        init
45826                    },
45827                    keySpec {
45828                        notes: 0 as *const libc::c_char,
45829                        flags: 0,
45830                        begin_search_type: KSPEC_BS_INVALID,
45831                        bs: C2RustUnnamed_3 {
45832                            index: C2RustUnnamed_5 { pos: 0 },
45833                        },
45834                        find_keys_type: KSPEC_FK_INVALID,
45835                        fk: C2RustUnnamed_0 {
45836                            range: C2RustUnnamed_2 {
45837                                lastkey: 0,
45838                                keystep: 0,
45839                                limit: 0,
45840                            },
45841                        },
45842                    },
45843                    keySpec {
45844                        notes: 0 as *const libc::c_char,
45845                        flags: 0,
45846                        begin_search_type: KSPEC_BS_INVALID,
45847                        bs: C2RustUnnamed_3 {
45848                            index: C2RustUnnamed_5 { pos: 0 },
45849                        },
45850                        find_keys_type: KSPEC_FK_INVALID,
45851                        fk: C2RustUnnamed_0 {
45852                            range: C2RustUnnamed_2 {
45853                                lastkey: 0,
45854                                keystep: 0,
45855                                limit: 0,
45856                            },
45857                        },
45858                    },
45859                    keySpec {
45860                        notes: 0 as *const libc::c_char,
45861                        flags: 0,
45862                        begin_search_type: KSPEC_BS_INVALID,
45863                        bs: C2RustUnnamed_3 {
45864                            index: C2RustUnnamed_5 { pos: 0 },
45865                        },
45866                        find_keys_type: KSPEC_FK_INVALID,
45867                        fk: C2RustUnnamed_0 {
45868                            range: C2RustUnnamed_2 {
45869                                lastkey: 0,
45870                                keystep: 0,
45871                                limit: 0,
45872                            },
45873                        },
45874                    },
45875                ],
45876                getkeys_proc: None,
45877                subcommands: 0 as *const redisCommand as *mut redisCommand,
45878                args: GEOPOS_Args.as_ptr() as *mut _,
45879                microseconds: 0,
45880                calls: 0,
45881                rejected_calls: 0,
45882                failed_calls: 0,
45883                id: 0,
45884                fullname: 0 as *const libc::c_char as *mut libc::c_char,
45885                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
45886                key_specs: 0 as *const keySpec as *mut keySpec,
45887                legacy_range_key_spec: keySpec {
45888                    notes: 0 as *const libc::c_char,
45889                    flags: 0,
45890                    begin_search_type: KSPEC_BS_INVALID,
45891                    bs: C2RustUnnamed_3 {
45892                        index: C2RustUnnamed_5 { pos: 0 },
45893                    },
45894                    find_keys_type: KSPEC_FK_INVALID,
45895                    fk: C2RustUnnamed_0 {
45896                        range: C2RustUnnamed_2 {
45897                            lastkey: 0,
45898                            keystep: 0,
45899                            limit: 0,
45900                        },
45901                    },
45902                },
45903                num_args: 0,
45904                num_history: 0,
45905                num_tips: 0,
45906                key_specs_num: 0,
45907                key_specs_max: 0,
45908                subcommands_dict: 0 as *const dict as *mut dict,
45909                parent: 0 as *const redisCommand as *mut redisCommand,
45910                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
45911            };
45912            init
45913        },
45914        {
45915            let mut init = redisCommand {
45916                declared_name: b"georadius\0" as *const u8 as *const libc::c_char,
45917                summary: b"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point\0"
45918                    as *const u8 as *const libc::c_char,
45919                complexity: b"O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.\0"
45920                    as *const u8 as *const libc::c_char,
45921                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
45922                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
45923                replaced_by: b"`GEOSEARCH` and `GEOSEARCHSTORE` with the `BYRADIUS` argument\0"
45924                    as *const u8 as *const libc::c_char,
45925                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
45926                group: COMMAND_GROUP_GEO,
45927                history: GEORADIUS_History.as_ptr() as *mut _,
45928                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
45929                proc_0: Some(
45930                    georadiusCommand as unsafe extern "C" fn(*mut client) -> (),
45931                ),
45932                arity: -(6 as libc::c_int),
45933                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45934                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
45935                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
45936                    as uint64_t,
45937                key_specs_static: [
45938                    {
45939                        let mut init = keySpec {
45940                            notes: 0 as *const libc::c_char,
45941                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
45942                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
45943                            begin_search_type: KSPEC_BS_INDEX,
45944                            bs: C2RustUnnamed_3 {
45945                                index: {
45946                                    let mut init = C2RustUnnamed_5 {
45947                                        pos: 1 as libc::c_int,
45948                                    };
45949                                    init
45950                                },
45951                            },
45952                            find_keys_type: KSPEC_FK_RANGE,
45953                            fk: C2RustUnnamed_0 {
45954                                range: {
45955                                    let mut init = C2RustUnnamed_2 {
45956                                        lastkey: 0 as libc::c_int,
45957                                        keystep: 1 as libc::c_int,
45958                                        limit: 0 as libc::c_int,
45959                                    };
45960                                    init
45961                                },
45962                            },
45963                        };
45964                        init
45965                    },
45966                    {
45967                        let mut init = keySpec {
45968                            notes: 0 as *const libc::c_char,
45969                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
45970                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
45971                            begin_search_type: KSPEC_BS_KEYWORD,
45972                            bs: C2RustUnnamed_3 {
45973                                keyword: {
45974                                    let mut init = C2RustUnnamed_4 {
45975                                        keyword: b"STORE\0" as *const u8 as *const libc::c_char,
45976                                        startfrom: 6 as libc::c_int,
45977                                    };
45978                                    init
45979                                },
45980                            },
45981                            find_keys_type: KSPEC_FK_RANGE,
45982                            fk: C2RustUnnamed_0 {
45983                                range: {
45984                                    let mut init = C2RustUnnamed_2 {
45985                                        lastkey: 0 as libc::c_int,
45986                                        keystep: 1 as libc::c_int,
45987                                        limit: 0 as libc::c_int,
45988                                    };
45989                                    init
45990                                },
45991                            },
45992                        };
45993                        init
45994                    },
45995                    {
45996                        let mut init = keySpec {
45997                            notes: 0 as *const libc::c_char,
45998                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
45999                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
46000                            begin_search_type: KSPEC_BS_KEYWORD,
46001                            bs: C2RustUnnamed_3 {
46002                                keyword: {
46003                                    let mut init = C2RustUnnamed_4 {
46004                                        keyword: b"STOREDIST\0" as *const u8 as *const libc::c_char,
46005                                        startfrom: 6 as libc::c_int,
46006                                    };
46007                                    init
46008                                },
46009                            },
46010                            find_keys_type: KSPEC_FK_RANGE,
46011                            fk: C2RustUnnamed_0 {
46012                                range: {
46013                                    let mut init = C2RustUnnamed_2 {
46014                                        lastkey: 0 as libc::c_int,
46015                                        keystep: 1 as libc::c_int,
46016                                        limit: 0 as libc::c_int,
46017                                    };
46018                                    init
46019                                },
46020                            },
46021                        };
46022                        init
46023                    },
46024                    keySpec {
46025                        notes: 0 as *const libc::c_char,
46026                        flags: 0,
46027                        begin_search_type: KSPEC_BS_INVALID,
46028                        bs: C2RustUnnamed_3 {
46029                            index: C2RustUnnamed_5 { pos: 0 },
46030                        },
46031                        find_keys_type: KSPEC_FK_INVALID,
46032                        fk: C2RustUnnamed_0 {
46033                            range: C2RustUnnamed_2 {
46034                                lastkey: 0,
46035                                keystep: 0,
46036                                limit: 0,
46037                            },
46038                        },
46039                    },
46040                ],
46041                getkeys_proc: Some(
46042                    georadiusGetKeys
46043                        as unsafe extern "C" fn(
46044                            *mut redisCommand,
46045                            *mut *mut robj,
46046                            libc::c_int,
46047                            *mut getKeysResult,
46048                        ) -> libc::c_int,
46049                ),
46050                subcommands: 0 as *const redisCommand as *mut redisCommand,
46051                args: GEORADIUS_Args.as_ptr() as *mut _,
46052                microseconds: 0,
46053                calls: 0,
46054                rejected_calls: 0,
46055                failed_calls: 0,
46056                id: 0,
46057                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46058                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46059                key_specs: 0 as *const keySpec as *mut keySpec,
46060                legacy_range_key_spec: keySpec {
46061                    notes: 0 as *const libc::c_char,
46062                    flags: 0,
46063                    begin_search_type: KSPEC_BS_INVALID,
46064                    bs: C2RustUnnamed_3 {
46065                        index: C2RustUnnamed_5 { pos: 0 },
46066                    },
46067                    find_keys_type: KSPEC_FK_INVALID,
46068                    fk: C2RustUnnamed_0 {
46069                        range: C2RustUnnamed_2 {
46070                            lastkey: 0,
46071                            keystep: 0,
46072                            limit: 0,
46073                        },
46074                    },
46075                },
46076                num_args: 0,
46077                num_history: 0,
46078                num_tips: 0,
46079                key_specs_num: 0,
46080                key_specs_max: 0,
46081                subcommands_dict: 0 as *const dict as *mut dict,
46082                parent: 0 as *const redisCommand as *mut redisCommand,
46083                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46084            };
46085            init
46086        },
46087        {
46088            let mut init = redisCommand {
46089                declared_name: b"georadiusbymember\0" as *const u8
46090                    as *const libc::c_char,
46091                summary: b"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member\0"
46092                    as *const u8 as *const libc::c_char,
46093                complexity: b"O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.\0"
46094                    as *const u8 as *const libc::c_char,
46095                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
46096                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
46097                replaced_by: b"`GEOSEARCH` and `GEOSEARCHSTORE` with the `BYRADIUS` and `FROMMEMBER` arguments\0"
46098                    as *const u8 as *const libc::c_char,
46099                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
46100                group: COMMAND_GROUP_GEO,
46101                history: GEORADIUSBYMEMBER_History.as_ptr() as *mut _,
46102                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46103                proc_0: Some(
46104                    georadiusbymemberCommand as unsafe extern "C" fn(*mut client) -> (),
46105                ),
46106                arity: -(5 as libc::c_int),
46107                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46108                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
46109                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
46110                    as uint64_t,
46111                key_specs_static: [
46112                    {
46113                        let mut init = keySpec {
46114                            notes: 0 as *const libc::c_char,
46115                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46116                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
46117                            begin_search_type: KSPEC_BS_INDEX,
46118                            bs: C2RustUnnamed_3 {
46119                                index: {
46120                                    let mut init = C2RustUnnamed_5 {
46121                                        pos: 1 as libc::c_int,
46122                                    };
46123                                    init
46124                                },
46125                            },
46126                            find_keys_type: KSPEC_FK_RANGE,
46127                            fk: C2RustUnnamed_0 {
46128                                range: {
46129                                    let mut init = C2RustUnnamed_2 {
46130                                        lastkey: 0 as libc::c_int,
46131                                        keystep: 1 as libc::c_int,
46132                                        limit: 0 as libc::c_int,
46133                                    };
46134                                    init
46135                                },
46136                            },
46137                        };
46138                        init
46139                    },
46140                    {
46141                        let mut init = keySpec {
46142                            notes: 0 as *const libc::c_char,
46143                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
46144                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
46145                            begin_search_type: KSPEC_BS_KEYWORD,
46146                            bs: C2RustUnnamed_3 {
46147                                keyword: {
46148                                    let mut init = C2RustUnnamed_4 {
46149                                        keyword: b"STORE\0" as *const u8 as *const libc::c_char,
46150                                        startfrom: 5 as libc::c_int,
46151                                    };
46152                                    init
46153                                },
46154                            },
46155                            find_keys_type: KSPEC_FK_RANGE,
46156                            fk: C2RustUnnamed_0 {
46157                                range: {
46158                                    let mut init = C2RustUnnamed_2 {
46159                                        lastkey: 0 as libc::c_int,
46160                                        keystep: 1 as libc::c_int,
46161                                        limit: 0 as libc::c_int,
46162                                    };
46163                                    init
46164                                },
46165                            },
46166                        };
46167                        init
46168                    },
46169                    {
46170                        let mut init = keySpec {
46171                            notes: 0 as *const libc::c_char,
46172                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
46173                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
46174                            begin_search_type: KSPEC_BS_KEYWORD,
46175                            bs: C2RustUnnamed_3 {
46176                                keyword: {
46177                                    let mut init = C2RustUnnamed_4 {
46178                                        keyword: b"STOREDIST\0" as *const u8 as *const libc::c_char,
46179                                        startfrom: 5 as libc::c_int,
46180                                    };
46181                                    init
46182                                },
46183                            },
46184                            find_keys_type: KSPEC_FK_RANGE,
46185                            fk: C2RustUnnamed_0 {
46186                                range: {
46187                                    let mut init = C2RustUnnamed_2 {
46188                                        lastkey: 0 as libc::c_int,
46189                                        keystep: 1 as libc::c_int,
46190                                        limit: 0 as libc::c_int,
46191                                    };
46192                                    init
46193                                },
46194                            },
46195                        };
46196                        init
46197                    },
46198                    keySpec {
46199                        notes: 0 as *const libc::c_char,
46200                        flags: 0,
46201                        begin_search_type: KSPEC_BS_INVALID,
46202                        bs: C2RustUnnamed_3 {
46203                            index: C2RustUnnamed_5 { pos: 0 },
46204                        },
46205                        find_keys_type: KSPEC_FK_INVALID,
46206                        fk: C2RustUnnamed_0 {
46207                            range: C2RustUnnamed_2 {
46208                                lastkey: 0,
46209                                keystep: 0,
46210                                limit: 0,
46211                            },
46212                        },
46213                    },
46214                ],
46215                getkeys_proc: Some(
46216                    georadiusGetKeys
46217                        as unsafe extern "C" fn(
46218                            *mut redisCommand,
46219                            *mut *mut robj,
46220                            libc::c_int,
46221                            *mut getKeysResult,
46222                        ) -> libc::c_int,
46223                ),
46224                subcommands: 0 as *const redisCommand as *mut redisCommand,
46225                args: GEORADIUSBYMEMBER_Args.as_ptr() as *mut _,
46226                microseconds: 0,
46227                calls: 0,
46228                rejected_calls: 0,
46229                failed_calls: 0,
46230                id: 0,
46231                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46232                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46233                key_specs: 0 as *const keySpec as *mut keySpec,
46234                legacy_range_key_spec: keySpec {
46235                    notes: 0 as *const libc::c_char,
46236                    flags: 0,
46237                    begin_search_type: KSPEC_BS_INVALID,
46238                    bs: C2RustUnnamed_3 {
46239                        index: C2RustUnnamed_5 { pos: 0 },
46240                    },
46241                    find_keys_type: KSPEC_FK_INVALID,
46242                    fk: C2RustUnnamed_0 {
46243                        range: C2RustUnnamed_2 {
46244                            lastkey: 0,
46245                            keystep: 0,
46246                            limit: 0,
46247                        },
46248                    },
46249                },
46250                num_args: 0,
46251                num_history: 0,
46252                num_tips: 0,
46253                key_specs_num: 0,
46254                key_specs_max: 0,
46255                subcommands_dict: 0 as *const dict as *mut dict,
46256                parent: 0 as *const redisCommand as *mut redisCommand,
46257                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46258            };
46259            init
46260        },
46261        {
46262            let mut init = redisCommand {
46263                declared_name: b"georadiusbymember_ro\0" as *const u8
46264                    as *const libc::c_char,
46265                summary: b"A read-only variant for GEORADIUSBYMEMBER\0" as *const u8
46266                    as *const libc::c_char,
46267                complexity: b"O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.\0"
46268                    as *const u8 as *const libc::c_char,
46269                since: b"3.2.10\0" as *const u8 as *const libc::c_char,
46270                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
46271                replaced_by: b"`GEOSEARCH` with the `BYRADIUS` and `FROMMEMBER` arguments\0"
46272                    as *const u8 as *const libc::c_char,
46273                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
46274                group: COMMAND_GROUP_GEO,
46275                history: 0 as *const commandHistory as *mut commandHistory,
46276                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46277                proc_0: Some(
46278                    georadiusbymemberroCommand as unsafe extern "C" fn(*mut client) -> (),
46279                ),
46280                arity: -(5 as libc::c_int),
46281                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
46282                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
46283                    as uint64_t,
46284                key_specs_static: [
46285                    {
46286                        let mut init = keySpec {
46287                            notes: 0 as *const libc::c_char,
46288                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46289                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
46290                            begin_search_type: KSPEC_BS_INDEX,
46291                            bs: C2RustUnnamed_3 {
46292                                index: {
46293                                    let mut init = C2RustUnnamed_5 {
46294                                        pos: 1 as libc::c_int,
46295                                    };
46296                                    init
46297                                },
46298                            },
46299                            find_keys_type: KSPEC_FK_RANGE,
46300                            fk: C2RustUnnamed_0 {
46301                                range: {
46302                                    let mut init = C2RustUnnamed_2 {
46303                                        lastkey: 0 as libc::c_int,
46304                                        keystep: 1 as libc::c_int,
46305                                        limit: 0 as libc::c_int,
46306                                    };
46307                                    init
46308                                },
46309                            },
46310                        };
46311                        init
46312                    },
46313                    keySpec {
46314                        notes: 0 as *const libc::c_char,
46315                        flags: 0,
46316                        begin_search_type: KSPEC_BS_INVALID,
46317                        bs: C2RustUnnamed_3 {
46318                            index: C2RustUnnamed_5 { pos: 0 },
46319                        },
46320                        find_keys_type: KSPEC_FK_INVALID,
46321                        fk: C2RustUnnamed_0 {
46322                            range: C2RustUnnamed_2 {
46323                                lastkey: 0,
46324                                keystep: 0,
46325                                limit: 0,
46326                            },
46327                        },
46328                    },
46329                    keySpec {
46330                        notes: 0 as *const libc::c_char,
46331                        flags: 0,
46332                        begin_search_type: KSPEC_BS_INVALID,
46333                        bs: C2RustUnnamed_3 {
46334                            index: C2RustUnnamed_5 { pos: 0 },
46335                        },
46336                        find_keys_type: KSPEC_FK_INVALID,
46337                        fk: C2RustUnnamed_0 {
46338                            range: C2RustUnnamed_2 {
46339                                lastkey: 0,
46340                                keystep: 0,
46341                                limit: 0,
46342                            },
46343                        },
46344                    },
46345                    keySpec {
46346                        notes: 0 as *const libc::c_char,
46347                        flags: 0,
46348                        begin_search_type: KSPEC_BS_INVALID,
46349                        bs: C2RustUnnamed_3 {
46350                            index: C2RustUnnamed_5 { pos: 0 },
46351                        },
46352                        find_keys_type: KSPEC_FK_INVALID,
46353                        fk: C2RustUnnamed_0 {
46354                            range: C2RustUnnamed_2 {
46355                                lastkey: 0,
46356                                keystep: 0,
46357                                limit: 0,
46358                            },
46359                        },
46360                    },
46361                ],
46362                getkeys_proc: None,
46363                subcommands: 0 as *const redisCommand as *mut redisCommand,
46364                args: GEORADIUSBYMEMBER_RO_Args.as_ptr() as *mut _,
46365                microseconds: 0,
46366                calls: 0,
46367                rejected_calls: 0,
46368                failed_calls: 0,
46369                id: 0,
46370                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46371                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46372                key_specs: 0 as *const keySpec as *mut keySpec,
46373                legacy_range_key_spec: keySpec {
46374                    notes: 0 as *const libc::c_char,
46375                    flags: 0,
46376                    begin_search_type: KSPEC_BS_INVALID,
46377                    bs: C2RustUnnamed_3 {
46378                        index: C2RustUnnamed_5 { pos: 0 },
46379                    },
46380                    find_keys_type: KSPEC_FK_INVALID,
46381                    fk: C2RustUnnamed_0 {
46382                        range: C2RustUnnamed_2 {
46383                            lastkey: 0,
46384                            keystep: 0,
46385                            limit: 0,
46386                        },
46387                    },
46388                },
46389                num_args: 0,
46390                num_history: 0,
46391                num_tips: 0,
46392                key_specs_num: 0,
46393                key_specs_max: 0,
46394                subcommands_dict: 0 as *const dict as *mut dict,
46395                parent: 0 as *const redisCommand as *mut redisCommand,
46396                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46397            };
46398            init
46399        },
46400        {
46401            let mut init = redisCommand {
46402                declared_name: b"georadius_ro\0" as *const u8 as *const libc::c_char,
46403                summary: b"A read-only variant for GEORADIUS\0" as *const u8
46404                    as *const libc::c_char,
46405                complexity: b"O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.\0"
46406                    as *const u8 as *const libc::c_char,
46407                since: b"3.2.10\0" as *const u8 as *const libc::c_char,
46408                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
46409                replaced_by: b"`GEOSEARCH` with the `BYRADIUS` argument\0" as *const u8
46410                    as *const libc::c_char,
46411                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
46412                group: COMMAND_GROUP_GEO,
46413                history: GEORADIUS_RO_History.as_ptr() as *mut _,
46414                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46415                proc_0: Some(
46416                    georadiusroCommand as unsafe extern "C" fn(*mut client) -> (),
46417                ),
46418                arity: -(6 as libc::c_int),
46419                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
46420                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
46421                    as uint64_t,
46422                key_specs_static: [
46423                    {
46424                        let mut init = keySpec {
46425                            notes: 0 as *const libc::c_char,
46426                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46427                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
46428                            begin_search_type: KSPEC_BS_INDEX,
46429                            bs: C2RustUnnamed_3 {
46430                                index: {
46431                                    let mut init = C2RustUnnamed_5 {
46432                                        pos: 1 as libc::c_int,
46433                                    };
46434                                    init
46435                                },
46436                            },
46437                            find_keys_type: KSPEC_FK_RANGE,
46438                            fk: C2RustUnnamed_0 {
46439                                range: {
46440                                    let mut init = C2RustUnnamed_2 {
46441                                        lastkey: 0 as libc::c_int,
46442                                        keystep: 1 as libc::c_int,
46443                                        limit: 0 as libc::c_int,
46444                                    };
46445                                    init
46446                                },
46447                            },
46448                        };
46449                        init
46450                    },
46451                    keySpec {
46452                        notes: 0 as *const libc::c_char,
46453                        flags: 0,
46454                        begin_search_type: KSPEC_BS_INVALID,
46455                        bs: C2RustUnnamed_3 {
46456                            index: C2RustUnnamed_5 { pos: 0 },
46457                        },
46458                        find_keys_type: KSPEC_FK_INVALID,
46459                        fk: C2RustUnnamed_0 {
46460                            range: C2RustUnnamed_2 {
46461                                lastkey: 0,
46462                                keystep: 0,
46463                                limit: 0,
46464                            },
46465                        },
46466                    },
46467                    keySpec {
46468                        notes: 0 as *const libc::c_char,
46469                        flags: 0,
46470                        begin_search_type: KSPEC_BS_INVALID,
46471                        bs: C2RustUnnamed_3 {
46472                            index: C2RustUnnamed_5 { pos: 0 },
46473                        },
46474                        find_keys_type: KSPEC_FK_INVALID,
46475                        fk: C2RustUnnamed_0 {
46476                            range: C2RustUnnamed_2 {
46477                                lastkey: 0,
46478                                keystep: 0,
46479                                limit: 0,
46480                            },
46481                        },
46482                    },
46483                    keySpec {
46484                        notes: 0 as *const libc::c_char,
46485                        flags: 0,
46486                        begin_search_type: KSPEC_BS_INVALID,
46487                        bs: C2RustUnnamed_3 {
46488                            index: C2RustUnnamed_5 { pos: 0 },
46489                        },
46490                        find_keys_type: KSPEC_FK_INVALID,
46491                        fk: C2RustUnnamed_0 {
46492                            range: C2RustUnnamed_2 {
46493                                lastkey: 0,
46494                                keystep: 0,
46495                                limit: 0,
46496                            },
46497                        },
46498                    },
46499                ],
46500                getkeys_proc: None,
46501                subcommands: 0 as *const redisCommand as *mut redisCommand,
46502                args: GEORADIUS_RO_Args.as_ptr() as *mut _,
46503                microseconds: 0,
46504                calls: 0,
46505                rejected_calls: 0,
46506                failed_calls: 0,
46507                id: 0,
46508                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46509                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46510                key_specs: 0 as *const keySpec as *mut keySpec,
46511                legacy_range_key_spec: keySpec {
46512                    notes: 0 as *const libc::c_char,
46513                    flags: 0,
46514                    begin_search_type: KSPEC_BS_INVALID,
46515                    bs: C2RustUnnamed_3 {
46516                        index: C2RustUnnamed_5 { pos: 0 },
46517                    },
46518                    find_keys_type: KSPEC_FK_INVALID,
46519                    fk: C2RustUnnamed_0 {
46520                        range: C2RustUnnamed_2 {
46521                            lastkey: 0,
46522                            keystep: 0,
46523                            limit: 0,
46524                        },
46525                    },
46526                },
46527                num_args: 0,
46528                num_history: 0,
46529                num_tips: 0,
46530                key_specs_num: 0,
46531                key_specs_max: 0,
46532                subcommands_dict: 0 as *const dict as *mut dict,
46533                parent: 0 as *const redisCommand as *mut redisCommand,
46534                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46535            };
46536            init
46537        },
46538        {
46539            let mut init = redisCommand {
46540                declared_name: b"geosearch\0" as *const u8 as *const libc::c_char,
46541                summary: b"Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.\0"
46542                    as *const u8 as *const libc::c_char,
46543                complexity: b"O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape\0"
46544                    as *const u8 as *const libc::c_char,
46545                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
46546                doc_flags: 0 as libc::c_int,
46547                replaced_by: 0 as *const libc::c_char,
46548                deprecated_since: 0 as *const libc::c_char,
46549                group: COMMAND_GROUP_GEO,
46550                history: GEOSEARCH_History.as_ptr() as *mut _,
46551                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46552                proc_0: Some(
46553                    geosearchCommand as unsafe extern "C" fn(*mut client) -> (),
46554                ),
46555                arity: -(7 as libc::c_int),
46556                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
46557                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
46558                    as uint64_t,
46559                key_specs_static: [
46560                    {
46561                        let mut init = keySpec {
46562                            notes: 0 as *const libc::c_char,
46563                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46564                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
46565                            begin_search_type: KSPEC_BS_INDEX,
46566                            bs: C2RustUnnamed_3 {
46567                                index: {
46568                                    let mut init = C2RustUnnamed_5 {
46569                                        pos: 1 as libc::c_int,
46570                                    };
46571                                    init
46572                                },
46573                            },
46574                            find_keys_type: KSPEC_FK_RANGE,
46575                            fk: C2RustUnnamed_0 {
46576                                range: {
46577                                    let mut init = C2RustUnnamed_2 {
46578                                        lastkey: 0 as libc::c_int,
46579                                        keystep: 1 as libc::c_int,
46580                                        limit: 0 as libc::c_int,
46581                                    };
46582                                    init
46583                                },
46584                            },
46585                        };
46586                        init
46587                    },
46588                    keySpec {
46589                        notes: 0 as *const libc::c_char,
46590                        flags: 0,
46591                        begin_search_type: KSPEC_BS_INVALID,
46592                        bs: C2RustUnnamed_3 {
46593                            index: C2RustUnnamed_5 { pos: 0 },
46594                        },
46595                        find_keys_type: KSPEC_FK_INVALID,
46596                        fk: C2RustUnnamed_0 {
46597                            range: C2RustUnnamed_2 {
46598                                lastkey: 0,
46599                                keystep: 0,
46600                                limit: 0,
46601                            },
46602                        },
46603                    },
46604                    keySpec {
46605                        notes: 0 as *const libc::c_char,
46606                        flags: 0,
46607                        begin_search_type: KSPEC_BS_INVALID,
46608                        bs: C2RustUnnamed_3 {
46609                            index: C2RustUnnamed_5 { pos: 0 },
46610                        },
46611                        find_keys_type: KSPEC_FK_INVALID,
46612                        fk: C2RustUnnamed_0 {
46613                            range: C2RustUnnamed_2 {
46614                                lastkey: 0,
46615                                keystep: 0,
46616                                limit: 0,
46617                            },
46618                        },
46619                    },
46620                    keySpec {
46621                        notes: 0 as *const libc::c_char,
46622                        flags: 0,
46623                        begin_search_type: KSPEC_BS_INVALID,
46624                        bs: C2RustUnnamed_3 {
46625                            index: C2RustUnnamed_5 { pos: 0 },
46626                        },
46627                        find_keys_type: KSPEC_FK_INVALID,
46628                        fk: C2RustUnnamed_0 {
46629                            range: C2RustUnnamed_2 {
46630                                lastkey: 0,
46631                                keystep: 0,
46632                                limit: 0,
46633                            },
46634                        },
46635                    },
46636                ],
46637                getkeys_proc: None,
46638                subcommands: 0 as *const redisCommand as *mut redisCommand,
46639                args: GEOSEARCH_Args.as_ptr() as *mut _,
46640                microseconds: 0,
46641                calls: 0,
46642                rejected_calls: 0,
46643                failed_calls: 0,
46644                id: 0,
46645                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46646                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46647                key_specs: 0 as *const keySpec as *mut keySpec,
46648                legacy_range_key_spec: keySpec {
46649                    notes: 0 as *const libc::c_char,
46650                    flags: 0,
46651                    begin_search_type: KSPEC_BS_INVALID,
46652                    bs: C2RustUnnamed_3 {
46653                        index: C2RustUnnamed_5 { pos: 0 },
46654                    },
46655                    find_keys_type: KSPEC_FK_INVALID,
46656                    fk: C2RustUnnamed_0 {
46657                        range: C2RustUnnamed_2 {
46658                            lastkey: 0,
46659                            keystep: 0,
46660                            limit: 0,
46661                        },
46662                    },
46663                },
46664                num_args: 0,
46665                num_history: 0,
46666                num_tips: 0,
46667                key_specs_num: 0,
46668                key_specs_max: 0,
46669                subcommands_dict: 0 as *const dict as *mut dict,
46670                parent: 0 as *const redisCommand as *mut redisCommand,
46671                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46672            };
46673            init
46674        },
46675        {
46676            let mut init = redisCommand {
46677                declared_name: b"geosearchstore\0" as *const u8 as *const libc::c_char,
46678                summary: b"Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.\0"
46679                    as *const u8 as *const libc::c_char,
46680                complexity: b"O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape\0"
46681                    as *const u8 as *const libc::c_char,
46682                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
46683                doc_flags: 0 as libc::c_int,
46684                replaced_by: 0 as *const libc::c_char,
46685                deprecated_since: 0 as *const libc::c_char,
46686                group: COMMAND_GROUP_GEO,
46687                history: GEOSEARCHSTORE_History.as_ptr() as *mut _,
46688                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46689                proc_0: Some(
46690                    geosearchstoreCommand as unsafe extern "C" fn(*mut client) -> (),
46691                ),
46692                arity: -(8 as libc::c_int),
46693                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46694                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
46695                acl_categories: ((1 as libc::c_ulonglong) << 10 as libc::c_int)
46696                    as uint64_t,
46697                key_specs_static: [
46698                    {
46699                        let mut init = keySpec {
46700                            notes: 0 as *const libc::c_char,
46701                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
46702                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
46703                            begin_search_type: KSPEC_BS_INDEX,
46704                            bs: C2RustUnnamed_3 {
46705                                index: {
46706                                    let mut init = C2RustUnnamed_5 {
46707                                        pos: 1 as libc::c_int,
46708                                    };
46709                                    init
46710                                },
46711                            },
46712                            find_keys_type: KSPEC_FK_RANGE,
46713                            fk: C2RustUnnamed_0 {
46714                                range: {
46715                                    let mut init = C2RustUnnamed_2 {
46716                                        lastkey: 0 as libc::c_int,
46717                                        keystep: 1 as libc::c_int,
46718                                        limit: 0 as libc::c_int,
46719                                    };
46720                                    init
46721                                },
46722                            },
46723                        };
46724                        init
46725                    },
46726                    {
46727                        let mut init = keySpec {
46728                            notes: 0 as *const libc::c_char,
46729                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46730                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
46731                            begin_search_type: KSPEC_BS_INDEX,
46732                            bs: C2RustUnnamed_3 {
46733                                index: {
46734                                    let mut init = C2RustUnnamed_5 {
46735                                        pos: 2 as libc::c_int,
46736                                    };
46737                                    init
46738                                },
46739                            },
46740                            find_keys_type: KSPEC_FK_RANGE,
46741                            fk: C2RustUnnamed_0 {
46742                                range: {
46743                                    let mut init = C2RustUnnamed_2 {
46744                                        lastkey: 0 as libc::c_int,
46745                                        keystep: 1 as libc::c_int,
46746                                        limit: 0 as libc::c_int,
46747                                    };
46748                                    init
46749                                },
46750                            },
46751                        };
46752                        init
46753                    },
46754                    keySpec {
46755                        notes: 0 as *const libc::c_char,
46756                        flags: 0,
46757                        begin_search_type: KSPEC_BS_INVALID,
46758                        bs: C2RustUnnamed_3 {
46759                            index: C2RustUnnamed_5 { pos: 0 },
46760                        },
46761                        find_keys_type: KSPEC_FK_INVALID,
46762                        fk: C2RustUnnamed_0 {
46763                            range: C2RustUnnamed_2 {
46764                                lastkey: 0,
46765                                keystep: 0,
46766                                limit: 0,
46767                            },
46768                        },
46769                    },
46770                    keySpec {
46771                        notes: 0 as *const libc::c_char,
46772                        flags: 0,
46773                        begin_search_type: KSPEC_BS_INVALID,
46774                        bs: C2RustUnnamed_3 {
46775                            index: C2RustUnnamed_5 { pos: 0 },
46776                        },
46777                        find_keys_type: KSPEC_FK_INVALID,
46778                        fk: C2RustUnnamed_0 {
46779                            range: C2RustUnnamed_2 {
46780                                lastkey: 0,
46781                                keystep: 0,
46782                                limit: 0,
46783                            },
46784                        },
46785                    },
46786                ],
46787                getkeys_proc: None,
46788                subcommands: 0 as *const redisCommand as *mut redisCommand,
46789                args: GEOSEARCHSTORE_Args.as_ptr() as *mut _,
46790                microseconds: 0,
46791                calls: 0,
46792                rejected_calls: 0,
46793                failed_calls: 0,
46794                id: 0,
46795                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46796                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46797                key_specs: 0 as *const keySpec as *mut keySpec,
46798                legacy_range_key_spec: keySpec {
46799                    notes: 0 as *const libc::c_char,
46800                    flags: 0,
46801                    begin_search_type: KSPEC_BS_INVALID,
46802                    bs: C2RustUnnamed_3 {
46803                        index: C2RustUnnamed_5 { pos: 0 },
46804                    },
46805                    find_keys_type: KSPEC_FK_INVALID,
46806                    fk: C2RustUnnamed_0 {
46807                        range: C2RustUnnamed_2 {
46808                            lastkey: 0,
46809                            keystep: 0,
46810                            limit: 0,
46811                        },
46812                    },
46813                },
46814                num_args: 0,
46815                num_history: 0,
46816                num_tips: 0,
46817                key_specs_num: 0,
46818                key_specs_max: 0,
46819                subcommands_dict: 0 as *const dict as *mut dict,
46820                parent: 0 as *const redisCommand as *mut redisCommand,
46821                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46822            };
46823            init
46824        },
46825        {
46826            let mut init = redisCommand {
46827                declared_name: b"hdel\0" as *const u8 as *const libc::c_char,
46828                summary: b"Delete one or more hash fields\0" as *const u8
46829                    as *const libc::c_char,
46830                complexity: b"O(N) where N is the number of fields to be removed.\0"
46831                    as *const u8 as *const libc::c_char,
46832                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
46833                doc_flags: 0 as libc::c_int,
46834                replaced_by: 0 as *const libc::c_char,
46835                deprecated_since: 0 as *const libc::c_char,
46836                group: COMMAND_GROUP_HASH,
46837                history: HDEL_History.as_ptr() as *mut _,
46838                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46839                proc_0: Some(hdelCommand as unsafe extern "C" fn(*mut client) -> ()),
46840                arity: -(3 as libc::c_int),
46841                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
46842                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
46843                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
46844                    as uint64_t,
46845                key_specs_static: [
46846                    {
46847                        let mut init = keySpec {
46848                            notes: 0 as *const libc::c_char,
46849                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
46850                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
46851                            begin_search_type: KSPEC_BS_INDEX,
46852                            bs: C2RustUnnamed_3 {
46853                                index: {
46854                                    let mut init = C2RustUnnamed_5 {
46855                                        pos: 1 as libc::c_int,
46856                                    };
46857                                    init
46858                                },
46859                            },
46860                            find_keys_type: KSPEC_FK_RANGE,
46861                            fk: C2RustUnnamed_0 {
46862                                range: {
46863                                    let mut init = C2RustUnnamed_2 {
46864                                        lastkey: 0 as libc::c_int,
46865                                        keystep: 1 as libc::c_int,
46866                                        limit: 0 as libc::c_int,
46867                                    };
46868                                    init
46869                                },
46870                            },
46871                        };
46872                        init
46873                    },
46874                    keySpec {
46875                        notes: 0 as *const libc::c_char,
46876                        flags: 0,
46877                        begin_search_type: KSPEC_BS_INVALID,
46878                        bs: C2RustUnnamed_3 {
46879                            index: C2RustUnnamed_5 { pos: 0 },
46880                        },
46881                        find_keys_type: KSPEC_FK_INVALID,
46882                        fk: C2RustUnnamed_0 {
46883                            range: C2RustUnnamed_2 {
46884                                lastkey: 0,
46885                                keystep: 0,
46886                                limit: 0,
46887                            },
46888                        },
46889                    },
46890                    keySpec {
46891                        notes: 0 as *const libc::c_char,
46892                        flags: 0,
46893                        begin_search_type: KSPEC_BS_INVALID,
46894                        bs: C2RustUnnamed_3 {
46895                            index: C2RustUnnamed_5 { pos: 0 },
46896                        },
46897                        find_keys_type: KSPEC_FK_INVALID,
46898                        fk: C2RustUnnamed_0 {
46899                            range: C2RustUnnamed_2 {
46900                                lastkey: 0,
46901                                keystep: 0,
46902                                limit: 0,
46903                            },
46904                        },
46905                    },
46906                    keySpec {
46907                        notes: 0 as *const libc::c_char,
46908                        flags: 0,
46909                        begin_search_type: KSPEC_BS_INVALID,
46910                        bs: C2RustUnnamed_3 {
46911                            index: C2RustUnnamed_5 { pos: 0 },
46912                        },
46913                        find_keys_type: KSPEC_FK_INVALID,
46914                        fk: C2RustUnnamed_0 {
46915                            range: C2RustUnnamed_2 {
46916                                lastkey: 0,
46917                                keystep: 0,
46918                                limit: 0,
46919                            },
46920                        },
46921                    },
46922                ],
46923                getkeys_proc: None,
46924                subcommands: 0 as *const redisCommand as *mut redisCommand,
46925                args: HDEL_Args.as_ptr() as *mut _,
46926                microseconds: 0,
46927                calls: 0,
46928                rejected_calls: 0,
46929                failed_calls: 0,
46930                id: 0,
46931                fullname: 0 as *const libc::c_char as *mut libc::c_char,
46932                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
46933                key_specs: 0 as *const keySpec as *mut keySpec,
46934                legacy_range_key_spec: keySpec {
46935                    notes: 0 as *const libc::c_char,
46936                    flags: 0,
46937                    begin_search_type: KSPEC_BS_INVALID,
46938                    bs: C2RustUnnamed_3 {
46939                        index: C2RustUnnamed_5 { pos: 0 },
46940                    },
46941                    find_keys_type: KSPEC_FK_INVALID,
46942                    fk: C2RustUnnamed_0 {
46943                        range: C2RustUnnamed_2 {
46944                            lastkey: 0,
46945                            keystep: 0,
46946                            limit: 0,
46947                        },
46948                    },
46949                },
46950                num_args: 0,
46951                num_history: 0,
46952                num_tips: 0,
46953                key_specs_num: 0,
46954                key_specs_max: 0,
46955                subcommands_dict: 0 as *const dict as *mut dict,
46956                parent: 0 as *const redisCommand as *mut redisCommand,
46957                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
46958            };
46959            init
46960        },
46961        {
46962            let mut init = redisCommand {
46963                declared_name: b"hexists\0" as *const u8 as *const libc::c_char,
46964                summary: b"Determine if a hash field exists\0" as *const u8
46965                    as *const libc::c_char,
46966                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
46967                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
46968                doc_flags: 0 as libc::c_int,
46969                replaced_by: 0 as *const libc::c_char,
46970                deprecated_since: 0 as *const libc::c_char,
46971                group: COMMAND_GROUP_HASH,
46972                history: 0 as *const commandHistory as *mut commandHistory,
46973                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
46974                proc_0: Some(hexistsCommand as unsafe extern "C" fn(*mut client) -> ()),
46975                arity: 3 as libc::c_int,
46976                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
46977                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
46978                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
46979                    as uint64_t,
46980                key_specs_static: [
46981                    {
46982                        let mut init = keySpec {
46983                            notes: 0 as *const libc::c_char,
46984                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
46985                                as uint64_t,
46986                            begin_search_type: KSPEC_BS_INDEX,
46987                            bs: C2RustUnnamed_3 {
46988                                index: {
46989                                    let mut init = C2RustUnnamed_5 {
46990                                        pos: 1 as libc::c_int,
46991                                    };
46992                                    init
46993                                },
46994                            },
46995                            find_keys_type: KSPEC_FK_RANGE,
46996                            fk: C2RustUnnamed_0 {
46997                                range: {
46998                                    let mut init = C2RustUnnamed_2 {
46999                                        lastkey: 0 as libc::c_int,
47000                                        keystep: 1 as libc::c_int,
47001                                        limit: 0 as libc::c_int,
47002                                    };
47003                                    init
47004                                },
47005                            },
47006                        };
47007                        init
47008                    },
47009                    keySpec {
47010                        notes: 0 as *const libc::c_char,
47011                        flags: 0,
47012                        begin_search_type: KSPEC_BS_INVALID,
47013                        bs: C2RustUnnamed_3 {
47014                            index: C2RustUnnamed_5 { pos: 0 },
47015                        },
47016                        find_keys_type: KSPEC_FK_INVALID,
47017                        fk: C2RustUnnamed_0 {
47018                            range: C2RustUnnamed_2 {
47019                                lastkey: 0,
47020                                keystep: 0,
47021                                limit: 0,
47022                            },
47023                        },
47024                    },
47025                    keySpec {
47026                        notes: 0 as *const libc::c_char,
47027                        flags: 0,
47028                        begin_search_type: KSPEC_BS_INVALID,
47029                        bs: C2RustUnnamed_3 {
47030                            index: C2RustUnnamed_5 { pos: 0 },
47031                        },
47032                        find_keys_type: KSPEC_FK_INVALID,
47033                        fk: C2RustUnnamed_0 {
47034                            range: C2RustUnnamed_2 {
47035                                lastkey: 0,
47036                                keystep: 0,
47037                                limit: 0,
47038                            },
47039                        },
47040                    },
47041                    keySpec {
47042                        notes: 0 as *const libc::c_char,
47043                        flags: 0,
47044                        begin_search_type: KSPEC_BS_INVALID,
47045                        bs: C2RustUnnamed_3 {
47046                            index: C2RustUnnamed_5 { pos: 0 },
47047                        },
47048                        find_keys_type: KSPEC_FK_INVALID,
47049                        fk: C2RustUnnamed_0 {
47050                            range: C2RustUnnamed_2 {
47051                                lastkey: 0,
47052                                keystep: 0,
47053                                limit: 0,
47054                            },
47055                        },
47056                    },
47057                ],
47058                getkeys_proc: None,
47059                subcommands: 0 as *const redisCommand as *mut redisCommand,
47060                args: HEXISTS_Args.as_ptr() as *mut _,
47061                microseconds: 0,
47062                calls: 0,
47063                rejected_calls: 0,
47064                failed_calls: 0,
47065                id: 0,
47066                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47067                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47068                key_specs: 0 as *const keySpec as *mut keySpec,
47069                legacy_range_key_spec: keySpec {
47070                    notes: 0 as *const libc::c_char,
47071                    flags: 0,
47072                    begin_search_type: KSPEC_BS_INVALID,
47073                    bs: C2RustUnnamed_3 {
47074                        index: C2RustUnnamed_5 { pos: 0 },
47075                    },
47076                    find_keys_type: KSPEC_FK_INVALID,
47077                    fk: C2RustUnnamed_0 {
47078                        range: C2RustUnnamed_2 {
47079                            lastkey: 0,
47080                            keystep: 0,
47081                            limit: 0,
47082                        },
47083                    },
47084                },
47085                num_args: 0,
47086                num_history: 0,
47087                num_tips: 0,
47088                key_specs_num: 0,
47089                key_specs_max: 0,
47090                subcommands_dict: 0 as *const dict as *mut dict,
47091                parent: 0 as *const redisCommand as *mut redisCommand,
47092                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47093            };
47094            init
47095        },
47096        {
47097            let mut init = redisCommand {
47098                declared_name: b"hget\0" as *const u8 as *const libc::c_char,
47099                summary: b"Get the value of a hash field\0" as *const u8
47100                    as *const libc::c_char,
47101                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
47102                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47103                doc_flags: 0 as libc::c_int,
47104                replaced_by: 0 as *const libc::c_char,
47105                deprecated_since: 0 as *const libc::c_char,
47106                group: COMMAND_GROUP_HASH,
47107                history: 0 as *const commandHistory as *mut commandHistory,
47108                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
47109                proc_0: Some(hgetCommand as unsafe extern "C" fn(*mut client) -> ()),
47110                arity: 3 as libc::c_int,
47111                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
47112                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
47113                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47114                    as uint64_t,
47115                key_specs_static: [
47116                    {
47117                        let mut init = keySpec {
47118                            notes: 0 as *const libc::c_char,
47119                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47120                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
47121                            begin_search_type: KSPEC_BS_INDEX,
47122                            bs: C2RustUnnamed_3 {
47123                                index: {
47124                                    let mut init = C2RustUnnamed_5 {
47125                                        pos: 1 as libc::c_int,
47126                                    };
47127                                    init
47128                                },
47129                            },
47130                            find_keys_type: KSPEC_FK_RANGE,
47131                            fk: C2RustUnnamed_0 {
47132                                range: {
47133                                    let mut init = C2RustUnnamed_2 {
47134                                        lastkey: 0 as libc::c_int,
47135                                        keystep: 1 as libc::c_int,
47136                                        limit: 0 as libc::c_int,
47137                                    };
47138                                    init
47139                                },
47140                            },
47141                        };
47142                        init
47143                    },
47144                    keySpec {
47145                        notes: 0 as *const libc::c_char,
47146                        flags: 0,
47147                        begin_search_type: KSPEC_BS_INVALID,
47148                        bs: C2RustUnnamed_3 {
47149                            index: C2RustUnnamed_5 { pos: 0 },
47150                        },
47151                        find_keys_type: KSPEC_FK_INVALID,
47152                        fk: C2RustUnnamed_0 {
47153                            range: C2RustUnnamed_2 {
47154                                lastkey: 0,
47155                                keystep: 0,
47156                                limit: 0,
47157                            },
47158                        },
47159                    },
47160                    keySpec {
47161                        notes: 0 as *const libc::c_char,
47162                        flags: 0,
47163                        begin_search_type: KSPEC_BS_INVALID,
47164                        bs: C2RustUnnamed_3 {
47165                            index: C2RustUnnamed_5 { pos: 0 },
47166                        },
47167                        find_keys_type: KSPEC_FK_INVALID,
47168                        fk: C2RustUnnamed_0 {
47169                            range: C2RustUnnamed_2 {
47170                                lastkey: 0,
47171                                keystep: 0,
47172                                limit: 0,
47173                            },
47174                        },
47175                    },
47176                    keySpec {
47177                        notes: 0 as *const libc::c_char,
47178                        flags: 0,
47179                        begin_search_type: KSPEC_BS_INVALID,
47180                        bs: C2RustUnnamed_3 {
47181                            index: C2RustUnnamed_5 { pos: 0 },
47182                        },
47183                        find_keys_type: KSPEC_FK_INVALID,
47184                        fk: C2RustUnnamed_0 {
47185                            range: C2RustUnnamed_2 {
47186                                lastkey: 0,
47187                                keystep: 0,
47188                                limit: 0,
47189                            },
47190                        },
47191                    },
47192                ],
47193                getkeys_proc: None,
47194                subcommands: 0 as *const redisCommand as *mut redisCommand,
47195                args: HGET_Args.as_ptr() as *mut _,
47196                microseconds: 0,
47197                calls: 0,
47198                rejected_calls: 0,
47199                failed_calls: 0,
47200                id: 0,
47201                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47202                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47203                key_specs: 0 as *const keySpec as *mut keySpec,
47204                legacy_range_key_spec: keySpec {
47205                    notes: 0 as *const libc::c_char,
47206                    flags: 0,
47207                    begin_search_type: KSPEC_BS_INVALID,
47208                    bs: C2RustUnnamed_3 {
47209                        index: C2RustUnnamed_5 { pos: 0 },
47210                    },
47211                    find_keys_type: KSPEC_FK_INVALID,
47212                    fk: C2RustUnnamed_0 {
47213                        range: C2RustUnnamed_2 {
47214                            lastkey: 0,
47215                            keystep: 0,
47216                            limit: 0,
47217                        },
47218                    },
47219                },
47220                num_args: 0,
47221                num_history: 0,
47222                num_tips: 0,
47223                key_specs_num: 0,
47224                key_specs_max: 0,
47225                subcommands_dict: 0 as *const dict as *mut dict,
47226                parent: 0 as *const redisCommand as *mut redisCommand,
47227                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47228            };
47229            init
47230        },
47231        {
47232            let mut init = redisCommand {
47233                declared_name: b"hgetall\0" as *const u8 as *const libc::c_char,
47234                summary: b"Get all the fields and values in a hash\0" as *const u8
47235                    as *const libc::c_char,
47236                complexity: b"O(N) where N is the size of the hash.\0" as *const u8
47237                    as *const libc::c_char,
47238                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47239                doc_flags: 0 as libc::c_int,
47240                replaced_by: 0 as *const libc::c_char,
47241                deprecated_since: 0 as *const libc::c_char,
47242                group: COMMAND_GROUP_HASH,
47243                history: 0 as *const commandHistory as *mut commandHistory,
47244                tips: HGETALL_tips.as_ptr() as *mut _,
47245                proc_0: Some(hgetallCommand as unsafe extern "C" fn(*mut client) -> ()),
47246                arity: 2 as libc::c_int,
47247                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
47248                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47249                    as uint64_t,
47250                key_specs_static: [
47251                    {
47252                        let mut init = keySpec {
47253                            notes: 0 as *const libc::c_char,
47254                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47255                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
47256                            begin_search_type: KSPEC_BS_INDEX,
47257                            bs: C2RustUnnamed_3 {
47258                                index: {
47259                                    let mut init = C2RustUnnamed_5 {
47260                                        pos: 1 as libc::c_int,
47261                                    };
47262                                    init
47263                                },
47264                            },
47265                            find_keys_type: KSPEC_FK_RANGE,
47266                            fk: C2RustUnnamed_0 {
47267                                range: {
47268                                    let mut init = C2RustUnnamed_2 {
47269                                        lastkey: 0 as libc::c_int,
47270                                        keystep: 1 as libc::c_int,
47271                                        limit: 0 as libc::c_int,
47272                                    };
47273                                    init
47274                                },
47275                            },
47276                        };
47277                        init
47278                    },
47279                    keySpec {
47280                        notes: 0 as *const libc::c_char,
47281                        flags: 0,
47282                        begin_search_type: KSPEC_BS_INVALID,
47283                        bs: C2RustUnnamed_3 {
47284                            index: C2RustUnnamed_5 { pos: 0 },
47285                        },
47286                        find_keys_type: KSPEC_FK_INVALID,
47287                        fk: C2RustUnnamed_0 {
47288                            range: C2RustUnnamed_2 {
47289                                lastkey: 0,
47290                                keystep: 0,
47291                                limit: 0,
47292                            },
47293                        },
47294                    },
47295                    keySpec {
47296                        notes: 0 as *const libc::c_char,
47297                        flags: 0,
47298                        begin_search_type: KSPEC_BS_INVALID,
47299                        bs: C2RustUnnamed_3 {
47300                            index: C2RustUnnamed_5 { pos: 0 },
47301                        },
47302                        find_keys_type: KSPEC_FK_INVALID,
47303                        fk: C2RustUnnamed_0 {
47304                            range: C2RustUnnamed_2 {
47305                                lastkey: 0,
47306                                keystep: 0,
47307                                limit: 0,
47308                            },
47309                        },
47310                    },
47311                    keySpec {
47312                        notes: 0 as *const libc::c_char,
47313                        flags: 0,
47314                        begin_search_type: KSPEC_BS_INVALID,
47315                        bs: C2RustUnnamed_3 {
47316                            index: C2RustUnnamed_5 { pos: 0 },
47317                        },
47318                        find_keys_type: KSPEC_FK_INVALID,
47319                        fk: C2RustUnnamed_0 {
47320                            range: C2RustUnnamed_2 {
47321                                lastkey: 0,
47322                                keystep: 0,
47323                                limit: 0,
47324                            },
47325                        },
47326                    },
47327                ],
47328                getkeys_proc: None,
47329                subcommands: 0 as *const redisCommand as *mut redisCommand,
47330                args: HGETALL_Args.as_ptr() as *mut _,
47331                microseconds: 0,
47332                calls: 0,
47333                rejected_calls: 0,
47334                failed_calls: 0,
47335                id: 0,
47336                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47337                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47338                key_specs: 0 as *const keySpec as *mut keySpec,
47339                legacy_range_key_spec: keySpec {
47340                    notes: 0 as *const libc::c_char,
47341                    flags: 0,
47342                    begin_search_type: KSPEC_BS_INVALID,
47343                    bs: C2RustUnnamed_3 {
47344                        index: C2RustUnnamed_5 { pos: 0 },
47345                    },
47346                    find_keys_type: KSPEC_FK_INVALID,
47347                    fk: C2RustUnnamed_0 {
47348                        range: C2RustUnnamed_2 {
47349                            lastkey: 0,
47350                            keystep: 0,
47351                            limit: 0,
47352                        },
47353                    },
47354                },
47355                num_args: 0,
47356                num_history: 0,
47357                num_tips: 0,
47358                key_specs_num: 0,
47359                key_specs_max: 0,
47360                subcommands_dict: 0 as *const dict as *mut dict,
47361                parent: 0 as *const redisCommand as *mut redisCommand,
47362                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47363            };
47364            init
47365        },
47366        {
47367            let mut init = redisCommand {
47368                declared_name: b"hincrby\0" as *const u8 as *const libc::c_char,
47369                summary: b"Increment the integer value of a hash field by the given number\0"
47370                    as *const u8 as *const libc::c_char,
47371                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
47372                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47373                doc_flags: 0 as libc::c_int,
47374                replaced_by: 0 as *const libc::c_char,
47375                deprecated_since: 0 as *const libc::c_char,
47376                group: COMMAND_GROUP_HASH,
47377                history: 0 as *const commandHistory as *mut commandHistory,
47378                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
47379                proc_0: Some(hincrbyCommand as unsafe extern "C" fn(*mut client) -> ()),
47380                arity: 4 as libc::c_int,
47381                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47382                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
47383                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
47384                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47385                    as uint64_t,
47386                key_specs_static: [
47387                    {
47388                        let mut init = keySpec {
47389                            notes: 0 as *const libc::c_char,
47390                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
47391                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
47392                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
47393                            begin_search_type: KSPEC_BS_INDEX,
47394                            bs: C2RustUnnamed_3 {
47395                                index: {
47396                                    let mut init = C2RustUnnamed_5 {
47397                                        pos: 1 as libc::c_int,
47398                                    };
47399                                    init
47400                                },
47401                            },
47402                            find_keys_type: KSPEC_FK_RANGE,
47403                            fk: C2RustUnnamed_0 {
47404                                range: {
47405                                    let mut init = C2RustUnnamed_2 {
47406                                        lastkey: 0 as libc::c_int,
47407                                        keystep: 1 as libc::c_int,
47408                                        limit: 0 as libc::c_int,
47409                                    };
47410                                    init
47411                                },
47412                            },
47413                        };
47414                        init
47415                    },
47416                    keySpec {
47417                        notes: 0 as *const libc::c_char,
47418                        flags: 0,
47419                        begin_search_type: KSPEC_BS_INVALID,
47420                        bs: C2RustUnnamed_3 {
47421                            index: C2RustUnnamed_5 { pos: 0 },
47422                        },
47423                        find_keys_type: KSPEC_FK_INVALID,
47424                        fk: C2RustUnnamed_0 {
47425                            range: C2RustUnnamed_2 {
47426                                lastkey: 0,
47427                                keystep: 0,
47428                                limit: 0,
47429                            },
47430                        },
47431                    },
47432                    keySpec {
47433                        notes: 0 as *const libc::c_char,
47434                        flags: 0,
47435                        begin_search_type: KSPEC_BS_INVALID,
47436                        bs: C2RustUnnamed_3 {
47437                            index: C2RustUnnamed_5 { pos: 0 },
47438                        },
47439                        find_keys_type: KSPEC_FK_INVALID,
47440                        fk: C2RustUnnamed_0 {
47441                            range: C2RustUnnamed_2 {
47442                                lastkey: 0,
47443                                keystep: 0,
47444                                limit: 0,
47445                            },
47446                        },
47447                    },
47448                    keySpec {
47449                        notes: 0 as *const libc::c_char,
47450                        flags: 0,
47451                        begin_search_type: KSPEC_BS_INVALID,
47452                        bs: C2RustUnnamed_3 {
47453                            index: C2RustUnnamed_5 { pos: 0 },
47454                        },
47455                        find_keys_type: KSPEC_FK_INVALID,
47456                        fk: C2RustUnnamed_0 {
47457                            range: C2RustUnnamed_2 {
47458                                lastkey: 0,
47459                                keystep: 0,
47460                                limit: 0,
47461                            },
47462                        },
47463                    },
47464                ],
47465                getkeys_proc: None,
47466                subcommands: 0 as *const redisCommand as *mut redisCommand,
47467                args: HINCRBY_Args.as_ptr() as *mut _,
47468                microseconds: 0,
47469                calls: 0,
47470                rejected_calls: 0,
47471                failed_calls: 0,
47472                id: 0,
47473                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47474                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47475                key_specs: 0 as *const keySpec as *mut keySpec,
47476                legacy_range_key_spec: keySpec {
47477                    notes: 0 as *const libc::c_char,
47478                    flags: 0,
47479                    begin_search_type: KSPEC_BS_INVALID,
47480                    bs: C2RustUnnamed_3 {
47481                        index: C2RustUnnamed_5 { pos: 0 },
47482                    },
47483                    find_keys_type: KSPEC_FK_INVALID,
47484                    fk: C2RustUnnamed_0 {
47485                        range: C2RustUnnamed_2 {
47486                            lastkey: 0,
47487                            keystep: 0,
47488                            limit: 0,
47489                        },
47490                    },
47491                },
47492                num_args: 0,
47493                num_history: 0,
47494                num_tips: 0,
47495                key_specs_num: 0,
47496                key_specs_max: 0,
47497                subcommands_dict: 0 as *const dict as *mut dict,
47498                parent: 0 as *const redisCommand as *mut redisCommand,
47499                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47500            };
47501            init
47502        },
47503        {
47504            let mut init = redisCommand {
47505                declared_name: b"hincrbyfloat\0" as *const u8 as *const libc::c_char,
47506                summary: b"Increment the float value of a hash field by the given amount\0"
47507                    as *const u8 as *const libc::c_char,
47508                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
47509                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
47510                doc_flags: 0 as libc::c_int,
47511                replaced_by: 0 as *const libc::c_char,
47512                deprecated_since: 0 as *const libc::c_char,
47513                group: COMMAND_GROUP_HASH,
47514                history: 0 as *const commandHistory as *mut commandHistory,
47515                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
47516                proc_0: Some(
47517                    hincrbyfloatCommand as unsafe extern "C" fn(*mut client) -> (),
47518                ),
47519                arity: 4 as libc::c_int,
47520                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47521                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
47522                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
47523                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47524                    as uint64_t,
47525                key_specs_static: [
47526                    {
47527                        let mut init = keySpec {
47528                            notes: 0 as *const libc::c_char,
47529                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
47530                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
47531                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
47532                            begin_search_type: KSPEC_BS_INDEX,
47533                            bs: C2RustUnnamed_3 {
47534                                index: {
47535                                    let mut init = C2RustUnnamed_5 {
47536                                        pos: 1 as libc::c_int,
47537                                    };
47538                                    init
47539                                },
47540                            },
47541                            find_keys_type: KSPEC_FK_RANGE,
47542                            fk: C2RustUnnamed_0 {
47543                                range: {
47544                                    let mut init = C2RustUnnamed_2 {
47545                                        lastkey: 0 as libc::c_int,
47546                                        keystep: 1 as libc::c_int,
47547                                        limit: 0 as libc::c_int,
47548                                    };
47549                                    init
47550                                },
47551                            },
47552                        };
47553                        init
47554                    },
47555                    keySpec {
47556                        notes: 0 as *const libc::c_char,
47557                        flags: 0,
47558                        begin_search_type: KSPEC_BS_INVALID,
47559                        bs: C2RustUnnamed_3 {
47560                            index: C2RustUnnamed_5 { pos: 0 },
47561                        },
47562                        find_keys_type: KSPEC_FK_INVALID,
47563                        fk: C2RustUnnamed_0 {
47564                            range: C2RustUnnamed_2 {
47565                                lastkey: 0,
47566                                keystep: 0,
47567                                limit: 0,
47568                            },
47569                        },
47570                    },
47571                    keySpec {
47572                        notes: 0 as *const libc::c_char,
47573                        flags: 0,
47574                        begin_search_type: KSPEC_BS_INVALID,
47575                        bs: C2RustUnnamed_3 {
47576                            index: C2RustUnnamed_5 { pos: 0 },
47577                        },
47578                        find_keys_type: KSPEC_FK_INVALID,
47579                        fk: C2RustUnnamed_0 {
47580                            range: C2RustUnnamed_2 {
47581                                lastkey: 0,
47582                                keystep: 0,
47583                                limit: 0,
47584                            },
47585                        },
47586                    },
47587                    keySpec {
47588                        notes: 0 as *const libc::c_char,
47589                        flags: 0,
47590                        begin_search_type: KSPEC_BS_INVALID,
47591                        bs: C2RustUnnamed_3 {
47592                            index: C2RustUnnamed_5 { pos: 0 },
47593                        },
47594                        find_keys_type: KSPEC_FK_INVALID,
47595                        fk: C2RustUnnamed_0 {
47596                            range: C2RustUnnamed_2 {
47597                                lastkey: 0,
47598                                keystep: 0,
47599                                limit: 0,
47600                            },
47601                        },
47602                    },
47603                ],
47604                getkeys_proc: None,
47605                subcommands: 0 as *const redisCommand as *mut redisCommand,
47606                args: HINCRBYFLOAT_Args.as_ptr() as *mut _,
47607                microseconds: 0,
47608                calls: 0,
47609                rejected_calls: 0,
47610                failed_calls: 0,
47611                id: 0,
47612                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47613                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47614                key_specs: 0 as *const keySpec as *mut keySpec,
47615                legacy_range_key_spec: keySpec {
47616                    notes: 0 as *const libc::c_char,
47617                    flags: 0,
47618                    begin_search_type: KSPEC_BS_INVALID,
47619                    bs: C2RustUnnamed_3 {
47620                        index: C2RustUnnamed_5 { pos: 0 },
47621                    },
47622                    find_keys_type: KSPEC_FK_INVALID,
47623                    fk: C2RustUnnamed_0 {
47624                        range: C2RustUnnamed_2 {
47625                            lastkey: 0,
47626                            keystep: 0,
47627                            limit: 0,
47628                        },
47629                    },
47630                },
47631                num_args: 0,
47632                num_history: 0,
47633                num_tips: 0,
47634                key_specs_num: 0,
47635                key_specs_max: 0,
47636                subcommands_dict: 0 as *const dict as *mut dict,
47637                parent: 0 as *const redisCommand as *mut redisCommand,
47638                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47639            };
47640            init
47641        },
47642        {
47643            let mut init = redisCommand {
47644                declared_name: b"hkeys\0" as *const u8 as *const libc::c_char,
47645                summary: b"Get all the fields in a hash\0" as *const u8
47646                    as *const libc::c_char,
47647                complexity: b"O(N) where N is the size of the hash.\0" as *const u8
47648                    as *const libc::c_char,
47649                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47650                doc_flags: 0 as libc::c_int,
47651                replaced_by: 0 as *const libc::c_char,
47652                deprecated_since: 0 as *const libc::c_char,
47653                group: COMMAND_GROUP_HASH,
47654                history: 0 as *const commandHistory as *mut commandHistory,
47655                tips: HKEYS_tips.as_ptr() as *mut _,
47656                proc_0: Some(hkeysCommand as unsafe extern "C" fn(*mut client) -> ()),
47657                arity: 2 as libc::c_int,
47658                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
47659                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47660                    as uint64_t,
47661                key_specs_static: [
47662                    {
47663                        let mut init = keySpec {
47664                            notes: 0 as *const libc::c_char,
47665                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47666                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
47667                            begin_search_type: KSPEC_BS_INDEX,
47668                            bs: C2RustUnnamed_3 {
47669                                index: {
47670                                    let mut init = C2RustUnnamed_5 {
47671                                        pos: 1 as libc::c_int,
47672                                    };
47673                                    init
47674                                },
47675                            },
47676                            find_keys_type: KSPEC_FK_RANGE,
47677                            fk: C2RustUnnamed_0 {
47678                                range: {
47679                                    let mut init = C2RustUnnamed_2 {
47680                                        lastkey: 0 as libc::c_int,
47681                                        keystep: 1 as libc::c_int,
47682                                        limit: 0 as libc::c_int,
47683                                    };
47684                                    init
47685                                },
47686                            },
47687                        };
47688                        init
47689                    },
47690                    keySpec {
47691                        notes: 0 as *const libc::c_char,
47692                        flags: 0,
47693                        begin_search_type: KSPEC_BS_INVALID,
47694                        bs: C2RustUnnamed_3 {
47695                            index: C2RustUnnamed_5 { pos: 0 },
47696                        },
47697                        find_keys_type: KSPEC_FK_INVALID,
47698                        fk: C2RustUnnamed_0 {
47699                            range: C2RustUnnamed_2 {
47700                                lastkey: 0,
47701                                keystep: 0,
47702                                limit: 0,
47703                            },
47704                        },
47705                    },
47706                    keySpec {
47707                        notes: 0 as *const libc::c_char,
47708                        flags: 0,
47709                        begin_search_type: KSPEC_BS_INVALID,
47710                        bs: C2RustUnnamed_3 {
47711                            index: C2RustUnnamed_5 { pos: 0 },
47712                        },
47713                        find_keys_type: KSPEC_FK_INVALID,
47714                        fk: C2RustUnnamed_0 {
47715                            range: C2RustUnnamed_2 {
47716                                lastkey: 0,
47717                                keystep: 0,
47718                                limit: 0,
47719                            },
47720                        },
47721                    },
47722                    keySpec {
47723                        notes: 0 as *const libc::c_char,
47724                        flags: 0,
47725                        begin_search_type: KSPEC_BS_INVALID,
47726                        bs: C2RustUnnamed_3 {
47727                            index: C2RustUnnamed_5 { pos: 0 },
47728                        },
47729                        find_keys_type: KSPEC_FK_INVALID,
47730                        fk: C2RustUnnamed_0 {
47731                            range: C2RustUnnamed_2 {
47732                                lastkey: 0,
47733                                keystep: 0,
47734                                limit: 0,
47735                            },
47736                        },
47737                    },
47738                ],
47739                getkeys_proc: None,
47740                subcommands: 0 as *const redisCommand as *mut redisCommand,
47741                args: HKEYS_Args.as_ptr() as *mut _,
47742                microseconds: 0,
47743                calls: 0,
47744                rejected_calls: 0,
47745                failed_calls: 0,
47746                id: 0,
47747                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47748                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47749                key_specs: 0 as *const keySpec as *mut keySpec,
47750                legacy_range_key_spec: keySpec {
47751                    notes: 0 as *const libc::c_char,
47752                    flags: 0,
47753                    begin_search_type: KSPEC_BS_INVALID,
47754                    bs: C2RustUnnamed_3 {
47755                        index: C2RustUnnamed_5 { pos: 0 },
47756                    },
47757                    find_keys_type: KSPEC_FK_INVALID,
47758                    fk: C2RustUnnamed_0 {
47759                        range: C2RustUnnamed_2 {
47760                            lastkey: 0,
47761                            keystep: 0,
47762                            limit: 0,
47763                        },
47764                    },
47765                },
47766                num_args: 0,
47767                num_history: 0,
47768                num_tips: 0,
47769                key_specs_num: 0,
47770                key_specs_max: 0,
47771                subcommands_dict: 0 as *const dict as *mut dict,
47772                parent: 0 as *const redisCommand as *mut redisCommand,
47773                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47774            };
47775            init
47776        },
47777        {
47778            let mut init = redisCommand {
47779                declared_name: b"hlen\0" as *const u8 as *const libc::c_char,
47780                summary: b"Get the number of fields in a hash\0" as *const u8
47781                    as *const libc::c_char,
47782                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
47783                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47784                doc_flags: 0 as libc::c_int,
47785                replaced_by: 0 as *const libc::c_char,
47786                deprecated_since: 0 as *const libc::c_char,
47787                group: COMMAND_GROUP_HASH,
47788                history: 0 as *const commandHistory as *mut commandHistory,
47789                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
47790                proc_0: Some(hlenCommand as unsafe extern "C" fn(*mut client) -> ()),
47791                arity: 2 as libc::c_int,
47792                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
47793                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
47794                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47795                    as uint64_t,
47796                key_specs_static: [
47797                    {
47798                        let mut init = keySpec {
47799                            notes: 0 as *const libc::c_char,
47800                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
47801                                as uint64_t,
47802                            begin_search_type: KSPEC_BS_INDEX,
47803                            bs: C2RustUnnamed_3 {
47804                                index: {
47805                                    let mut init = C2RustUnnamed_5 {
47806                                        pos: 1 as libc::c_int,
47807                                    };
47808                                    init
47809                                },
47810                            },
47811                            find_keys_type: KSPEC_FK_RANGE,
47812                            fk: C2RustUnnamed_0 {
47813                                range: {
47814                                    let mut init = C2RustUnnamed_2 {
47815                                        lastkey: 0 as libc::c_int,
47816                                        keystep: 1 as libc::c_int,
47817                                        limit: 0 as libc::c_int,
47818                                    };
47819                                    init
47820                                },
47821                            },
47822                        };
47823                        init
47824                    },
47825                    keySpec {
47826                        notes: 0 as *const libc::c_char,
47827                        flags: 0,
47828                        begin_search_type: KSPEC_BS_INVALID,
47829                        bs: C2RustUnnamed_3 {
47830                            index: C2RustUnnamed_5 { pos: 0 },
47831                        },
47832                        find_keys_type: KSPEC_FK_INVALID,
47833                        fk: C2RustUnnamed_0 {
47834                            range: C2RustUnnamed_2 {
47835                                lastkey: 0,
47836                                keystep: 0,
47837                                limit: 0,
47838                            },
47839                        },
47840                    },
47841                    keySpec {
47842                        notes: 0 as *const libc::c_char,
47843                        flags: 0,
47844                        begin_search_type: KSPEC_BS_INVALID,
47845                        bs: C2RustUnnamed_3 {
47846                            index: C2RustUnnamed_5 { pos: 0 },
47847                        },
47848                        find_keys_type: KSPEC_FK_INVALID,
47849                        fk: C2RustUnnamed_0 {
47850                            range: C2RustUnnamed_2 {
47851                                lastkey: 0,
47852                                keystep: 0,
47853                                limit: 0,
47854                            },
47855                        },
47856                    },
47857                    keySpec {
47858                        notes: 0 as *const libc::c_char,
47859                        flags: 0,
47860                        begin_search_type: KSPEC_BS_INVALID,
47861                        bs: C2RustUnnamed_3 {
47862                            index: C2RustUnnamed_5 { pos: 0 },
47863                        },
47864                        find_keys_type: KSPEC_FK_INVALID,
47865                        fk: C2RustUnnamed_0 {
47866                            range: C2RustUnnamed_2 {
47867                                lastkey: 0,
47868                                keystep: 0,
47869                                limit: 0,
47870                            },
47871                        },
47872                    },
47873                ],
47874                getkeys_proc: None,
47875                subcommands: 0 as *const redisCommand as *mut redisCommand,
47876                args: HLEN_Args.as_ptr() as *mut _,
47877                microseconds: 0,
47878                calls: 0,
47879                rejected_calls: 0,
47880                failed_calls: 0,
47881                id: 0,
47882                fullname: 0 as *const libc::c_char as *mut libc::c_char,
47883                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
47884                key_specs: 0 as *const keySpec as *mut keySpec,
47885                legacy_range_key_spec: keySpec {
47886                    notes: 0 as *const libc::c_char,
47887                    flags: 0,
47888                    begin_search_type: KSPEC_BS_INVALID,
47889                    bs: C2RustUnnamed_3 {
47890                        index: C2RustUnnamed_5 { pos: 0 },
47891                    },
47892                    find_keys_type: KSPEC_FK_INVALID,
47893                    fk: C2RustUnnamed_0 {
47894                        range: C2RustUnnamed_2 {
47895                            lastkey: 0,
47896                            keystep: 0,
47897                            limit: 0,
47898                        },
47899                    },
47900                },
47901                num_args: 0,
47902                num_history: 0,
47903                num_tips: 0,
47904                key_specs_num: 0,
47905                key_specs_max: 0,
47906                subcommands_dict: 0 as *const dict as *mut dict,
47907                parent: 0 as *const redisCommand as *mut redisCommand,
47908                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
47909            };
47910            init
47911        },
47912        {
47913            let mut init = redisCommand {
47914                declared_name: b"hmget\0" as *const u8 as *const libc::c_char,
47915                summary: b"Get the values of all the given hash fields\0" as *const u8
47916                    as *const libc::c_char,
47917                complexity: b"O(N) where N is the number of fields being requested.\0"
47918                    as *const u8 as *const libc::c_char,
47919                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
47920                doc_flags: 0 as libc::c_int,
47921                replaced_by: 0 as *const libc::c_char,
47922                deprecated_since: 0 as *const libc::c_char,
47923                group: COMMAND_GROUP_HASH,
47924                history: 0 as *const commandHistory as *mut commandHistory,
47925                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
47926                proc_0: Some(hmgetCommand as unsafe extern "C" fn(*mut client) -> ()),
47927                arity: -(3 as libc::c_int),
47928                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
47929                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
47930                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
47931                    as uint64_t,
47932                key_specs_static: [
47933                    {
47934                        let mut init = keySpec {
47935                            notes: 0 as *const libc::c_char,
47936                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
47937                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
47938                            begin_search_type: KSPEC_BS_INDEX,
47939                            bs: C2RustUnnamed_3 {
47940                                index: {
47941                                    let mut init = C2RustUnnamed_5 {
47942                                        pos: 1 as libc::c_int,
47943                                    };
47944                                    init
47945                                },
47946                            },
47947                            find_keys_type: KSPEC_FK_RANGE,
47948                            fk: C2RustUnnamed_0 {
47949                                range: {
47950                                    let mut init = C2RustUnnamed_2 {
47951                                        lastkey: 0 as libc::c_int,
47952                                        keystep: 1 as libc::c_int,
47953                                        limit: 0 as libc::c_int,
47954                                    };
47955                                    init
47956                                },
47957                            },
47958                        };
47959                        init
47960                    },
47961                    keySpec {
47962                        notes: 0 as *const libc::c_char,
47963                        flags: 0,
47964                        begin_search_type: KSPEC_BS_INVALID,
47965                        bs: C2RustUnnamed_3 {
47966                            index: C2RustUnnamed_5 { pos: 0 },
47967                        },
47968                        find_keys_type: KSPEC_FK_INVALID,
47969                        fk: C2RustUnnamed_0 {
47970                            range: C2RustUnnamed_2 {
47971                                lastkey: 0,
47972                                keystep: 0,
47973                                limit: 0,
47974                            },
47975                        },
47976                    },
47977                    keySpec {
47978                        notes: 0 as *const libc::c_char,
47979                        flags: 0,
47980                        begin_search_type: KSPEC_BS_INVALID,
47981                        bs: C2RustUnnamed_3 {
47982                            index: C2RustUnnamed_5 { pos: 0 },
47983                        },
47984                        find_keys_type: KSPEC_FK_INVALID,
47985                        fk: C2RustUnnamed_0 {
47986                            range: C2RustUnnamed_2 {
47987                                lastkey: 0,
47988                                keystep: 0,
47989                                limit: 0,
47990                            },
47991                        },
47992                    },
47993                    keySpec {
47994                        notes: 0 as *const libc::c_char,
47995                        flags: 0,
47996                        begin_search_type: KSPEC_BS_INVALID,
47997                        bs: C2RustUnnamed_3 {
47998                            index: C2RustUnnamed_5 { pos: 0 },
47999                        },
48000                        find_keys_type: KSPEC_FK_INVALID,
48001                        fk: C2RustUnnamed_0 {
48002                            range: C2RustUnnamed_2 {
48003                                lastkey: 0,
48004                                keystep: 0,
48005                                limit: 0,
48006                            },
48007                        },
48008                    },
48009                ],
48010                getkeys_proc: None,
48011                subcommands: 0 as *const redisCommand as *mut redisCommand,
48012                args: HMGET_Args.as_ptr() as *mut _,
48013                microseconds: 0,
48014                calls: 0,
48015                rejected_calls: 0,
48016                failed_calls: 0,
48017                id: 0,
48018                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48019                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48020                key_specs: 0 as *const keySpec as *mut keySpec,
48021                legacy_range_key_spec: keySpec {
48022                    notes: 0 as *const libc::c_char,
48023                    flags: 0,
48024                    begin_search_type: KSPEC_BS_INVALID,
48025                    bs: C2RustUnnamed_3 {
48026                        index: C2RustUnnamed_5 { pos: 0 },
48027                    },
48028                    find_keys_type: KSPEC_FK_INVALID,
48029                    fk: C2RustUnnamed_0 {
48030                        range: C2RustUnnamed_2 {
48031                            lastkey: 0,
48032                            keystep: 0,
48033                            limit: 0,
48034                        },
48035                    },
48036                },
48037                num_args: 0,
48038                num_history: 0,
48039                num_tips: 0,
48040                key_specs_num: 0,
48041                key_specs_max: 0,
48042                subcommands_dict: 0 as *const dict as *mut dict,
48043                parent: 0 as *const redisCommand as *mut redisCommand,
48044                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48045            };
48046            init
48047        },
48048        {
48049            let mut init = redisCommand {
48050                declared_name: b"hmset\0" as *const u8 as *const libc::c_char,
48051                summary: b"Set multiple hash fields to multiple values\0" as *const u8
48052                    as *const libc::c_char,
48053                complexity: b"O(N) where N is the number of fields being set.\0"
48054                    as *const u8 as *const libc::c_char,
48055                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
48056                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
48057                replaced_by: b"`HSET` with multiple field-value pairs\0" as *const u8
48058                    as *const libc::c_char,
48059                deprecated_since: b"4.0.0\0" as *const u8 as *const libc::c_char,
48060                group: COMMAND_GROUP_HASH,
48061                history: 0 as *const commandHistory as *mut commandHistory,
48062                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
48063                proc_0: Some(hsetCommand as unsafe extern "C" fn(*mut client) -> ()),
48064                arity: -(4 as libc::c_int),
48065                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48066                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
48067                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
48068                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48069                    as uint64_t,
48070                key_specs_static: [
48071                    {
48072                        let mut init = keySpec {
48073                            notes: 0 as *const libc::c_char,
48074                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
48075                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
48076                            begin_search_type: KSPEC_BS_INDEX,
48077                            bs: C2RustUnnamed_3 {
48078                                index: {
48079                                    let mut init = C2RustUnnamed_5 {
48080                                        pos: 1 as libc::c_int,
48081                                    };
48082                                    init
48083                                },
48084                            },
48085                            find_keys_type: KSPEC_FK_RANGE,
48086                            fk: C2RustUnnamed_0 {
48087                                range: {
48088                                    let mut init = C2RustUnnamed_2 {
48089                                        lastkey: 0 as libc::c_int,
48090                                        keystep: 1 as libc::c_int,
48091                                        limit: 0 as libc::c_int,
48092                                    };
48093                                    init
48094                                },
48095                            },
48096                        };
48097                        init
48098                    },
48099                    keySpec {
48100                        notes: 0 as *const libc::c_char,
48101                        flags: 0,
48102                        begin_search_type: KSPEC_BS_INVALID,
48103                        bs: C2RustUnnamed_3 {
48104                            index: C2RustUnnamed_5 { pos: 0 },
48105                        },
48106                        find_keys_type: KSPEC_FK_INVALID,
48107                        fk: C2RustUnnamed_0 {
48108                            range: C2RustUnnamed_2 {
48109                                lastkey: 0,
48110                                keystep: 0,
48111                                limit: 0,
48112                            },
48113                        },
48114                    },
48115                    keySpec {
48116                        notes: 0 as *const libc::c_char,
48117                        flags: 0,
48118                        begin_search_type: KSPEC_BS_INVALID,
48119                        bs: C2RustUnnamed_3 {
48120                            index: C2RustUnnamed_5 { pos: 0 },
48121                        },
48122                        find_keys_type: KSPEC_FK_INVALID,
48123                        fk: C2RustUnnamed_0 {
48124                            range: C2RustUnnamed_2 {
48125                                lastkey: 0,
48126                                keystep: 0,
48127                                limit: 0,
48128                            },
48129                        },
48130                    },
48131                    keySpec {
48132                        notes: 0 as *const libc::c_char,
48133                        flags: 0,
48134                        begin_search_type: KSPEC_BS_INVALID,
48135                        bs: C2RustUnnamed_3 {
48136                            index: C2RustUnnamed_5 { pos: 0 },
48137                        },
48138                        find_keys_type: KSPEC_FK_INVALID,
48139                        fk: C2RustUnnamed_0 {
48140                            range: C2RustUnnamed_2 {
48141                                lastkey: 0,
48142                                keystep: 0,
48143                                limit: 0,
48144                            },
48145                        },
48146                    },
48147                ],
48148                getkeys_proc: None,
48149                subcommands: 0 as *const redisCommand as *mut redisCommand,
48150                args: HMSET_Args.as_ptr() as *mut _,
48151                microseconds: 0,
48152                calls: 0,
48153                rejected_calls: 0,
48154                failed_calls: 0,
48155                id: 0,
48156                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48157                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48158                key_specs: 0 as *const keySpec as *mut keySpec,
48159                legacy_range_key_spec: keySpec {
48160                    notes: 0 as *const libc::c_char,
48161                    flags: 0,
48162                    begin_search_type: KSPEC_BS_INVALID,
48163                    bs: C2RustUnnamed_3 {
48164                        index: C2RustUnnamed_5 { pos: 0 },
48165                    },
48166                    find_keys_type: KSPEC_FK_INVALID,
48167                    fk: C2RustUnnamed_0 {
48168                        range: C2RustUnnamed_2 {
48169                            lastkey: 0,
48170                            keystep: 0,
48171                            limit: 0,
48172                        },
48173                    },
48174                },
48175                num_args: 0,
48176                num_history: 0,
48177                num_tips: 0,
48178                key_specs_num: 0,
48179                key_specs_max: 0,
48180                subcommands_dict: 0 as *const dict as *mut dict,
48181                parent: 0 as *const redisCommand as *mut redisCommand,
48182                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48183            };
48184            init
48185        },
48186        {
48187            let mut init = redisCommand {
48188                declared_name: b"hrandfield\0" as *const u8 as *const libc::c_char,
48189                summary: b"Get one or multiple random fields from a hash\0" as *const u8
48190                    as *const libc::c_char,
48191                complexity: b"O(N) where N is the number of fields returned\0"
48192                    as *const u8 as *const libc::c_char,
48193                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
48194                doc_flags: 0 as libc::c_int,
48195                replaced_by: 0 as *const libc::c_char,
48196                deprecated_since: 0 as *const libc::c_char,
48197                group: COMMAND_GROUP_HASH,
48198                history: 0 as *const commandHistory as *mut commandHistory,
48199                tips: HRANDFIELD_tips.as_ptr() as *mut _,
48200                proc_0: Some(
48201                    hrandfieldCommand as unsafe extern "C" fn(*mut client) -> (),
48202                ),
48203                arity: -(2 as libc::c_int),
48204                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
48205                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48206                    as uint64_t,
48207                key_specs_static: [
48208                    {
48209                        let mut init = keySpec {
48210                            notes: 0 as *const libc::c_char,
48211                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48212                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
48213                            begin_search_type: KSPEC_BS_INDEX,
48214                            bs: C2RustUnnamed_3 {
48215                                index: {
48216                                    let mut init = C2RustUnnamed_5 {
48217                                        pos: 1 as libc::c_int,
48218                                    };
48219                                    init
48220                                },
48221                            },
48222                            find_keys_type: KSPEC_FK_RANGE,
48223                            fk: C2RustUnnamed_0 {
48224                                range: {
48225                                    let mut init = C2RustUnnamed_2 {
48226                                        lastkey: 0 as libc::c_int,
48227                                        keystep: 1 as libc::c_int,
48228                                        limit: 0 as libc::c_int,
48229                                    };
48230                                    init
48231                                },
48232                            },
48233                        };
48234                        init
48235                    },
48236                    keySpec {
48237                        notes: 0 as *const libc::c_char,
48238                        flags: 0,
48239                        begin_search_type: KSPEC_BS_INVALID,
48240                        bs: C2RustUnnamed_3 {
48241                            index: C2RustUnnamed_5 { pos: 0 },
48242                        },
48243                        find_keys_type: KSPEC_FK_INVALID,
48244                        fk: C2RustUnnamed_0 {
48245                            range: C2RustUnnamed_2 {
48246                                lastkey: 0,
48247                                keystep: 0,
48248                                limit: 0,
48249                            },
48250                        },
48251                    },
48252                    keySpec {
48253                        notes: 0 as *const libc::c_char,
48254                        flags: 0,
48255                        begin_search_type: KSPEC_BS_INVALID,
48256                        bs: C2RustUnnamed_3 {
48257                            index: C2RustUnnamed_5 { pos: 0 },
48258                        },
48259                        find_keys_type: KSPEC_FK_INVALID,
48260                        fk: C2RustUnnamed_0 {
48261                            range: C2RustUnnamed_2 {
48262                                lastkey: 0,
48263                                keystep: 0,
48264                                limit: 0,
48265                            },
48266                        },
48267                    },
48268                    keySpec {
48269                        notes: 0 as *const libc::c_char,
48270                        flags: 0,
48271                        begin_search_type: KSPEC_BS_INVALID,
48272                        bs: C2RustUnnamed_3 {
48273                            index: C2RustUnnamed_5 { pos: 0 },
48274                        },
48275                        find_keys_type: KSPEC_FK_INVALID,
48276                        fk: C2RustUnnamed_0 {
48277                            range: C2RustUnnamed_2 {
48278                                lastkey: 0,
48279                                keystep: 0,
48280                                limit: 0,
48281                            },
48282                        },
48283                    },
48284                ],
48285                getkeys_proc: None,
48286                subcommands: 0 as *const redisCommand as *mut redisCommand,
48287                args: HRANDFIELD_Args.as_ptr() as *mut _,
48288                microseconds: 0,
48289                calls: 0,
48290                rejected_calls: 0,
48291                failed_calls: 0,
48292                id: 0,
48293                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48294                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48295                key_specs: 0 as *const keySpec as *mut keySpec,
48296                legacy_range_key_spec: keySpec {
48297                    notes: 0 as *const libc::c_char,
48298                    flags: 0,
48299                    begin_search_type: KSPEC_BS_INVALID,
48300                    bs: C2RustUnnamed_3 {
48301                        index: C2RustUnnamed_5 { pos: 0 },
48302                    },
48303                    find_keys_type: KSPEC_FK_INVALID,
48304                    fk: C2RustUnnamed_0 {
48305                        range: C2RustUnnamed_2 {
48306                            lastkey: 0,
48307                            keystep: 0,
48308                            limit: 0,
48309                        },
48310                    },
48311                },
48312                num_args: 0,
48313                num_history: 0,
48314                num_tips: 0,
48315                key_specs_num: 0,
48316                key_specs_max: 0,
48317                subcommands_dict: 0 as *const dict as *mut dict,
48318                parent: 0 as *const redisCommand as *mut redisCommand,
48319                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48320            };
48321            init
48322        },
48323        {
48324            let mut init = redisCommand {
48325                declared_name: b"hscan\0" as *const u8 as *const libc::c_char,
48326                summary: b"Incrementally iterate hash fields and associated values\0"
48327                    as *const u8 as *const libc::c_char,
48328                complexity: b"O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..\0"
48329                    as *const u8 as *const libc::c_char,
48330                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
48331                doc_flags: 0 as libc::c_int,
48332                replaced_by: 0 as *const libc::c_char,
48333                deprecated_since: 0 as *const libc::c_char,
48334                group: COMMAND_GROUP_HASH,
48335                history: 0 as *const commandHistory as *mut commandHistory,
48336                tips: HSCAN_tips.as_ptr() as *mut _,
48337                proc_0: Some(hscanCommand as unsafe extern "C" fn(*mut client) -> ()),
48338                arity: -(3 as libc::c_int),
48339                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
48340                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48341                    as uint64_t,
48342                key_specs_static: [
48343                    {
48344                        let mut init = keySpec {
48345                            notes: 0 as *const libc::c_char,
48346                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48347                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
48348                            begin_search_type: KSPEC_BS_INDEX,
48349                            bs: C2RustUnnamed_3 {
48350                                index: {
48351                                    let mut init = C2RustUnnamed_5 {
48352                                        pos: 1 as libc::c_int,
48353                                    };
48354                                    init
48355                                },
48356                            },
48357                            find_keys_type: KSPEC_FK_RANGE,
48358                            fk: C2RustUnnamed_0 {
48359                                range: {
48360                                    let mut init = C2RustUnnamed_2 {
48361                                        lastkey: 0 as libc::c_int,
48362                                        keystep: 1 as libc::c_int,
48363                                        limit: 0 as libc::c_int,
48364                                    };
48365                                    init
48366                                },
48367                            },
48368                        };
48369                        init
48370                    },
48371                    keySpec {
48372                        notes: 0 as *const libc::c_char,
48373                        flags: 0,
48374                        begin_search_type: KSPEC_BS_INVALID,
48375                        bs: C2RustUnnamed_3 {
48376                            index: C2RustUnnamed_5 { pos: 0 },
48377                        },
48378                        find_keys_type: KSPEC_FK_INVALID,
48379                        fk: C2RustUnnamed_0 {
48380                            range: C2RustUnnamed_2 {
48381                                lastkey: 0,
48382                                keystep: 0,
48383                                limit: 0,
48384                            },
48385                        },
48386                    },
48387                    keySpec {
48388                        notes: 0 as *const libc::c_char,
48389                        flags: 0,
48390                        begin_search_type: KSPEC_BS_INVALID,
48391                        bs: C2RustUnnamed_3 {
48392                            index: C2RustUnnamed_5 { pos: 0 },
48393                        },
48394                        find_keys_type: KSPEC_FK_INVALID,
48395                        fk: C2RustUnnamed_0 {
48396                            range: C2RustUnnamed_2 {
48397                                lastkey: 0,
48398                                keystep: 0,
48399                                limit: 0,
48400                            },
48401                        },
48402                    },
48403                    keySpec {
48404                        notes: 0 as *const libc::c_char,
48405                        flags: 0,
48406                        begin_search_type: KSPEC_BS_INVALID,
48407                        bs: C2RustUnnamed_3 {
48408                            index: C2RustUnnamed_5 { pos: 0 },
48409                        },
48410                        find_keys_type: KSPEC_FK_INVALID,
48411                        fk: C2RustUnnamed_0 {
48412                            range: C2RustUnnamed_2 {
48413                                lastkey: 0,
48414                                keystep: 0,
48415                                limit: 0,
48416                            },
48417                        },
48418                    },
48419                ],
48420                getkeys_proc: None,
48421                subcommands: 0 as *const redisCommand as *mut redisCommand,
48422                args: HSCAN_Args.as_ptr() as *mut _,
48423                microseconds: 0,
48424                calls: 0,
48425                rejected_calls: 0,
48426                failed_calls: 0,
48427                id: 0,
48428                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48429                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48430                key_specs: 0 as *const keySpec as *mut keySpec,
48431                legacy_range_key_spec: keySpec {
48432                    notes: 0 as *const libc::c_char,
48433                    flags: 0,
48434                    begin_search_type: KSPEC_BS_INVALID,
48435                    bs: C2RustUnnamed_3 {
48436                        index: C2RustUnnamed_5 { pos: 0 },
48437                    },
48438                    find_keys_type: KSPEC_FK_INVALID,
48439                    fk: C2RustUnnamed_0 {
48440                        range: C2RustUnnamed_2 {
48441                            lastkey: 0,
48442                            keystep: 0,
48443                            limit: 0,
48444                        },
48445                    },
48446                },
48447                num_args: 0,
48448                num_history: 0,
48449                num_tips: 0,
48450                key_specs_num: 0,
48451                key_specs_max: 0,
48452                subcommands_dict: 0 as *const dict as *mut dict,
48453                parent: 0 as *const redisCommand as *mut redisCommand,
48454                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48455            };
48456            init
48457        },
48458        {
48459            let mut init = redisCommand {
48460                declared_name: b"hset\0" as *const u8 as *const libc::c_char,
48461                summary: b"Set the string value of a hash field\0" as *const u8
48462                    as *const libc::c_char,
48463                complexity: b"O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.\0"
48464                    as *const u8 as *const libc::c_char,
48465                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
48466                doc_flags: 0 as libc::c_int,
48467                replaced_by: 0 as *const libc::c_char,
48468                deprecated_since: 0 as *const libc::c_char,
48469                group: COMMAND_GROUP_HASH,
48470                history: HSET_History.as_ptr() as *mut _,
48471                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
48472                proc_0: Some(hsetCommand as unsafe extern "C" fn(*mut client) -> ()),
48473                arity: -(4 as libc::c_int),
48474                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48475                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
48476                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
48477                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48478                    as uint64_t,
48479                key_specs_static: [
48480                    {
48481                        let mut init = keySpec {
48482                            notes: 0 as *const libc::c_char,
48483                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
48484                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
48485                            begin_search_type: KSPEC_BS_INDEX,
48486                            bs: C2RustUnnamed_3 {
48487                                index: {
48488                                    let mut init = C2RustUnnamed_5 {
48489                                        pos: 1 as libc::c_int,
48490                                    };
48491                                    init
48492                                },
48493                            },
48494                            find_keys_type: KSPEC_FK_RANGE,
48495                            fk: C2RustUnnamed_0 {
48496                                range: {
48497                                    let mut init = C2RustUnnamed_2 {
48498                                        lastkey: 0 as libc::c_int,
48499                                        keystep: 1 as libc::c_int,
48500                                        limit: 0 as libc::c_int,
48501                                    };
48502                                    init
48503                                },
48504                            },
48505                        };
48506                        init
48507                    },
48508                    keySpec {
48509                        notes: 0 as *const libc::c_char,
48510                        flags: 0,
48511                        begin_search_type: KSPEC_BS_INVALID,
48512                        bs: C2RustUnnamed_3 {
48513                            index: C2RustUnnamed_5 { pos: 0 },
48514                        },
48515                        find_keys_type: KSPEC_FK_INVALID,
48516                        fk: C2RustUnnamed_0 {
48517                            range: C2RustUnnamed_2 {
48518                                lastkey: 0,
48519                                keystep: 0,
48520                                limit: 0,
48521                            },
48522                        },
48523                    },
48524                    keySpec {
48525                        notes: 0 as *const libc::c_char,
48526                        flags: 0,
48527                        begin_search_type: KSPEC_BS_INVALID,
48528                        bs: C2RustUnnamed_3 {
48529                            index: C2RustUnnamed_5 { pos: 0 },
48530                        },
48531                        find_keys_type: KSPEC_FK_INVALID,
48532                        fk: C2RustUnnamed_0 {
48533                            range: C2RustUnnamed_2 {
48534                                lastkey: 0,
48535                                keystep: 0,
48536                                limit: 0,
48537                            },
48538                        },
48539                    },
48540                    keySpec {
48541                        notes: 0 as *const libc::c_char,
48542                        flags: 0,
48543                        begin_search_type: KSPEC_BS_INVALID,
48544                        bs: C2RustUnnamed_3 {
48545                            index: C2RustUnnamed_5 { pos: 0 },
48546                        },
48547                        find_keys_type: KSPEC_FK_INVALID,
48548                        fk: C2RustUnnamed_0 {
48549                            range: C2RustUnnamed_2 {
48550                                lastkey: 0,
48551                                keystep: 0,
48552                                limit: 0,
48553                            },
48554                        },
48555                    },
48556                ],
48557                getkeys_proc: None,
48558                subcommands: 0 as *const redisCommand as *mut redisCommand,
48559                args: HSET_Args.as_ptr() as *mut _,
48560                microseconds: 0,
48561                calls: 0,
48562                rejected_calls: 0,
48563                failed_calls: 0,
48564                id: 0,
48565                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48566                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48567                key_specs: 0 as *const keySpec as *mut keySpec,
48568                legacy_range_key_spec: keySpec {
48569                    notes: 0 as *const libc::c_char,
48570                    flags: 0,
48571                    begin_search_type: KSPEC_BS_INVALID,
48572                    bs: C2RustUnnamed_3 {
48573                        index: C2RustUnnamed_5 { pos: 0 },
48574                    },
48575                    find_keys_type: KSPEC_FK_INVALID,
48576                    fk: C2RustUnnamed_0 {
48577                        range: C2RustUnnamed_2 {
48578                            lastkey: 0,
48579                            keystep: 0,
48580                            limit: 0,
48581                        },
48582                    },
48583                },
48584                num_args: 0,
48585                num_history: 0,
48586                num_tips: 0,
48587                key_specs_num: 0,
48588                key_specs_max: 0,
48589                subcommands_dict: 0 as *const dict as *mut dict,
48590                parent: 0 as *const redisCommand as *mut redisCommand,
48591                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48592            };
48593            init
48594        },
48595        {
48596            let mut init = redisCommand {
48597                declared_name: b"hsetnx\0" as *const u8 as *const libc::c_char,
48598                summary: b"Set the value of a hash field, only if the field does not exist\0"
48599                    as *const u8 as *const libc::c_char,
48600                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
48601                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
48602                doc_flags: 0 as libc::c_int,
48603                replaced_by: 0 as *const libc::c_char,
48604                deprecated_since: 0 as *const libc::c_char,
48605                group: COMMAND_GROUP_HASH,
48606                history: 0 as *const commandHistory as *mut commandHistory,
48607                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
48608                proc_0: Some(hsetnxCommand as unsafe extern "C" fn(*mut client) -> ()),
48609                arity: 4 as libc::c_int,
48610                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48611                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
48612                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
48613                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48614                    as uint64_t,
48615                key_specs_static: [
48616                    {
48617                        let mut init = keySpec {
48618                            notes: 0 as *const libc::c_char,
48619                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
48620                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
48621                            begin_search_type: KSPEC_BS_INDEX,
48622                            bs: C2RustUnnamed_3 {
48623                                index: {
48624                                    let mut init = C2RustUnnamed_5 {
48625                                        pos: 1 as libc::c_int,
48626                                    };
48627                                    init
48628                                },
48629                            },
48630                            find_keys_type: KSPEC_FK_RANGE,
48631                            fk: C2RustUnnamed_0 {
48632                                range: {
48633                                    let mut init = C2RustUnnamed_2 {
48634                                        lastkey: 0 as libc::c_int,
48635                                        keystep: 1 as libc::c_int,
48636                                        limit: 0 as libc::c_int,
48637                                    };
48638                                    init
48639                                },
48640                            },
48641                        };
48642                        init
48643                    },
48644                    keySpec {
48645                        notes: 0 as *const libc::c_char,
48646                        flags: 0,
48647                        begin_search_type: KSPEC_BS_INVALID,
48648                        bs: C2RustUnnamed_3 {
48649                            index: C2RustUnnamed_5 { pos: 0 },
48650                        },
48651                        find_keys_type: KSPEC_FK_INVALID,
48652                        fk: C2RustUnnamed_0 {
48653                            range: C2RustUnnamed_2 {
48654                                lastkey: 0,
48655                                keystep: 0,
48656                                limit: 0,
48657                            },
48658                        },
48659                    },
48660                    keySpec {
48661                        notes: 0 as *const libc::c_char,
48662                        flags: 0,
48663                        begin_search_type: KSPEC_BS_INVALID,
48664                        bs: C2RustUnnamed_3 {
48665                            index: C2RustUnnamed_5 { pos: 0 },
48666                        },
48667                        find_keys_type: KSPEC_FK_INVALID,
48668                        fk: C2RustUnnamed_0 {
48669                            range: C2RustUnnamed_2 {
48670                                lastkey: 0,
48671                                keystep: 0,
48672                                limit: 0,
48673                            },
48674                        },
48675                    },
48676                    keySpec {
48677                        notes: 0 as *const libc::c_char,
48678                        flags: 0,
48679                        begin_search_type: KSPEC_BS_INVALID,
48680                        bs: C2RustUnnamed_3 {
48681                            index: C2RustUnnamed_5 { pos: 0 },
48682                        },
48683                        find_keys_type: KSPEC_FK_INVALID,
48684                        fk: C2RustUnnamed_0 {
48685                            range: C2RustUnnamed_2 {
48686                                lastkey: 0,
48687                                keystep: 0,
48688                                limit: 0,
48689                            },
48690                        },
48691                    },
48692                ],
48693                getkeys_proc: None,
48694                subcommands: 0 as *const redisCommand as *mut redisCommand,
48695                args: HSETNX_Args.as_ptr() as *mut _,
48696                microseconds: 0,
48697                calls: 0,
48698                rejected_calls: 0,
48699                failed_calls: 0,
48700                id: 0,
48701                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48702                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48703                key_specs: 0 as *const keySpec as *mut keySpec,
48704                legacy_range_key_spec: keySpec {
48705                    notes: 0 as *const libc::c_char,
48706                    flags: 0,
48707                    begin_search_type: KSPEC_BS_INVALID,
48708                    bs: C2RustUnnamed_3 {
48709                        index: C2RustUnnamed_5 { pos: 0 },
48710                    },
48711                    find_keys_type: KSPEC_FK_INVALID,
48712                    fk: C2RustUnnamed_0 {
48713                        range: C2RustUnnamed_2 {
48714                            lastkey: 0,
48715                            keystep: 0,
48716                            limit: 0,
48717                        },
48718                    },
48719                },
48720                num_args: 0,
48721                num_history: 0,
48722                num_tips: 0,
48723                key_specs_num: 0,
48724                key_specs_max: 0,
48725                subcommands_dict: 0 as *const dict as *mut dict,
48726                parent: 0 as *const redisCommand as *mut redisCommand,
48727                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48728            };
48729            init
48730        },
48731        {
48732            let mut init = redisCommand {
48733                declared_name: b"hstrlen\0" as *const u8 as *const libc::c_char,
48734                summary: b"Get the length of the value of a hash field\0" as *const u8
48735                    as *const libc::c_char,
48736                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
48737                since: b"3.2.0\0" as *const u8 as *const libc::c_char,
48738                doc_flags: 0 as libc::c_int,
48739                replaced_by: 0 as *const libc::c_char,
48740                deprecated_since: 0 as *const libc::c_char,
48741                group: COMMAND_GROUP_HASH,
48742                history: 0 as *const commandHistory as *mut commandHistory,
48743                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
48744                proc_0: Some(hstrlenCommand as unsafe extern "C" fn(*mut client) -> ()),
48745                arity: 3 as libc::c_int,
48746                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
48747                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
48748                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48749                    as uint64_t,
48750                key_specs_static: [
48751                    {
48752                        let mut init = keySpec {
48753                            notes: 0 as *const libc::c_char,
48754                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
48755                                as uint64_t,
48756                            begin_search_type: KSPEC_BS_INDEX,
48757                            bs: C2RustUnnamed_3 {
48758                                index: {
48759                                    let mut init = C2RustUnnamed_5 {
48760                                        pos: 1 as libc::c_int,
48761                                    };
48762                                    init
48763                                },
48764                            },
48765                            find_keys_type: KSPEC_FK_RANGE,
48766                            fk: C2RustUnnamed_0 {
48767                                range: {
48768                                    let mut init = C2RustUnnamed_2 {
48769                                        lastkey: 0 as libc::c_int,
48770                                        keystep: 1 as libc::c_int,
48771                                        limit: 0 as libc::c_int,
48772                                    };
48773                                    init
48774                                },
48775                            },
48776                        };
48777                        init
48778                    },
48779                    keySpec {
48780                        notes: 0 as *const libc::c_char,
48781                        flags: 0,
48782                        begin_search_type: KSPEC_BS_INVALID,
48783                        bs: C2RustUnnamed_3 {
48784                            index: C2RustUnnamed_5 { pos: 0 },
48785                        },
48786                        find_keys_type: KSPEC_FK_INVALID,
48787                        fk: C2RustUnnamed_0 {
48788                            range: C2RustUnnamed_2 {
48789                                lastkey: 0,
48790                                keystep: 0,
48791                                limit: 0,
48792                            },
48793                        },
48794                    },
48795                    keySpec {
48796                        notes: 0 as *const libc::c_char,
48797                        flags: 0,
48798                        begin_search_type: KSPEC_BS_INVALID,
48799                        bs: C2RustUnnamed_3 {
48800                            index: C2RustUnnamed_5 { pos: 0 },
48801                        },
48802                        find_keys_type: KSPEC_FK_INVALID,
48803                        fk: C2RustUnnamed_0 {
48804                            range: C2RustUnnamed_2 {
48805                                lastkey: 0,
48806                                keystep: 0,
48807                                limit: 0,
48808                            },
48809                        },
48810                    },
48811                    keySpec {
48812                        notes: 0 as *const libc::c_char,
48813                        flags: 0,
48814                        begin_search_type: KSPEC_BS_INVALID,
48815                        bs: C2RustUnnamed_3 {
48816                            index: C2RustUnnamed_5 { pos: 0 },
48817                        },
48818                        find_keys_type: KSPEC_FK_INVALID,
48819                        fk: C2RustUnnamed_0 {
48820                            range: C2RustUnnamed_2 {
48821                                lastkey: 0,
48822                                keystep: 0,
48823                                limit: 0,
48824                            },
48825                        },
48826                    },
48827                ],
48828                getkeys_proc: None,
48829                subcommands: 0 as *const redisCommand as *mut redisCommand,
48830                args: HSTRLEN_Args.as_ptr() as *mut _,
48831                microseconds: 0,
48832                calls: 0,
48833                rejected_calls: 0,
48834                failed_calls: 0,
48835                id: 0,
48836                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48837                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48838                key_specs: 0 as *const keySpec as *mut keySpec,
48839                legacy_range_key_spec: keySpec {
48840                    notes: 0 as *const libc::c_char,
48841                    flags: 0,
48842                    begin_search_type: KSPEC_BS_INVALID,
48843                    bs: C2RustUnnamed_3 {
48844                        index: C2RustUnnamed_5 { pos: 0 },
48845                    },
48846                    find_keys_type: KSPEC_FK_INVALID,
48847                    fk: C2RustUnnamed_0 {
48848                        range: C2RustUnnamed_2 {
48849                            lastkey: 0,
48850                            keystep: 0,
48851                            limit: 0,
48852                        },
48853                    },
48854                },
48855                num_args: 0,
48856                num_history: 0,
48857                num_tips: 0,
48858                key_specs_num: 0,
48859                key_specs_max: 0,
48860                subcommands_dict: 0 as *const dict as *mut dict,
48861                parent: 0 as *const redisCommand as *mut redisCommand,
48862                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48863            };
48864            init
48865        },
48866        {
48867            let mut init = redisCommand {
48868                declared_name: b"hvals\0" as *const u8 as *const libc::c_char,
48869                summary: b"Get all the values in a hash\0" as *const u8
48870                    as *const libc::c_char,
48871                complexity: b"O(N) where N is the size of the hash.\0" as *const u8
48872                    as *const libc::c_char,
48873                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
48874                doc_flags: 0 as libc::c_int,
48875                replaced_by: 0 as *const libc::c_char,
48876                deprecated_since: 0 as *const libc::c_char,
48877                group: COMMAND_GROUP_HASH,
48878                history: 0 as *const commandHistory as *mut commandHistory,
48879                tips: HVALS_tips.as_ptr() as *mut _,
48880                proc_0: Some(hvalsCommand as unsafe extern "C" fn(*mut client) -> ()),
48881                arity: 2 as libc::c_int,
48882                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
48883                acl_categories: ((1 as libc::c_ulonglong) << 6 as libc::c_int)
48884                    as uint64_t,
48885                key_specs_static: [
48886                    {
48887                        let mut init = keySpec {
48888                            notes: 0 as *const libc::c_char,
48889                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
48890                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
48891                            begin_search_type: KSPEC_BS_INDEX,
48892                            bs: C2RustUnnamed_3 {
48893                                index: {
48894                                    let mut init = C2RustUnnamed_5 {
48895                                        pos: 1 as libc::c_int,
48896                                    };
48897                                    init
48898                                },
48899                            },
48900                            find_keys_type: KSPEC_FK_RANGE,
48901                            fk: C2RustUnnamed_0 {
48902                                range: {
48903                                    let mut init = C2RustUnnamed_2 {
48904                                        lastkey: 0 as libc::c_int,
48905                                        keystep: 1 as libc::c_int,
48906                                        limit: 0 as libc::c_int,
48907                                    };
48908                                    init
48909                                },
48910                            },
48911                        };
48912                        init
48913                    },
48914                    keySpec {
48915                        notes: 0 as *const libc::c_char,
48916                        flags: 0,
48917                        begin_search_type: KSPEC_BS_INVALID,
48918                        bs: C2RustUnnamed_3 {
48919                            index: C2RustUnnamed_5 { pos: 0 },
48920                        },
48921                        find_keys_type: KSPEC_FK_INVALID,
48922                        fk: C2RustUnnamed_0 {
48923                            range: C2RustUnnamed_2 {
48924                                lastkey: 0,
48925                                keystep: 0,
48926                                limit: 0,
48927                            },
48928                        },
48929                    },
48930                    keySpec {
48931                        notes: 0 as *const libc::c_char,
48932                        flags: 0,
48933                        begin_search_type: KSPEC_BS_INVALID,
48934                        bs: C2RustUnnamed_3 {
48935                            index: C2RustUnnamed_5 { pos: 0 },
48936                        },
48937                        find_keys_type: KSPEC_FK_INVALID,
48938                        fk: C2RustUnnamed_0 {
48939                            range: C2RustUnnamed_2 {
48940                                lastkey: 0,
48941                                keystep: 0,
48942                                limit: 0,
48943                            },
48944                        },
48945                    },
48946                    keySpec {
48947                        notes: 0 as *const libc::c_char,
48948                        flags: 0,
48949                        begin_search_type: KSPEC_BS_INVALID,
48950                        bs: C2RustUnnamed_3 {
48951                            index: C2RustUnnamed_5 { pos: 0 },
48952                        },
48953                        find_keys_type: KSPEC_FK_INVALID,
48954                        fk: C2RustUnnamed_0 {
48955                            range: C2RustUnnamed_2 {
48956                                lastkey: 0,
48957                                keystep: 0,
48958                                limit: 0,
48959                            },
48960                        },
48961                    },
48962                ],
48963                getkeys_proc: None,
48964                subcommands: 0 as *const redisCommand as *mut redisCommand,
48965                args: HVALS_Args.as_ptr() as *mut _,
48966                microseconds: 0,
48967                calls: 0,
48968                rejected_calls: 0,
48969                failed_calls: 0,
48970                id: 0,
48971                fullname: 0 as *const libc::c_char as *mut libc::c_char,
48972                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
48973                key_specs: 0 as *const keySpec as *mut keySpec,
48974                legacy_range_key_spec: keySpec {
48975                    notes: 0 as *const libc::c_char,
48976                    flags: 0,
48977                    begin_search_type: KSPEC_BS_INVALID,
48978                    bs: C2RustUnnamed_3 {
48979                        index: C2RustUnnamed_5 { pos: 0 },
48980                    },
48981                    find_keys_type: KSPEC_FK_INVALID,
48982                    fk: C2RustUnnamed_0 {
48983                        range: C2RustUnnamed_2 {
48984                            lastkey: 0,
48985                            keystep: 0,
48986                            limit: 0,
48987                        },
48988                    },
48989                },
48990                num_args: 0,
48991                num_history: 0,
48992                num_tips: 0,
48993                key_specs_num: 0,
48994                key_specs_max: 0,
48995                subcommands_dict: 0 as *const dict as *mut dict,
48996                parent: 0 as *const redisCommand as *mut redisCommand,
48997                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
48998            };
48999            init
49000        },
49001        {
49002            let mut init = redisCommand {
49003                declared_name: b"pfadd\0" as *const u8 as *const libc::c_char,
49004                summary: b"Adds the specified elements to the specified HyperLogLog.\0"
49005                    as *const u8 as *const libc::c_char,
49006                complexity: b"O(1) to add every element.\0" as *const u8
49007                    as *const libc::c_char,
49008                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
49009                doc_flags: 0 as libc::c_int,
49010                replaced_by: 0 as *const libc::c_char,
49011                deprecated_since: 0 as *const libc::c_char,
49012                group: COMMAND_GROUP_HYPERLOGLOG,
49013                history: 0 as *const commandHistory as *mut commandHistory,
49014                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49015                proc_0: Some(pfaddCommand as unsafe extern "C" fn(*mut client) -> ()),
49016                arity: -(2 as libc::c_int),
49017                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49018                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
49019                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
49020                acl_categories: ((1 as libc::c_ulonglong) << 9 as libc::c_int)
49021                    as uint64_t,
49022                key_specs_static: [
49023                    {
49024                        let mut init = keySpec {
49025                            notes: 0 as *const libc::c_char,
49026                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49027                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
49028                            begin_search_type: KSPEC_BS_INDEX,
49029                            bs: C2RustUnnamed_3 {
49030                                index: {
49031                                    let mut init = C2RustUnnamed_5 {
49032                                        pos: 1 as libc::c_int,
49033                                    };
49034                                    init
49035                                },
49036                            },
49037                            find_keys_type: KSPEC_FK_RANGE,
49038                            fk: C2RustUnnamed_0 {
49039                                range: {
49040                                    let mut init = C2RustUnnamed_2 {
49041                                        lastkey: 0 as libc::c_int,
49042                                        keystep: 1 as libc::c_int,
49043                                        limit: 0 as libc::c_int,
49044                                    };
49045                                    init
49046                                },
49047                            },
49048                        };
49049                        init
49050                    },
49051                    keySpec {
49052                        notes: 0 as *const libc::c_char,
49053                        flags: 0,
49054                        begin_search_type: KSPEC_BS_INVALID,
49055                        bs: C2RustUnnamed_3 {
49056                            index: C2RustUnnamed_5 { pos: 0 },
49057                        },
49058                        find_keys_type: KSPEC_FK_INVALID,
49059                        fk: C2RustUnnamed_0 {
49060                            range: C2RustUnnamed_2 {
49061                                lastkey: 0,
49062                                keystep: 0,
49063                                limit: 0,
49064                            },
49065                        },
49066                    },
49067                    keySpec {
49068                        notes: 0 as *const libc::c_char,
49069                        flags: 0,
49070                        begin_search_type: KSPEC_BS_INVALID,
49071                        bs: C2RustUnnamed_3 {
49072                            index: C2RustUnnamed_5 { pos: 0 },
49073                        },
49074                        find_keys_type: KSPEC_FK_INVALID,
49075                        fk: C2RustUnnamed_0 {
49076                            range: C2RustUnnamed_2 {
49077                                lastkey: 0,
49078                                keystep: 0,
49079                                limit: 0,
49080                            },
49081                        },
49082                    },
49083                    keySpec {
49084                        notes: 0 as *const libc::c_char,
49085                        flags: 0,
49086                        begin_search_type: KSPEC_BS_INVALID,
49087                        bs: C2RustUnnamed_3 {
49088                            index: C2RustUnnamed_5 { pos: 0 },
49089                        },
49090                        find_keys_type: KSPEC_FK_INVALID,
49091                        fk: C2RustUnnamed_0 {
49092                            range: C2RustUnnamed_2 {
49093                                lastkey: 0,
49094                                keystep: 0,
49095                                limit: 0,
49096                            },
49097                        },
49098                    },
49099                ],
49100                getkeys_proc: None,
49101                subcommands: 0 as *const redisCommand as *mut redisCommand,
49102                args: PFADD_Args.as_ptr() as *mut _,
49103                microseconds: 0,
49104                calls: 0,
49105                rejected_calls: 0,
49106                failed_calls: 0,
49107                id: 0,
49108                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49109                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49110                key_specs: 0 as *const keySpec as *mut keySpec,
49111                legacy_range_key_spec: keySpec {
49112                    notes: 0 as *const libc::c_char,
49113                    flags: 0,
49114                    begin_search_type: KSPEC_BS_INVALID,
49115                    bs: C2RustUnnamed_3 {
49116                        index: C2RustUnnamed_5 { pos: 0 },
49117                    },
49118                    find_keys_type: KSPEC_FK_INVALID,
49119                    fk: C2RustUnnamed_0 {
49120                        range: C2RustUnnamed_2 {
49121                            lastkey: 0,
49122                            keystep: 0,
49123                            limit: 0,
49124                        },
49125                    },
49126                },
49127                num_args: 0,
49128                num_history: 0,
49129                num_tips: 0,
49130                key_specs_num: 0,
49131                key_specs_max: 0,
49132                subcommands_dict: 0 as *const dict as *mut dict,
49133                parent: 0 as *const redisCommand as *mut redisCommand,
49134                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49135            };
49136            init
49137        },
49138        {
49139            let mut init = redisCommand {
49140                declared_name: b"pfcount\0" as *const u8 as *const libc::c_char,
49141                summary: b"Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).\0"
49142                    as *const u8 as *const libc::c_char,
49143                complexity: b"O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.\0"
49144                    as *const u8 as *const libc::c_char,
49145                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
49146                doc_flags: 0 as libc::c_int,
49147                replaced_by: 0 as *const libc::c_char,
49148                deprecated_since: 0 as *const libc::c_char,
49149                group: COMMAND_GROUP_HYPERLOGLOG,
49150                history: 0 as *const commandHistory as *mut commandHistory,
49151                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49152                proc_0: Some(pfcountCommand as unsafe extern "C" fn(*mut client) -> ()),
49153                arity: -(2 as libc::c_int),
49154                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49155                    | (1 as libc::c_ulonglong) << 16 as libc::c_int) as uint64_t,
49156                acl_categories: ((1 as libc::c_ulonglong) << 9 as libc::c_int)
49157                    as uint64_t,
49158                key_specs_static: [
49159                    {
49160                        let mut init = keySpec {
49161                            notes: b"RW because it may change the internal representation of the key, and propagate to replicas\0"
49162                                as *const u8 as *const libc::c_char,
49163                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49164                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
49165                            begin_search_type: KSPEC_BS_INDEX,
49166                            bs: C2RustUnnamed_3 {
49167                                index: {
49168                                    let mut init = C2RustUnnamed_5 {
49169                                        pos: 1 as libc::c_int,
49170                                    };
49171                                    init
49172                                },
49173                            },
49174                            find_keys_type: KSPEC_FK_RANGE,
49175                            fk: C2RustUnnamed_0 {
49176                                range: {
49177                                    let mut init = C2RustUnnamed_2 {
49178                                        lastkey: -(1 as libc::c_int),
49179                                        keystep: 1 as libc::c_int,
49180                                        limit: 0 as libc::c_int,
49181                                    };
49182                                    init
49183                                },
49184                            },
49185                        };
49186                        init
49187                    },
49188                    keySpec {
49189                        notes: 0 as *const libc::c_char,
49190                        flags: 0,
49191                        begin_search_type: KSPEC_BS_INVALID,
49192                        bs: C2RustUnnamed_3 {
49193                            index: C2RustUnnamed_5 { pos: 0 },
49194                        },
49195                        find_keys_type: KSPEC_FK_INVALID,
49196                        fk: C2RustUnnamed_0 {
49197                            range: C2RustUnnamed_2 {
49198                                lastkey: 0,
49199                                keystep: 0,
49200                                limit: 0,
49201                            },
49202                        },
49203                    },
49204                    keySpec {
49205                        notes: 0 as *const libc::c_char,
49206                        flags: 0,
49207                        begin_search_type: KSPEC_BS_INVALID,
49208                        bs: C2RustUnnamed_3 {
49209                            index: C2RustUnnamed_5 { pos: 0 },
49210                        },
49211                        find_keys_type: KSPEC_FK_INVALID,
49212                        fk: C2RustUnnamed_0 {
49213                            range: C2RustUnnamed_2 {
49214                                lastkey: 0,
49215                                keystep: 0,
49216                                limit: 0,
49217                            },
49218                        },
49219                    },
49220                    keySpec {
49221                        notes: 0 as *const libc::c_char,
49222                        flags: 0,
49223                        begin_search_type: KSPEC_BS_INVALID,
49224                        bs: C2RustUnnamed_3 {
49225                            index: C2RustUnnamed_5 { pos: 0 },
49226                        },
49227                        find_keys_type: KSPEC_FK_INVALID,
49228                        fk: C2RustUnnamed_0 {
49229                            range: C2RustUnnamed_2 {
49230                                lastkey: 0,
49231                                keystep: 0,
49232                                limit: 0,
49233                            },
49234                        },
49235                    },
49236                ],
49237                getkeys_proc: None,
49238                subcommands: 0 as *const redisCommand as *mut redisCommand,
49239                args: PFCOUNT_Args.as_ptr() as *mut _,
49240                microseconds: 0,
49241                calls: 0,
49242                rejected_calls: 0,
49243                failed_calls: 0,
49244                id: 0,
49245                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49246                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49247                key_specs: 0 as *const keySpec as *mut keySpec,
49248                legacy_range_key_spec: keySpec {
49249                    notes: 0 as *const libc::c_char,
49250                    flags: 0,
49251                    begin_search_type: KSPEC_BS_INVALID,
49252                    bs: C2RustUnnamed_3 {
49253                        index: C2RustUnnamed_5 { pos: 0 },
49254                    },
49255                    find_keys_type: KSPEC_FK_INVALID,
49256                    fk: C2RustUnnamed_0 {
49257                        range: C2RustUnnamed_2 {
49258                            lastkey: 0,
49259                            keystep: 0,
49260                            limit: 0,
49261                        },
49262                    },
49263                },
49264                num_args: 0,
49265                num_history: 0,
49266                num_tips: 0,
49267                key_specs_num: 0,
49268                key_specs_max: 0,
49269                subcommands_dict: 0 as *const dict as *mut dict,
49270                parent: 0 as *const redisCommand as *mut redisCommand,
49271                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49272            };
49273            init
49274        },
49275        {
49276            let mut init = redisCommand {
49277                declared_name: b"pfdebug\0" as *const u8 as *const libc::c_char,
49278                summary: b"Internal commands for debugging HyperLogLog values\0"
49279                    as *const u8 as *const libc::c_char,
49280                complexity: b"N/A\0" as *const u8 as *const libc::c_char,
49281                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
49282                doc_flags: (1 as libc::c_int) << 1 as libc::c_int,
49283                replaced_by: 0 as *const libc::c_char,
49284                deprecated_since: 0 as *const libc::c_char,
49285                group: COMMAND_GROUP_HYPERLOGLOG,
49286                history: 0 as *const commandHistory as *mut commandHistory,
49287                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49288                proc_0: Some(pfdebugCommand as unsafe extern "C" fn(*mut client) -> ()),
49289                arity: 3 as libc::c_int,
49290                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49291                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
49292                    | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
49293                acl_categories: ((1 as libc::c_ulonglong) << 9 as libc::c_int)
49294                    as uint64_t,
49295                key_specs_static: [
49296                    {
49297                        let mut init = keySpec {
49298                            notes: 0 as *const libc::c_char,
49299                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49300                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
49301                            begin_search_type: KSPEC_BS_INDEX,
49302                            bs: C2RustUnnamed_3 {
49303                                index: {
49304                                    let mut init = C2RustUnnamed_5 {
49305                                        pos: 2 as libc::c_int,
49306                                    };
49307                                    init
49308                                },
49309                            },
49310                            find_keys_type: KSPEC_FK_RANGE,
49311                            fk: C2RustUnnamed_0 {
49312                                range: {
49313                                    let mut init = C2RustUnnamed_2 {
49314                                        lastkey: 0 as libc::c_int,
49315                                        keystep: 1 as libc::c_int,
49316                                        limit: 0 as libc::c_int,
49317                                    };
49318                                    init
49319                                },
49320                            },
49321                        };
49322                        init
49323                    },
49324                    keySpec {
49325                        notes: 0 as *const libc::c_char,
49326                        flags: 0,
49327                        begin_search_type: KSPEC_BS_INVALID,
49328                        bs: C2RustUnnamed_3 {
49329                            index: C2RustUnnamed_5 { pos: 0 },
49330                        },
49331                        find_keys_type: KSPEC_FK_INVALID,
49332                        fk: C2RustUnnamed_0 {
49333                            range: C2RustUnnamed_2 {
49334                                lastkey: 0,
49335                                keystep: 0,
49336                                limit: 0,
49337                            },
49338                        },
49339                    },
49340                    keySpec {
49341                        notes: 0 as *const libc::c_char,
49342                        flags: 0,
49343                        begin_search_type: KSPEC_BS_INVALID,
49344                        bs: C2RustUnnamed_3 {
49345                            index: C2RustUnnamed_5 { pos: 0 },
49346                        },
49347                        find_keys_type: KSPEC_FK_INVALID,
49348                        fk: C2RustUnnamed_0 {
49349                            range: C2RustUnnamed_2 {
49350                                lastkey: 0,
49351                                keystep: 0,
49352                                limit: 0,
49353                            },
49354                        },
49355                    },
49356                    keySpec {
49357                        notes: 0 as *const libc::c_char,
49358                        flags: 0,
49359                        begin_search_type: KSPEC_BS_INVALID,
49360                        bs: C2RustUnnamed_3 {
49361                            index: C2RustUnnamed_5 { pos: 0 },
49362                        },
49363                        find_keys_type: KSPEC_FK_INVALID,
49364                        fk: C2RustUnnamed_0 {
49365                            range: C2RustUnnamed_2 {
49366                                lastkey: 0,
49367                                keystep: 0,
49368                                limit: 0,
49369                            },
49370                        },
49371                    },
49372                ],
49373                getkeys_proc: None,
49374                subcommands: 0 as *const redisCommand as *mut redisCommand,
49375                args: PFDEBUG_Args.as_ptr() as *mut _,
49376                microseconds: 0,
49377                calls: 0,
49378                rejected_calls: 0,
49379                failed_calls: 0,
49380                id: 0,
49381                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49382                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49383                key_specs: 0 as *const keySpec as *mut keySpec,
49384                legacy_range_key_spec: keySpec {
49385                    notes: 0 as *const libc::c_char,
49386                    flags: 0,
49387                    begin_search_type: KSPEC_BS_INVALID,
49388                    bs: C2RustUnnamed_3 {
49389                        index: C2RustUnnamed_5 { pos: 0 },
49390                    },
49391                    find_keys_type: KSPEC_FK_INVALID,
49392                    fk: C2RustUnnamed_0 {
49393                        range: C2RustUnnamed_2 {
49394                            lastkey: 0,
49395                            keystep: 0,
49396                            limit: 0,
49397                        },
49398                    },
49399                },
49400                num_args: 0,
49401                num_history: 0,
49402                num_tips: 0,
49403                key_specs_num: 0,
49404                key_specs_max: 0,
49405                subcommands_dict: 0 as *const dict as *mut dict,
49406                parent: 0 as *const redisCommand as *mut redisCommand,
49407                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49408            };
49409            init
49410        },
49411        {
49412            let mut init = redisCommand {
49413                declared_name: b"pfmerge\0" as *const u8 as *const libc::c_char,
49414                summary: b"Merge N different HyperLogLogs into a single one.\0"
49415                    as *const u8 as *const libc::c_char,
49416                complexity: b"O(N) to merge N HyperLogLogs, but with high constant times.\0"
49417                    as *const u8 as *const libc::c_char,
49418                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
49419                doc_flags: 0 as libc::c_int,
49420                replaced_by: 0 as *const libc::c_char,
49421                deprecated_since: 0 as *const libc::c_char,
49422                group: COMMAND_GROUP_HYPERLOGLOG,
49423                history: 0 as *const commandHistory as *mut commandHistory,
49424                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49425                proc_0: Some(pfmergeCommand as unsafe extern "C" fn(*mut client) -> ()),
49426                arity: -(2 as libc::c_int),
49427                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49428                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
49429                acl_categories: ((1 as libc::c_ulonglong) << 9 as libc::c_int)
49430                    as uint64_t,
49431                key_specs_static: [
49432                    {
49433                        let mut init = keySpec {
49434                            notes: 0 as *const libc::c_char,
49435                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49436                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
49437                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
49438                            begin_search_type: KSPEC_BS_INDEX,
49439                            bs: C2RustUnnamed_3 {
49440                                index: {
49441                                    let mut init = C2RustUnnamed_5 {
49442                                        pos: 1 as libc::c_int,
49443                                    };
49444                                    init
49445                                },
49446                            },
49447                            find_keys_type: KSPEC_FK_RANGE,
49448                            fk: C2RustUnnamed_0 {
49449                                range: {
49450                                    let mut init = C2RustUnnamed_2 {
49451                                        lastkey: 0 as libc::c_int,
49452                                        keystep: 1 as libc::c_int,
49453                                        limit: 0 as libc::c_int,
49454                                    };
49455                                    init
49456                                },
49457                            },
49458                        };
49459                        init
49460                    },
49461                    {
49462                        let mut init = keySpec {
49463                            notes: 0 as *const libc::c_char,
49464                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49465                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
49466                            begin_search_type: KSPEC_BS_INDEX,
49467                            bs: C2RustUnnamed_3 {
49468                                index: {
49469                                    let mut init = C2RustUnnamed_5 {
49470                                        pos: 2 as libc::c_int,
49471                                    };
49472                                    init
49473                                },
49474                            },
49475                            find_keys_type: KSPEC_FK_RANGE,
49476                            fk: C2RustUnnamed_0 {
49477                                range: {
49478                                    let mut init = C2RustUnnamed_2 {
49479                                        lastkey: -(1 as libc::c_int),
49480                                        keystep: 1 as libc::c_int,
49481                                        limit: 0 as libc::c_int,
49482                                    };
49483                                    init
49484                                },
49485                            },
49486                        };
49487                        init
49488                    },
49489                    keySpec {
49490                        notes: 0 as *const libc::c_char,
49491                        flags: 0,
49492                        begin_search_type: KSPEC_BS_INVALID,
49493                        bs: C2RustUnnamed_3 {
49494                            index: C2RustUnnamed_5 { pos: 0 },
49495                        },
49496                        find_keys_type: KSPEC_FK_INVALID,
49497                        fk: C2RustUnnamed_0 {
49498                            range: C2RustUnnamed_2 {
49499                                lastkey: 0,
49500                                keystep: 0,
49501                                limit: 0,
49502                            },
49503                        },
49504                    },
49505                    keySpec {
49506                        notes: 0 as *const libc::c_char,
49507                        flags: 0,
49508                        begin_search_type: KSPEC_BS_INVALID,
49509                        bs: C2RustUnnamed_3 {
49510                            index: C2RustUnnamed_5 { pos: 0 },
49511                        },
49512                        find_keys_type: KSPEC_FK_INVALID,
49513                        fk: C2RustUnnamed_0 {
49514                            range: C2RustUnnamed_2 {
49515                                lastkey: 0,
49516                                keystep: 0,
49517                                limit: 0,
49518                            },
49519                        },
49520                    },
49521                ],
49522                getkeys_proc: None,
49523                subcommands: 0 as *const redisCommand as *mut redisCommand,
49524                args: PFMERGE_Args.as_ptr() as *mut _,
49525                microseconds: 0,
49526                calls: 0,
49527                rejected_calls: 0,
49528                failed_calls: 0,
49529                id: 0,
49530                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49531                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49532                key_specs: 0 as *const keySpec as *mut keySpec,
49533                legacy_range_key_spec: keySpec {
49534                    notes: 0 as *const libc::c_char,
49535                    flags: 0,
49536                    begin_search_type: KSPEC_BS_INVALID,
49537                    bs: C2RustUnnamed_3 {
49538                        index: C2RustUnnamed_5 { pos: 0 },
49539                    },
49540                    find_keys_type: KSPEC_FK_INVALID,
49541                    fk: C2RustUnnamed_0 {
49542                        range: C2RustUnnamed_2 {
49543                            lastkey: 0,
49544                            keystep: 0,
49545                            limit: 0,
49546                        },
49547                    },
49548                },
49549                num_args: 0,
49550                num_history: 0,
49551                num_tips: 0,
49552                key_specs_num: 0,
49553                key_specs_max: 0,
49554                subcommands_dict: 0 as *const dict as *mut dict,
49555                parent: 0 as *const redisCommand as *mut redisCommand,
49556                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49557            };
49558            init
49559        },
49560        {
49561            let mut init = redisCommand {
49562                declared_name: b"pfselftest\0" as *const u8 as *const libc::c_char,
49563                summary: b"An internal command for testing HyperLogLog values\0"
49564                    as *const u8 as *const libc::c_char,
49565                complexity: b"N/A\0" as *const u8 as *const libc::c_char,
49566                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
49567                doc_flags: (1 as libc::c_int) << 1 as libc::c_int,
49568                replaced_by: 0 as *const libc::c_char,
49569                deprecated_since: 0 as *const libc::c_char,
49570                group: COMMAND_GROUP_HYPERLOGLOG,
49571                history: 0 as *const commandHistory as *mut commandHistory,
49572                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49573                proc_0: Some(
49574                    pfselftestCommand as unsafe extern "C" fn(*mut client) -> (),
49575                ),
49576                arity: 1 as libc::c_int,
49577                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
49578                acl_categories: ((1 as libc::c_ulonglong) << 9 as libc::c_int)
49579                    as uint64_t,
49580                key_specs_static: [keySpec {
49581                    notes: 0 as *const libc::c_char,
49582                    flags: 0,
49583                    begin_search_type: KSPEC_BS_INVALID,
49584                    bs: C2RustUnnamed_3 {
49585                        index: C2RustUnnamed_5 { pos: 0 },
49586                    },
49587                    find_keys_type: KSPEC_FK_INVALID,
49588                    fk: C2RustUnnamed_0 {
49589                        range: C2RustUnnamed_2 {
49590                            lastkey: 0,
49591                            keystep: 0,
49592                            limit: 0,
49593                        },
49594                    },
49595                }; 4],
49596                getkeys_proc: None,
49597                subcommands: 0 as *const redisCommand as *mut redisCommand,
49598                args: 0 as *const redisCommandArg as *mut redisCommandArg,
49599                microseconds: 0,
49600                calls: 0,
49601                rejected_calls: 0,
49602                failed_calls: 0,
49603                id: 0,
49604                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49605                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49606                key_specs: 0 as *const keySpec as *mut keySpec,
49607                legacy_range_key_spec: keySpec {
49608                    notes: 0 as *const libc::c_char,
49609                    flags: 0,
49610                    begin_search_type: KSPEC_BS_INVALID,
49611                    bs: C2RustUnnamed_3 {
49612                        index: C2RustUnnamed_5 { pos: 0 },
49613                    },
49614                    find_keys_type: KSPEC_FK_INVALID,
49615                    fk: C2RustUnnamed_0 {
49616                        range: C2RustUnnamed_2 {
49617                            lastkey: 0,
49618                            keystep: 0,
49619                            limit: 0,
49620                        },
49621                    },
49622                },
49623                num_args: 0,
49624                num_history: 0,
49625                num_tips: 0,
49626                key_specs_num: 0,
49627                key_specs_max: 0,
49628                subcommands_dict: 0 as *const dict as *mut dict,
49629                parent: 0 as *const redisCommand as *mut redisCommand,
49630                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49631            };
49632            init
49633        },
49634        {
49635            let mut init = redisCommand {
49636                declared_name: b"blmove\0" as *const u8 as *const libc::c_char,
49637                summary: b"Pop an element from a list, push it to another list and return it; or block until one is available\0"
49638                    as *const u8 as *const libc::c_char,
49639                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
49640                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
49641                doc_flags: 0 as libc::c_int,
49642                replaced_by: 0 as *const libc::c_char,
49643                deprecated_since: 0 as *const libc::c_char,
49644                group: COMMAND_GROUP_LIST,
49645                history: 0 as *const commandHistory as *mut commandHistory,
49646                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49647                proc_0: Some(blmoveCommand as unsafe extern "C" fn(*mut client) -> ()),
49648                arity: 6 as libc::c_int,
49649                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49650                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
49651                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
49652                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
49653                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
49654                    as uint64_t,
49655                key_specs_static: [
49656                    {
49657                        let mut init = keySpec {
49658                            notes: 0 as *const libc::c_char,
49659                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49660                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
49661                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
49662                            begin_search_type: KSPEC_BS_INDEX,
49663                            bs: C2RustUnnamed_3 {
49664                                index: {
49665                                    let mut init = C2RustUnnamed_5 {
49666                                        pos: 1 as libc::c_int,
49667                                    };
49668                                    init
49669                                },
49670                            },
49671                            find_keys_type: KSPEC_FK_RANGE,
49672                            fk: C2RustUnnamed_0 {
49673                                range: {
49674                                    let mut init = C2RustUnnamed_2 {
49675                                        lastkey: 0 as libc::c_int,
49676                                        keystep: 1 as libc::c_int,
49677                                        limit: 0 as libc::c_int,
49678                                    };
49679                                    init
49680                                },
49681                            },
49682                        };
49683                        init
49684                    },
49685                    {
49686                        let mut init = keySpec {
49687                            notes: 0 as *const libc::c_char,
49688                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49689                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
49690                            begin_search_type: KSPEC_BS_INDEX,
49691                            bs: C2RustUnnamed_3 {
49692                                index: {
49693                                    let mut init = C2RustUnnamed_5 {
49694                                        pos: 2 as libc::c_int,
49695                                    };
49696                                    init
49697                                },
49698                            },
49699                            find_keys_type: KSPEC_FK_RANGE,
49700                            fk: C2RustUnnamed_0 {
49701                                range: {
49702                                    let mut init = C2RustUnnamed_2 {
49703                                        lastkey: 0 as libc::c_int,
49704                                        keystep: 1 as libc::c_int,
49705                                        limit: 0 as libc::c_int,
49706                                    };
49707                                    init
49708                                },
49709                            },
49710                        };
49711                        init
49712                    },
49713                    keySpec {
49714                        notes: 0 as *const libc::c_char,
49715                        flags: 0,
49716                        begin_search_type: KSPEC_BS_INVALID,
49717                        bs: C2RustUnnamed_3 {
49718                            index: C2RustUnnamed_5 { pos: 0 },
49719                        },
49720                        find_keys_type: KSPEC_FK_INVALID,
49721                        fk: C2RustUnnamed_0 {
49722                            range: C2RustUnnamed_2 {
49723                                lastkey: 0,
49724                                keystep: 0,
49725                                limit: 0,
49726                            },
49727                        },
49728                    },
49729                    keySpec {
49730                        notes: 0 as *const libc::c_char,
49731                        flags: 0,
49732                        begin_search_type: KSPEC_BS_INVALID,
49733                        bs: C2RustUnnamed_3 {
49734                            index: C2RustUnnamed_5 { pos: 0 },
49735                        },
49736                        find_keys_type: KSPEC_FK_INVALID,
49737                        fk: C2RustUnnamed_0 {
49738                            range: C2RustUnnamed_2 {
49739                                lastkey: 0,
49740                                keystep: 0,
49741                                limit: 0,
49742                            },
49743                        },
49744                    },
49745                ],
49746                getkeys_proc: None,
49747                subcommands: 0 as *const redisCommand as *mut redisCommand,
49748                args: BLMOVE_Args.as_ptr() as *mut _,
49749                microseconds: 0,
49750                calls: 0,
49751                rejected_calls: 0,
49752                failed_calls: 0,
49753                id: 0,
49754                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49755                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49756                key_specs: 0 as *const keySpec as *mut keySpec,
49757                legacy_range_key_spec: keySpec {
49758                    notes: 0 as *const libc::c_char,
49759                    flags: 0,
49760                    begin_search_type: KSPEC_BS_INVALID,
49761                    bs: C2RustUnnamed_3 {
49762                        index: C2RustUnnamed_5 { pos: 0 },
49763                    },
49764                    find_keys_type: KSPEC_FK_INVALID,
49765                    fk: C2RustUnnamed_0 {
49766                        range: C2RustUnnamed_2 {
49767                            lastkey: 0,
49768                            keystep: 0,
49769                            limit: 0,
49770                        },
49771                    },
49772                },
49773                num_args: 0,
49774                num_history: 0,
49775                num_tips: 0,
49776                key_specs_num: 0,
49777                key_specs_max: 0,
49778                subcommands_dict: 0 as *const dict as *mut dict,
49779                parent: 0 as *const redisCommand as *mut redisCommand,
49780                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49781            };
49782            init
49783        },
49784        {
49785            let mut init = redisCommand {
49786                declared_name: b"blmpop\0" as *const u8 as *const libc::c_char,
49787                summary: b"Pop elements from a list, or block until one is available\0"
49788                    as *const u8 as *const libc::c_char,
49789                complexity: b"O(N+M) where N is the number of provided keys and M is the number of elements returned.\0"
49790                    as *const u8 as *const libc::c_char,
49791                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
49792                doc_flags: 0 as libc::c_int,
49793                replaced_by: 0 as *const libc::c_char,
49794                deprecated_since: 0 as *const libc::c_char,
49795                group: COMMAND_GROUP_LIST,
49796                history: 0 as *const commandHistory as *mut commandHistory,
49797                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49798                proc_0: Some(blmpopCommand as unsafe extern "C" fn(*mut client) -> ()),
49799                arity: -(5 as libc::c_int),
49800                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49801                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
49802                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
49803                    as uint64_t,
49804                key_specs_static: [
49805                    {
49806                        let mut init = keySpec {
49807                            notes: 0 as *const libc::c_char,
49808                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49809                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
49810                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
49811                            begin_search_type: KSPEC_BS_INDEX,
49812                            bs: C2RustUnnamed_3 {
49813                                index: {
49814                                    let mut init = C2RustUnnamed_5 {
49815                                        pos: 2 as libc::c_int,
49816                                    };
49817                                    init
49818                                },
49819                            },
49820                            find_keys_type: KSPEC_FK_KEYNUM,
49821                            fk: C2RustUnnamed_0 {
49822                                keynum: {
49823                                    let mut init = C2RustUnnamed_1 {
49824                                        keynumidx: 0 as libc::c_int,
49825                                        firstkey: 1 as libc::c_int,
49826                                        keystep: 1 as libc::c_int,
49827                                    };
49828                                    init
49829                                },
49830                            },
49831                        };
49832                        init
49833                    },
49834                    keySpec {
49835                        notes: 0 as *const libc::c_char,
49836                        flags: 0,
49837                        begin_search_type: KSPEC_BS_INVALID,
49838                        bs: C2RustUnnamed_3 {
49839                            index: C2RustUnnamed_5 { pos: 0 },
49840                        },
49841                        find_keys_type: KSPEC_FK_INVALID,
49842                        fk: C2RustUnnamed_0 {
49843                            range: C2RustUnnamed_2 {
49844                                lastkey: 0,
49845                                keystep: 0,
49846                                limit: 0,
49847                            },
49848                        },
49849                    },
49850                    keySpec {
49851                        notes: 0 as *const libc::c_char,
49852                        flags: 0,
49853                        begin_search_type: KSPEC_BS_INVALID,
49854                        bs: C2RustUnnamed_3 {
49855                            index: C2RustUnnamed_5 { pos: 0 },
49856                        },
49857                        find_keys_type: KSPEC_FK_INVALID,
49858                        fk: C2RustUnnamed_0 {
49859                            range: C2RustUnnamed_2 {
49860                                lastkey: 0,
49861                                keystep: 0,
49862                                limit: 0,
49863                            },
49864                        },
49865                    },
49866                    keySpec {
49867                        notes: 0 as *const libc::c_char,
49868                        flags: 0,
49869                        begin_search_type: KSPEC_BS_INVALID,
49870                        bs: C2RustUnnamed_3 {
49871                            index: C2RustUnnamed_5 { pos: 0 },
49872                        },
49873                        find_keys_type: KSPEC_FK_INVALID,
49874                        fk: C2RustUnnamed_0 {
49875                            range: C2RustUnnamed_2 {
49876                                lastkey: 0,
49877                                keystep: 0,
49878                                limit: 0,
49879                            },
49880                        },
49881                    },
49882                ],
49883                getkeys_proc: Some(
49884                    blmpopGetKeys
49885                        as unsafe extern "C" fn(
49886                            *mut redisCommand,
49887                            *mut *mut robj,
49888                            libc::c_int,
49889                            *mut getKeysResult,
49890                        ) -> libc::c_int,
49891                ),
49892                subcommands: 0 as *const redisCommand as *mut redisCommand,
49893                args: BLMPOP_Args.as_ptr() as *mut _,
49894                microseconds: 0,
49895                calls: 0,
49896                rejected_calls: 0,
49897                failed_calls: 0,
49898                id: 0,
49899                fullname: 0 as *const libc::c_char as *mut libc::c_char,
49900                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
49901                key_specs: 0 as *const keySpec as *mut keySpec,
49902                legacy_range_key_spec: keySpec {
49903                    notes: 0 as *const libc::c_char,
49904                    flags: 0,
49905                    begin_search_type: KSPEC_BS_INVALID,
49906                    bs: C2RustUnnamed_3 {
49907                        index: C2RustUnnamed_5 { pos: 0 },
49908                    },
49909                    find_keys_type: KSPEC_FK_INVALID,
49910                    fk: C2RustUnnamed_0 {
49911                        range: C2RustUnnamed_2 {
49912                            lastkey: 0,
49913                            keystep: 0,
49914                            limit: 0,
49915                        },
49916                    },
49917                },
49918                num_args: 0,
49919                num_history: 0,
49920                num_tips: 0,
49921                key_specs_num: 0,
49922                key_specs_max: 0,
49923                subcommands_dict: 0 as *const dict as *mut dict,
49924                parent: 0 as *const redisCommand as *mut redisCommand,
49925                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
49926            };
49927            init
49928        },
49929        {
49930            let mut init = redisCommand {
49931                declared_name: b"blpop\0" as *const u8 as *const libc::c_char,
49932                summary: b"Remove and get the first element in a list, or block until one is available\0"
49933                    as *const u8 as *const libc::c_char,
49934                complexity: b"O(N) where N is the number of provided keys.\0"
49935                    as *const u8 as *const libc::c_char,
49936                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
49937                doc_flags: 0 as libc::c_int,
49938                replaced_by: 0 as *const libc::c_char,
49939                deprecated_since: 0 as *const libc::c_char,
49940                group: COMMAND_GROUP_LIST,
49941                history: BLPOP_History.as_ptr() as *mut _,
49942                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
49943                proc_0: Some(blpopCommand as unsafe extern "C" fn(*mut client) -> ()),
49944                arity: -(3 as libc::c_int),
49945                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
49946                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
49947                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
49948                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
49949                    as uint64_t,
49950                key_specs_static: [
49951                    {
49952                        let mut init = keySpec {
49953                            notes: 0 as *const libc::c_char,
49954                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
49955                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
49956                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
49957                            begin_search_type: KSPEC_BS_INDEX,
49958                            bs: C2RustUnnamed_3 {
49959                                index: {
49960                                    let mut init = C2RustUnnamed_5 {
49961                                        pos: 1 as libc::c_int,
49962                                    };
49963                                    init
49964                                },
49965                            },
49966                            find_keys_type: KSPEC_FK_RANGE,
49967                            fk: C2RustUnnamed_0 {
49968                                range: {
49969                                    let mut init = C2RustUnnamed_2 {
49970                                        lastkey: -(2 as libc::c_int),
49971                                        keystep: 1 as libc::c_int,
49972                                        limit: 0 as libc::c_int,
49973                                    };
49974                                    init
49975                                },
49976                            },
49977                        };
49978                        init
49979                    },
49980                    keySpec {
49981                        notes: 0 as *const libc::c_char,
49982                        flags: 0,
49983                        begin_search_type: KSPEC_BS_INVALID,
49984                        bs: C2RustUnnamed_3 {
49985                            index: C2RustUnnamed_5 { pos: 0 },
49986                        },
49987                        find_keys_type: KSPEC_FK_INVALID,
49988                        fk: C2RustUnnamed_0 {
49989                            range: C2RustUnnamed_2 {
49990                                lastkey: 0,
49991                                keystep: 0,
49992                                limit: 0,
49993                            },
49994                        },
49995                    },
49996                    keySpec {
49997                        notes: 0 as *const libc::c_char,
49998                        flags: 0,
49999                        begin_search_type: KSPEC_BS_INVALID,
50000                        bs: C2RustUnnamed_3 {
50001                            index: C2RustUnnamed_5 { pos: 0 },
50002                        },
50003                        find_keys_type: KSPEC_FK_INVALID,
50004                        fk: C2RustUnnamed_0 {
50005                            range: C2RustUnnamed_2 {
50006                                lastkey: 0,
50007                                keystep: 0,
50008                                limit: 0,
50009                            },
50010                        },
50011                    },
50012                    keySpec {
50013                        notes: 0 as *const libc::c_char,
50014                        flags: 0,
50015                        begin_search_type: KSPEC_BS_INVALID,
50016                        bs: C2RustUnnamed_3 {
50017                            index: C2RustUnnamed_5 { pos: 0 },
50018                        },
50019                        find_keys_type: KSPEC_FK_INVALID,
50020                        fk: C2RustUnnamed_0 {
50021                            range: C2RustUnnamed_2 {
50022                                lastkey: 0,
50023                                keystep: 0,
50024                                limit: 0,
50025                            },
50026                        },
50027                    },
50028                ],
50029                getkeys_proc: None,
50030                subcommands: 0 as *const redisCommand as *mut redisCommand,
50031                args: BLPOP_Args.as_ptr() as *mut _,
50032                microseconds: 0,
50033                calls: 0,
50034                rejected_calls: 0,
50035                failed_calls: 0,
50036                id: 0,
50037                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50038                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50039                key_specs: 0 as *const keySpec as *mut keySpec,
50040                legacy_range_key_spec: keySpec {
50041                    notes: 0 as *const libc::c_char,
50042                    flags: 0,
50043                    begin_search_type: KSPEC_BS_INVALID,
50044                    bs: C2RustUnnamed_3 {
50045                        index: C2RustUnnamed_5 { pos: 0 },
50046                    },
50047                    find_keys_type: KSPEC_FK_INVALID,
50048                    fk: C2RustUnnamed_0 {
50049                        range: C2RustUnnamed_2 {
50050                            lastkey: 0,
50051                            keystep: 0,
50052                            limit: 0,
50053                        },
50054                    },
50055                },
50056                num_args: 0,
50057                num_history: 0,
50058                num_tips: 0,
50059                key_specs_num: 0,
50060                key_specs_max: 0,
50061                subcommands_dict: 0 as *const dict as *mut dict,
50062                parent: 0 as *const redisCommand as *mut redisCommand,
50063                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50064            };
50065            init
50066        },
50067        {
50068            let mut init = redisCommand {
50069                declared_name: b"brpop\0" as *const u8 as *const libc::c_char,
50070                summary: b"Remove and get the last element in a list, or block until one is available\0"
50071                    as *const u8 as *const libc::c_char,
50072                complexity: b"O(N) where N is the number of provided keys.\0"
50073                    as *const u8 as *const libc::c_char,
50074                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
50075                doc_flags: 0 as libc::c_int,
50076                replaced_by: 0 as *const libc::c_char,
50077                deprecated_since: 0 as *const libc::c_char,
50078                group: COMMAND_GROUP_LIST,
50079                history: BRPOP_History.as_ptr() as *mut _,
50080                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50081                proc_0: Some(brpopCommand as unsafe extern "C" fn(*mut client) -> ()),
50082                arity: -(3 as libc::c_int),
50083                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
50084                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
50085                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
50086                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50087                    as uint64_t,
50088                key_specs_static: [
50089                    {
50090                        let mut init = keySpec {
50091                            notes: 0 as *const libc::c_char,
50092                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50093                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
50094                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
50095                            begin_search_type: KSPEC_BS_INDEX,
50096                            bs: C2RustUnnamed_3 {
50097                                index: {
50098                                    let mut init = C2RustUnnamed_5 {
50099                                        pos: 1 as libc::c_int,
50100                                    };
50101                                    init
50102                                },
50103                            },
50104                            find_keys_type: KSPEC_FK_RANGE,
50105                            fk: C2RustUnnamed_0 {
50106                                range: {
50107                                    let mut init = C2RustUnnamed_2 {
50108                                        lastkey: -(2 as libc::c_int),
50109                                        keystep: 1 as libc::c_int,
50110                                        limit: 0 as libc::c_int,
50111                                    };
50112                                    init
50113                                },
50114                            },
50115                        };
50116                        init
50117                    },
50118                    keySpec {
50119                        notes: 0 as *const libc::c_char,
50120                        flags: 0,
50121                        begin_search_type: KSPEC_BS_INVALID,
50122                        bs: C2RustUnnamed_3 {
50123                            index: C2RustUnnamed_5 { pos: 0 },
50124                        },
50125                        find_keys_type: KSPEC_FK_INVALID,
50126                        fk: C2RustUnnamed_0 {
50127                            range: C2RustUnnamed_2 {
50128                                lastkey: 0,
50129                                keystep: 0,
50130                                limit: 0,
50131                            },
50132                        },
50133                    },
50134                    keySpec {
50135                        notes: 0 as *const libc::c_char,
50136                        flags: 0,
50137                        begin_search_type: KSPEC_BS_INVALID,
50138                        bs: C2RustUnnamed_3 {
50139                            index: C2RustUnnamed_5 { pos: 0 },
50140                        },
50141                        find_keys_type: KSPEC_FK_INVALID,
50142                        fk: C2RustUnnamed_0 {
50143                            range: C2RustUnnamed_2 {
50144                                lastkey: 0,
50145                                keystep: 0,
50146                                limit: 0,
50147                            },
50148                        },
50149                    },
50150                    keySpec {
50151                        notes: 0 as *const libc::c_char,
50152                        flags: 0,
50153                        begin_search_type: KSPEC_BS_INVALID,
50154                        bs: C2RustUnnamed_3 {
50155                            index: C2RustUnnamed_5 { pos: 0 },
50156                        },
50157                        find_keys_type: KSPEC_FK_INVALID,
50158                        fk: C2RustUnnamed_0 {
50159                            range: C2RustUnnamed_2 {
50160                                lastkey: 0,
50161                                keystep: 0,
50162                                limit: 0,
50163                            },
50164                        },
50165                    },
50166                ],
50167                getkeys_proc: None,
50168                subcommands: 0 as *const redisCommand as *mut redisCommand,
50169                args: BRPOP_Args.as_ptr() as *mut _,
50170                microseconds: 0,
50171                calls: 0,
50172                rejected_calls: 0,
50173                failed_calls: 0,
50174                id: 0,
50175                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50176                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50177                key_specs: 0 as *const keySpec as *mut keySpec,
50178                legacy_range_key_spec: keySpec {
50179                    notes: 0 as *const libc::c_char,
50180                    flags: 0,
50181                    begin_search_type: KSPEC_BS_INVALID,
50182                    bs: C2RustUnnamed_3 {
50183                        index: C2RustUnnamed_5 { pos: 0 },
50184                    },
50185                    find_keys_type: KSPEC_FK_INVALID,
50186                    fk: C2RustUnnamed_0 {
50187                        range: C2RustUnnamed_2 {
50188                            lastkey: 0,
50189                            keystep: 0,
50190                            limit: 0,
50191                        },
50192                    },
50193                },
50194                num_args: 0,
50195                num_history: 0,
50196                num_tips: 0,
50197                key_specs_num: 0,
50198                key_specs_max: 0,
50199                subcommands_dict: 0 as *const dict as *mut dict,
50200                parent: 0 as *const redisCommand as *mut redisCommand,
50201                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50202            };
50203            init
50204        },
50205        {
50206            let mut init = redisCommand {
50207                declared_name: b"brpoplpush\0" as *const u8 as *const libc::c_char,
50208                summary: b"Pop an element from a list, push it to another list and return it; or block until one is available\0"
50209                    as *const u8 as *const libc::c_char,
50210                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
50211                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
50212                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
50213                replaced_by: b"`BLMOVE` with the `RIGHT` and `LEFT` arguments\0"
50214                    as *const u8 as *const libc::c_char,
50215                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
50216                group: COMMAND_GROUP_LIST,
50217                history: BRPOPLPUSH_History.as_ptr() as *mut _,
50218                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50219                proc_0: Some(
50220                    brpoplpushCommand as unsafe extern "C" fn(*mut client) -> (),
50221                ),
50222                arity: 4 as libc::c_int,
50223                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
50224                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
50225                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
50226                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
50227                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50228                    as uint64_t,
50229                key_specs_static: [
50230                    {
50231                        let mut init = keySpec {
50232                            notes: 0 as *const libc::c_char,
50233                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50234                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
50235                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
50236                            begin_search_type: KSPEC_BS_INDEX,
50237                            bs: C2RustUnnamed_3 {
50238                                index: {
50239                                    let mut init = C2RustUnnamed_5 {
50240                                        pos: 1 as libc::c_int,
50241                                    };
50242                                    init
50243                                },
50244                            },
50245                            find_keys_type: KSPEC_FK_RANGE,
50246                            fk: C2RustUnnamed_0 {
50247                                range: {
50248                                    let mut init = C2RustUnnamed_2 {
50249                                        lastkey: 0 as libc::c_int,
50250                                        keystep: 1 as libc::c_int,
50251                                        limit: 0 as libc::c_int,
50252                                    };
50253                                    init
50254                                },
50255                            },
50256                        };
50257                        init
50258                    },
50259                    {
50260                        let mut init = keySpec {
50261                            notes: 0 as *const libc::c_char,
50262                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50263                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
50264                            begin_search_type: KSPEC_BS_INDEX,
50265                            bs: C2RustUnnamed_3 {
50266                                index: {
50267                                    let mut init = C2RustUnnamed_5 {
50268                                        pos: 2 as libc::c_int,
50269                                    };
50270                                    init
50271                                },
50272                            },
50273                            find_keys_type: KSPEC_FK_RANGE,
50274                            fk: C2RustUnnamed_0 {
50275                                range: {
50276                                    let mut init = C2RustUnnamed_2 {
50277                                        lastkey: 0 as libc::c_int,
50278                                        keystep: 1 as libc::c_int,
50279                                        limit: 0 as libc::c_int,
50280                                    };
50281                                    init
50282                                },
50283                            },
50284                        };
50285                        init
50286                    },
50287                    keySpec {
50288                        notes: 0 as *const libc::c_char,
50289                        flags: 0,
50290                        begin_search_type: KSPEC_BS_INVALID,
50291                        bs: C2RustUnnamed_3 {
50292                            index: C2RustUnnamed_5 { pos: 0 },
50293                        },
50294                        find_keys_type: KSPEC_FK_INVALID,
50295                        fk: C2RustUnnamed_0 {
50296                            range: C2RustUnnamed_2 {
50297                                lastkey: 0,
50298                                keystep: 0,
50299                                limit: 0,
50300                            },
50301                        },
50302                    },
50303                    keySpec {
50304                        notes: 0 as *const libc::c_char,
50305                        flags: 0,
50306                        begin_search_type: KSPEC_BS_INVALID,
50307                        bs: C2RustUnnamed_3 {
50308                            index: C2RustUnnamed_5 { pos: 0 },
50309                        },
50310                        find_keys_type: KSPEC_FK_INVALID,
50311                        fk: C2RustUnnamed_0 {
50312                            range: C2RustUnnamed_2 {
50313                                lastkey: 0,
50314                                keystep: 0,
50315                                limit: 0,
50316                            },
50317                        },
50318                    },
50319                ],
50320                getkeys_proc: None,
50321                subcommands: 0 as *const redisCommand as *mut redisCommand,
50322                args: BRPOPLPUSH_Args.as_ptr() as *mut _,
50323                microseconds: 0,
50324                calls: 0,
50325                rejected_calls: 0,
50326                failed_calls: 0,
50327                id: 0,
50328                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50329                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50330                key_specs: 0 as *const keySpec as *mut keySpec,
50331                legacy_range_key_spec: keySpec {
50332                    notes: 0 as *const libc::c_char,
50333                    flags: 0,
50334                    begin_search_type: KSPEC_BS_INVALID,
50335                    bs: C2RustUnnamed_3 {
50336                        index: C2RustUnnamed_5 { pos: 0 },
50337                    },
50338                    find_keys_type: KSPEC_FK_INVALID,
50339                    fk: C2RustUnnamed_0 {
50340                        range: C2RustUnnamed_2 {
50341                            lastkey: 0,
50342                            keystep: 0,
50343                            limit: 0,
50344                        },
50345                    },
50346                },
50347                num_args: 0,
50348                num_history: 0,
50349                num_tips: 0,
50350                key_specs_num: 0,
50351                key_specs_max: 0,
50352                subcommands_dict: 0 as *const dict as *mut dict,
50353                parent: 0 as *const redisCommand as *mut redisCommand,
50354                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50355            };
50356            init
50357        },
50358        {
50359            let mut init = redisCommand {
50360                declared_name: b"lindex\0" as *const u8 as *const libc::c_char,
50361                summary: b"Get an element from a list by its index\0" as *const u8
50362                    as *const libc::c_char,
50363                complexity: b"O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).\0"
50364                    as *const u8 as *const libc::c_char,
50365                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
50366                doc_flags: 0 as libc::c_int,
50367                replaced_by: 0 as *const libc::c_char,
50368                deprecated_since: 0 as *const libc::c_char,
50369                group: COMMAND_GROUP_LIST,
50370                history: 0 as *const commandHistory as *mut commandHistory,
50371                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50372                proc_0: Some(lindexCommand as unsafe extern "C" fn(*mut client) -> ()),
50373                arity: 3 as libc::c_int,
50374                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
50375                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50376                    as uint64_t,
50377                key_specs_static: [
50378                    {
50379                        let mut init = keySpec {
50380                            notes: 0 as *const libc::c_char,
50381                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
50382                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
50383                            begin_search_type: KSPEC_BS_INDEX,
50384                            bs: C2RustUnnamed_3 {
50385                                index: {
50386                                    let mut init = C2RustUnnamed_5 {
50387                                        pos: 1 as libc::c_int,
50388                                    };
50389                                    init
50390                                },
50391                            },
50392                            find_keys_type: KSPEC_FK_RANGE,
50393                            fk: C2RustUnnamed_0 {
50394                                range: {
50395                                    let mut init = C2RustUnnamed_2 {
50396                                        lastkey: 0 as libc::c_int,
50397                                        keystep: 1 as libc::c_int,
50398                                        limit: 0 as libc::c_int,
50399                                    };
50400                                    init
50401                                },
50402                            },
50403                        };
50404                        init
50405                    },
50406                    keySpec {
50407                        notes: 0 as *const libc::c_char,
50408                        flags: 0,
50409                        begin_search_type: KSPEC_BS_INVALID,
50410                        bs: C2RustUnnamed_3 {
50411                            index: C2RustUnnamed_5 { pos: 0 },
50412                        },
50413                        find_keys_type: KSPEC_FK_INVALID,
50414                        fk: C2RustUnnamed_0 {
50415                            range: C2RustUnnamed_2 {
50416                                lastkey: 0,
50417                                keystep: 0,
50418                                limit: 0,
50419                            },
50420                        },
50421                    },
50422                    keySpec {
50423                        notes: 0 as *const libc::c_char,
50424                        flags: 0,
50425                        begin_search_type: KSPEC_BS_INVALID,
50426                        bs: C2RustUnnamed_3 {
50427                            index: C2RustUnnamed_5 { pos: 0 },
50428                        },
50429                        find_keys_type: KSPEC_FK_INVALID,
50430                        fk: C2RustUnnamed_0 {
50431                            range: C2RustUnnamed_2 {
50432                                lastkey: 0,
50433                                keystep: 0,
50434                                limit: 0,
50435                            },
50436                        },
50437                    },
50438                    keySpec {
50439                        notes: 0 as *const libc::c_char,
50440                        flags: 0,
50441                        begin_search_type: KSPEC_BS_INVALID,
50442                        bs: C2RustUnnamed_3 {
50443                            index: C2RustUnnamed_5 { pos: 0 },
50444                        },
50445                        find_keys_type: KSPEC_FK_INVALID,
50446                        fk: C2RustUnnamed_0 {
50447                            range: C2RustUnnamed_2 {
50448                                lastkey: 0,
50449                                keystep: 0,
50450                                limit: 0,
50451                            },
50452                        },
50453                    },
50454                ],
50455                getkeys_proc: None,
50456                subcommands: 0 as *const redisCommand as *mut redisCommand,
50457                args: LINDEX_Args.as_ptr() as *mut _,
50458                microseconds: 0,
50459                calls: 0,
50460                rejected_calls: 0,
50461                failed_calls: 0,
50462                id: 0,
50463                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50464                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50465                key_specs: 0 as *const keySpec as *mut keySpec,
50466                legacy_range_key_spec: keySpec {
50467                    notes: 0 as *const libc::c_char,
50468                    flags: 0,
50469                    begin_search_type: KSPEC_BS_INVALID,
50470                    bs: C2RustUnnamed_3 {
50471                        index: C2RustUnnamed_5 { pos: 0 },
50472                    },
50473                    find_keys_type: KSPEC_FK_INVALID,
50474                    fk: C2RustUnnamed_0 {
50475                        range: C2RustUnnamed_2 {
50476                            lastkey: 0,
50477                            keystep: 0,
50478                            limit: 0,
50479                        },
50480                    },
50481                },
50482                num_args: 0,
50483                num_history: 0,
50484                num_tips: 0,
50485                key_specs_num: 0,
50486                key_specs_max: 0,
50487                subcommands_dict: 0 as *const dict as *mut dict,
50488                parent: 0 as *const redisCommand as *mut redisCommand,
50489                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50490            };
50491            init
50492        },
50493        {
50494            let mut init = redisCommand {
50495                declared_name: b"linsert\0" as *const u8 as *const libc::c_char,
50496                summary: b"Insert an element before or after another element in a list\0"
50497                    as *const u8 as *const libc::c_char,
50498                complexity: b"O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).\0"
50499                    as *const u8 as *const libc::c_char,
50500                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
50501                doc_flags: 0 as libc::c_int,
50502                replaced_by: 0 as *const libc::c_char,
50503                deprecated_since: 0 as *const libc::c_char,
50504                group: COMMAND_GROUP_LIST,
50505                history: 0 as *const commandHistory as *mut commandHistory,
50506                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50507                proc_0: Some(linsertCommand as unsafe extern "C" fn(*mut client) -> ()),
50508                arity: 5 as libc::c_int,
50509                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
50510                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
50511                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50512                    as uint64_t,
50513                key_specs_static: [
50514                    {
50515                        let mut init = keySpec {
50516                            notes: 0 as *const libc::c_char,
50517                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50518                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
50519                            begin_search_type: KSPEC_BS_INDEX,
50520                            bs: C2RustUnnamed_3 {
50521                                index: {
50522                                    let mut init = C2RustUnnamed_5 {
50523                                        pos: 1 as libc::c_int,
50524                                    };
50525                                    init
50526                                },
50527                            },
50528                            find_keys_type: KSPEC_FK_RANGE,
50529                            fk: C2RustUnnamed_0 {
50530                                range: {
50531                                    let mut init = C2RustUnnamed_2 {
50532                                        lastkey: 0 as libc::c_int,
50533                                        keystep: 1 as libc::c_int,
50534                                        limit: 0 as libc::c_int,
50535                                    };
50536                                    init
50537                                },
50538                            },
50539                        };
50540                        init
50541                    },
50542                    keySpec {
50543                        notes: 0 as *const libc::c_char,
50544                        flags: 0,
50545                        begin_search_type: KSPEC_BS_INVALID,
50546                        bs: C2RustUnnamed_3 {
50547                            index: C2RustUnnamed_5 { pos: 0 },
50548                        },
50549                        find_keys_type: KSPEC_FK_INVALID,
50550                        fk: C2RustUnnamed_0 {
50551                            range: C2RustUnnamed_2 {
50552                                lastkey: 0,
50553                                keystep: 0,
50554                                limit: 0,
50555                            },
50556                        },
50557                    },
50558                    keySpec {
50559                        notes: 0 as *const libc::c_char,
50560                        flags: 0,
50561                        begin_search_type: KSPEC_BS_INVALID,
50562                        bs: C2RustUnnamed_3 {
50563                            index: C2RustUnnamed_5 { pos: 0 },
50564                        },
50565                        find_keys_type: KSPEC_FK_INVALID,
50566                        fk: C2RustUnnamed_0 {
50567                            range: C2RustUnnamed_2 {
50568                                lastkey: 0,
50569                                keystep: 0,
50570                                limit: 0,
50571                            },
50572                        },
50573                    },
50574                    keySpec {
50575                        notes: 0 as *const libc::c_char,
50576                        flags: 0,
50577                        begin_search_type: KSPEC_BS_INVALID,
50578                        bs: C2RustUnnamed_3 {
50579                            index: C2RustUnnamed_5 { pos: 0 },
50580                        },
50581                        find_keys_type: KSPEC_FK_INVALID,
50582                        fk: C2RustUnnamed_0 {
50583                            range: C2RustUnnamed_2 {
50584                                lastkey: 0,
50585                                keystep: 0,
50586                                limit: 0,
50587                            },
50588                        },
50589                    },
50590                ],
50591                getkeys_proc: None,
50592                subcommands: 0 as *const redisCommand as *mut redisCommand,
50593                args: LINSERT_Args.as_ptr() as *mut _,
50594                microseconds: 0,
50595                calls: 0,
50596                rejected_calls: 0,
50597                failed_calls: 0,
50598                id: 0,
50599                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50600                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50601                key_specs: 0 as *const keySpec as *mut keySpec,
50602                legacy_range_key_spec: keySpec {
50603                    notes: 0 as *const libc::c_char,
50604                    flags: 0,
50605                    begin_search_type: KSPEC_BS_INVALID,
50606                    bs: C2RustUnnamed_3 {
50607                        index: C2RustUnnamed_5 { pos: 0 },
50608                    },
50609                    find_keys_type: KSPEC_FK_INVALID,
50610                    fk: C2RustUnnamed_0 {
50611                        range: C2RustUnnamed_2 {
50612                            lastkey: 0,
50613                            keystep: 0,
50614                            limit: 0,
50615                        },
50616                    },
50617                },
50618                num_args: 0,
50619                num_history: 0,
50620                num_tips: 0,
50621                key_specs_num: 0,
50622                key_specs_max: 0,
50623                subcommands_dict: 0 as *const dict as *mut dict,
50624                parent: 0 as *const redisCommand as *mut redisCommand,
50625                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50626            };
50627            init
50628        },
50629        {
50630            let mut init = redisCommand {
50631                declared_name: b"llen\0" as *const u8 as *const libc::c_char,
50632                summary: b"Get the length of a list\0" as *const u8
50633                    as *const libc::c_char,
50634                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
50635                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
50636                doc_flags: 0 as libc::c_int,
50637                replaced_by: 0 as *const libc::c_char,
50638                deprecated_since: 0 as *const libc::c_char,
50639                group: COMMAND_GROUP_LIST,
50640                history: 0 as *const commandHistory as *mut commandHistory,
50641                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50642                proc_0: Some(llenCommand as unsafe extern "C" fn(*mut client) -> ()),
50643                arity: 2 as libc::c_int,
50644                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50645                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
50646                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50647                    as uint64_t,
50648                key_specs_static: [
50649                    {
50650                        let mut init = keySpec {
50651                            notes: 0 as *const libc::c_char,
50652                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
50653                                as uint64_t,
50654                            begin_search_type: KSPEC_BS_INDEX,
50655                            bs: C2RustUnnamed_3 {
50656                                index: {
50657                                    let mut init = C2RustUnnamed_5 {
50658                                        pos: 1 as libc::c_int,
50659                                    };
50660                                    init
50661                                },
50662                            },
50663                            find_keys_type: KSPEC_FK_RANGE,
50664                            fk: C2RustUnnamed_0 {
50665                                range: {
50666                                    let mut init = C2RustUnnamed_2 {
50667                                        lastkey: 0 as libc::c_int,
50668                                        keystep: 1 as libc::c_int,
50669                                        limit: 0 as libc::c_int,
50670                                    };
50671                                    init
50672                                },
50673                            },
50674                        };
50675                        init
50676                    },
50677                    keySpec {
50678                        notes: 0 as *const libc::c_char,
50679                        flags: 0,
50680                        begin_search_type: KSPEC_BS_INVALID,
50681                        bs: C2RustUnnamed_3 {
50682                            index: C2RustUnnamed_5 { pos: 0 },
50683                        },
50684                        find_keys_type: KSPEC_FK_INVALID,
50685                        fk: C2RustUnnamed_0 {
50686                            range: C2RustUnnamed_2 {
50687                                lastkey: 0,
50688                                keystep: 0,
50689                                limit: 0,
50690                            },
50691                        },
50692                    },
50693                    keySpec {
50694                        notes: 0 as *const libc::c_char,
50695                        flags: 0,
50696                        begin_search_type: KSPEC_BS_INVALID,
50697                        bs: C2RustUnnamed_3 {
50698                            index: C2RustUnnamed_5 { pos: 0 },
50699                        },
50700                        find_keys_type: KSPEC_FK_INVALID,
50701                        fk: C2RustUnnamed_0 {
50702                            range: C2RustUnnamed_2 {
50703                                lastkey: 0,
50704                                keystep: 0,
50705                                limit: 0,
50706                            },
50707                        },
50708                    },
50709                    keySpec {
50710                        notes: 0 as *const libc::c_char,
50711                        flags: 0,
50712                        begin_search_type: KSPEC_BS_INVALID,
50713                        bs: C2RustUnnamed_3 {
50714                            index: C2RustUnnamed_5 { pos: 0 },
50715                        },
50716                        find_keys_type: KSPEC_FK_INVALID,
50717                        fk: C2RustUnnamed_0 {
50718                            range: C2RustUnnamed_2 {
50719                                lastkey: 0,
50720                                keystep: 0,
50721                                limit: 0,
50722                            },
50723                        },
50724                    },
50725                ],
50726                getkeys_proc: None,
50727                subcommands: 0 as *const redisCommand as *mut redisCommand,
50728                args: LLEN_Args.as_ptr() as *mut _,
50729                microseconds: 0,
50730                calls: 0,
50731                rejected_calls: 0,
50732                failed_calls: 0,
50733                id: 0,
50734                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50735                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50736                key_specs: 0 as *const keySpec as *mut keySpec,
50737                legacy_range_key_spec: keySpec {
50738                    notes: 0 as *const libc::c_char,
50739                    flags: 0,
50740                    begin_search_type: KSPEC_BS_INVALID,
50741                    bs: C2RustUnnamed_3 {
50742                        index: C2RustUnnamed_5 { pos: 0 },
50743                    },
50744                    find_keys_type: KSPEC_FK_INVALID,
50745                    fk: C2RustUnnamed_0 {
50746                        range: C2RustUnnamed_2 {
50747                            lastkey: 0,
50748                            keystep: 0,
50749                            limit: 0,
50750                        },
50751                    },
50752                },
50753                num_args: 0,
50754                num_history: 0,
50755                num_tips: 0,
50756                key_specs_num: 0,
50757                key_specs_max: 0,
50758                subcommands_dict: 0 as *const dict as *mut dict,
50759                parent: 0 as *const redisCommand as *mut redisCommand,
50760                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50761            };
50762            init
50763        },
50764        {
50765            let mut init = redisCommand {
50766                declared_name: b"lmove\0" as *const u8 as *const libc::c_char,
50767                summary: b"Pop an element from a list, push it to another list and return it\0"
50768                    as *const u8 as *const libc::c_char,
50769                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
50770                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
50771                doc_flags: 0 as libc::c_int,
50772                replaced_by: 0 as *const libc::c_char,
50773                deprecated_since: 0 as *const libc::c_char,
50774                group: COMMAND_GROUP_LIST,
50775                history: 0 as *const commandHistory as *mut commandHistory,
50776                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50777                proc_0: Some(lmoveCommand as unsafe extern "C" fn(*mut client) -> ()),
50778                arity: 5 as libc::c_int,
50779                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
50780                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
50781                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50782                    as uint64_t,
50783                key_specs_static: [
50784                    {
50785                        let mut init = keySpec {
50786                            notes: 0 as *const libc::c_char,
50787                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50788                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
50789                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
50790                            begin_search_type: KSPEC_BS_INDEX,
50791                            bs: C2RustUnnamed_3 {
50792                                index: {
50793                                    let mut init = C2RustUnnamed_5 {
50794                                        pos: 1 as libc::c_int,
50795                                    };
50796                                    init
50797                                },
50798                            },
50799                            find_keys_type: KSPEC_FK_RANGE,
50800                            fk: C2RustUnnamed_0 {
50801                                range: {
50802                                    let mut init = C2RustUnnamed_2 {
50803                                        lastkey: 0 as libc::c_int,
50804                                        keystep: 1 as libc::c_int,
50805                                        limit: 0 as libc::c_int,
50806                                    };
50807                                    init
50808                                },
50809                            },
50810                        };
50811                        init
50812                    },
50813                    {
50814                        let mut init = keySpec {
50815                            notes: 0 as *const libc::c_char,
50816                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50817                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
50818                            begin_search_type: KSPEC_BS_INDEX,
50819                            bs: C2RustUnnamed_3 {
50820                                index: {
50821                                    let mut init = C2RustUnnamed_5 {
50822                                        pos: 2 as libc::c_int,
50823                                    };
50824                                    init
50825                                },
50826                            },
50827                            find_keys_type: KSPEC_FK_RANGE,
50828                            fk: C2RustUnnamed_0 {
50829                                range: {
50830                                    let mut init = C2RustUnnamed_2 {
50831                                        lastkey: 0 as libc::c_int,
50832                                        keystep: 1 as libc::c_int,
50833                                        limit: 0 as libc::c_int,
50834                                    };
50835                                    init
50836                                },
50837                            },
50838                        };
50839                        init
50840                    },
50841                    keySpec {
50842                        notes: 0 as *const libc::c_char,
50843                        flags: 0,
50844                        begin_search_type: KSPEC_BS_INVALID,
50845                        bs: C2RustUnnamed_3 {
50846                            index: C2RustUnnamed_5 { pos: 0 },
50847                        },
50848                        find_keys_type: KSPEC_FK_INVALID,
50849                        fk: C2RustUnnamed_0 {
50850                            range: C2RustUnnamed_2 {
50851                                lastkey: 0,
50852                                keystep: 0,
50853                                limit: 0,
50854                            },
50855                        },
50856                    },
50857                    keySpec {
50858                        notes: 0 as *const libc::c_char,
50859                        flags: 0,
50860                        begin_search_type: KSPEC_BS_INVALID,
50861                        bs: C2RustUnnamed_3 {
50862                            index: C2RustUnnamed_5 { pos: 0 },
50863                        },
50864                        find_keys_type: KSPEC_FK_INVALID,
50865                        fk: C2RustUnnamed_0 {
50866                            range: C2RustUnnamed_2 {
50867                                lastkey: 0,
50868                                keystep: 0,
50869                                limit: 0,
50870                            },
50871                        },
50872                    },
50873                ],
50874                getkeys_proc: None,
50875                subcommands: 0 as *const redisCommand as *mut redisCommand,
50876                args: LMOVE_Args.as_ptr() as *mut _,
50877                microseconds: 0,
50878                calls: 0,
50879                rejected_calls: 0,
50880                failed_calls: 0,
50881                id: 0,
50882                fullname: 0 as *const libc::c_char as *mut libc::c_char,
50883                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
50884                key_specs: 0 as *const keySpec as *mut keySpec,
50885                legacy_range_key_spec: keySpec {
50886                    notes: 0 as *const libc::c_char,
50887                    flags: 0,
50888                    begin_search_type: KSPEC_BS_INVALID,
50889                    bs: C2RustUnnamed_3 {
50890                        index: C2RustUnnamed_5 { pos: 0 },
50891                    },
50892                    find_keys_type: KSPEC_FK_INVALID,
50893                    fk: C2RustUnnamed_0 {
50894                        range: C2RustUnnamed_2 {
50895                            lastkey: 0,
50896                            keystep: 0,
50897                            limit: 0,
50898                        },
50899                    },
50900                },
50901                num_args: 0,
50902                num_history: 0,
50903                num_tips: 0,
50904                key_specs_num: 0,
50905                key_specs_max: 0,
50906                subcommands_dict: 0 as *const dict as *mut dict,
50907                parent: 0 as *const redisCommand as *mut redisCommand,
50908                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
50909            };
50910            init
50911        },
50912        {
50913            let mut init = redisCommand {
50914                declared_name: b"lmpop\0" as *const u8 as *const libc::c_char,
50915                summary: b"Pop elements from a list\0" as *const u8
50916                    as *const libc::c_char,
50917                complexity: b"O(N+M) where N is the number of provided keys and M is the number of elements returned.\0"
50918                    as *const u8 as *const libc::c_char,
50919                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
50920                doc_flags: 0 as libc::c_int,
50921                replaced_by: 0 as *const libc::c_char,
50922                deprecated_since: 0 as *const libc::c_char,
50923                group: COMMAND_GROUP_LIST,
50924                history: 0 as *const commandHistory as *mut commandHistory,
50925                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
50926                proc_0: Some(lmpopCommand as unsafe extern "C" fn(*mut client) -> ()),
50927                arity: -(4 as libc::c_int),
50928                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
50929                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
50930                    as uint64_t,
50931                key_specs_static: [
50932                    {
50933                        let mut init = keySpec {
50934                            notes: 0 as *const libc::c_char,
50935                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
50936                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
50937                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
50938                            begin_search_type: KSPEC_BS_INDEX,
50939                            bs: C2RustUnnamed_3 {
50940                                index: {
50941                                    let mut init = C2RustUnnamed_5 {
50942                                        pos: 1 as libc::c_int,
50943                                    };
50944                                    init
50945                                },
50946                            },
50947                            find_keys_type: KSPEC_FK_KEYNUM,
50948                            fk: C2RustUnnamed_0 {
50949                                keynum: {
50950                                    let mut init = C2RustUnnamed_1 {
50951                                        keynumidx: 0 as libc::c_int,
50952                                        firstkey: 1 as libc::c_int,
50953                                        keystep: 1 as libc::c_int,
50954                                    };
50955                                    init
50956                                },
50957                            },
50958                        };
50959                        init
50960                    },
50961                    keySpec {
50962                        notes: 0 as *const libc::c_char,
50963                        flags: 0,
50964                        begin_search_type: KSPEC_BS_INVALID,
50965                        bs: C2RustUnnamed_3 {
50966                            index: C2RustUnnamed_5 { pos: 0 },
50967                        },
50968                        find_keys_type: KSPEC_FK_INVALID,
50969                        fk: C2RustUnnamed_0 {
50970                            range: C2RustUnnamed_2 {
50971                                lastkey: 0,
50972                                keystep: 0,
50973                                limit: 0,
50974                            },
50975                        },
50976                    },
50977                    keySpec {
50978                        notes: 0 as *const libc::c_char,
50979                        flags: 0,
50980                        begin_search_type: KSPEC_BS_INVALID,
50981                        bs: C2RustUnnamed_3 {
50982                            index: C2RustUnnamed_5 { pos: 0 },
50983                        },
50984                        find_keys_type: KSPEC_FK_INVALID,
50985                        fk: C2RustUnnamed_0 {
50986                            range: C2RustUnnamed_2 {
50987                                lastkey: 0,
50988                                keystep: 0,
50989                                limit: 0,
50990                            },
50991                        },
50992                    },
50993                    keySpec {
50994                        notes: 0 as *const libc::c_char,
50995                        flags: 0,
50996                        begin_search_type: KSPEC_BS_INVALID,
50997                        bs: C2RustUnnamed_3 {
50998                            index: C2RustUnnamed_5 { pos: 0 },
50999                        },
51000                        find_keys_type: KSPEC_FK_INVALID,
51001                        fk: C2RustUnnamed_0 {
51002                            range: C2RustUnnamed_2 {
51003                                lastkey: 0,
51004                                keystep: 0,
51005                                limit: 0,
51006                            },
51007                        },
51008                    },
51009                ],
51010                getkeys_proc: Some(
51011                    lmpopGetKeys
51012                        as unsafe extern "C" fn(
51013                            *mut redisCommand,
51014                            *mut *mut robj,
51015                            libc::c_int,
51016                            *mut getKeysResult,
51017                        ) -> libc::c_int,
51018                ),
51019                subcommands: 0 as *const redisCommand as *mut redisCommand,
51020                args: LMPOP_Args.as_ptr() as *mut _,
51021                microseconds: 0,
51022                calls: 0,
51023                rejected_calls: 0,
51024                failed_calls: 0,
51025                id: 0,
51026                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51027                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51028                key_specs: 0 as *const keySpec as *mut keySpec,
51029                legacy_range_key_spec: keySpec {
51030                    notes: 0 as *const libc::c_char,
51031                    flags: 0,
51032                    begin_search_type: KSPEC_BS_INVALID,
51033                    bs: C2RustUnnamed_3 {
51034                        index: C2RustUnnamed_5 { pos: 0 },
51035                    },
51036                    find_keys_type: KSPEC_FK_INVALID,
51037                    fk: C2RustUnnamed_0 {
51038                        range: C2RustUnnamed_2 {
51039                            lastkey: 0,
51040                            keystep: 0,
51041                            limit: 0,
51042                        },
51043                    },
51044                },
51045                num_args: 0,
51046                num_history: 0,
51047                num_tips: 0,
51048                key_specs_num: 0,
51049                key_specs_max: 0,
51050                subcommands_dict: 0 as *const dict as *mut dict,
51051                parent: 0 as *const redisCommand as *mut redisCommand,
51052                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51053            };
51054            init
51055        },
51056        {
51057            let mut init = redisCommand {
51058                declared_name: b"lpop\0" as *const u8 as *const libc::c_char,
51059                summary: b"Remove and get the first elements in a list\0" as *const u8
51060                    as *const libc::c_char,
51061                complexity: b"O(N) where N is the number of elements returned\0"
51062                    as *const u8 as *const libc::c_char,
51063                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
51064                doc_flags: 0 as libc::c_int,
51065                replaced_by: 0 as *const libc::c_char,
51066                deprecated_since: 0 as *const libc::c_char,
51067                group: COMMAND_GROUP_LIST,
51068                history: LPOP_History.as_ptr() as *mut _,
51069                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51070                proc_0: Some(lpopCommand as unsafe extern "C" fn(*mut client) -> ()),
51071                arity: -(2 as libc::c_int),
51072                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51073                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
51074                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51075                    as uint64_t,
51076                key_specs_static: [
51077                    {
51078                        let mut init = keySpec {
51079                            notes: 0 as *const libc::c_char,
51080                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
51081                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
51082                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
51083                            begin_search_type: KSPEC_BS_INDEX,
51084                            bs: C2RustUnnamed_3 {
51085                                index: {
51086                                    let mut init = C2RustUnnamed_5 {
51087                                        pos: 1 as libc::c_int,
51088                                    };
51089                                    init
51090                                },
51091                            },
51092                            find_keys_type: KSPEC_FK_RANGE,
51093                            fk: C2RustUnnamed_0 {
51094                                range: {
51095                                    let mut init = C2RustUnnamed_2 {
51096                                        lastkey: 0 as libc::c_int,
51097                                        keystep: 1 as libc::c_int,
51098                                        limit: 0 as libc::c_int,
51099                                    };
51100                                    init
51101                                },
51102                            },
51103                        };
51104                        init
51105                    },
51106                    keySpec {
51107                        notes: 0 as *const libc::c_char,
51108                        flags: 0,
51109                        begin_search_type: KSPEC_BS_INVALID,
51110                        bs: C2RustUnnamed_3 {
51111                            index: C2RustUnnamed_5 { pos: 0 },
51112                        },
51113                        find_keys_type: KSPEC_FK_INVALID,
51114                        fk: C2RustUnnamed_0 {
51115                            range: C2RustUnnamed_2 {
51116                                lastkey: 0,
51117                                keystep: 0,
51118                                limit: 0,
51119                            },
51120                        },
51121                    },
51122                    keySpec {
51123                        notes: 0 as *const libc::c_char,
51124                        flags: 0,
51125                        begin_search_type: KSPEC_BS_INVALID,
51126                        bs: C2RustUnnamed_3 {
51127                            index: C2RustUnnamed_5 { pos: 0 },
51128                        },
51129                        find_keys_type: KSPEC_FK_INVALID,
51130                        fk: C2RustUnnamed_0 {
51131                            range: C2RustUnnamed_2 {
51132                                lastkey: 0,
51133                                keystep: 0,
51134                                limit: 0,
51135                            },
51136                        },
51137                    },
51138                    keySpec {
51139                        notes: 0 as *const libc::c_char,
51140                        flags: 0,
51141                        begin_search_type: KSPEC_BS_INVALID,
51142                        bs: C2RustUnnamed_3 {
51143                            index: C2RustUnnamed_5 { pos: 0 },
51144                        },
51145                        find_keys_type: KSPEC_FK_INVALID,
51146                        fk: C2RustUnnamed_0 {
51147                            range: C2RustUnnamed_2 {
51148                                lastkey: 0,
51149                                keystep: 0,
51150                                limit: 0,
51151                            },
51152                        },
51153                    },
51154                ],
51155                getkeys_proc: None,
51156                subcommands: 0 as *const redisCommand as *mut redisCommand,
51157                args: LPOP_Args.as_ptr() as *mut _,
51158                microseconds: 0,
51159                calls: 0,
51160                rejected_calls: 0,
51161                failed_calls: 0,
51162                id: 0,
51163                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51164                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51165                key_specs: 0 as *const keySpec as *mut keySpec,
51166                legacy_range_key_spec: keySpec {
51167                    notes: 0 as *const libc::c_char,
51168                    flags: 0,
51169                    begin_search_type: KSPEC_BS_INVALID,
51170                    bs: C2RustUnnamed_3 {
51171                        index: C2RustUnnamed_5 { pos: 0 },
51172                    },
51173                    find_keys_type: KSPEC_FK_INVALID,
51174                    fk: C2RustUnnamed_0 {
51175                        range: C2RustUnnamed_2 {
51176                            lastkey: 0,
51177                            keystep: 0,
51178                            limit: 0,
51179                        },
51180                    },
51181                },
51182                num_args: 0,
51183                num_history: 0,
51184                num_tips: 0,
51185                key_specs_num: 0,
51186                key_specs_max: 0,
51187                subcommands_dict: 0 as *const dict as *mut dict,
51188                parent: 0 as *const redisCommand as *mut redisCommand,
51189                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51190            };
51191            init
51192        },
51193        {
51194            let mut init = redisCommand {
51195                declared_name: b"lpos\0" as *const u8 as *const libc::c_char,
51196                summary: b"Return the index of matching elements on a list\0"
51197                    as *const u8 as *const libc::c_char,
51198                complexity: b"O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.\0"
51199                    as *const u8 as *const libc::c_char,
51200                since: b"6.0.6\0" as *const u8 as *const libc::c_char,
51201                doc_flags: 0 as libc::c_int,
51202                replaced_by: 0 as *const libc::c_char,
51203                deprecated_since: 0 as *const libc::c_char,
51204                group: COMMAND_GROUP_LIST,
51205                history: 0 as *const commandHistory as *mut commandHistory,
51206                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51207                proc_0: Some(lposCommand as unsafe extern "C" fn(*mut client) -> ()),
51208                arity: -(3 as libc::c_int),
51209                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
51210                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51211                    as uint64_t,
51212                key_specs_static: [
51213                    {
51214                        let mut init = keySpec {
51215                            notes: 0 as *const libc::c_char,
51216                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51217                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
51218                            begin_search_type: KSPEC_BS_INDEX,
51219                            bs: C2RustUnnamed_3 {
51220                                index: {
51221                                    let mut init = C2RustUnnamed_5 {
51222                                        pos: 1 as libc::c_int,
51223                                    };
51224                                    init
51225                                },
51226                            },
51227                            find_keys_type: KSPEC_FK_RANGE,
51228                            fk: C2RustUnnamed_0 {
51229                                range: {
51230                                    let mut init = C2RustUnnamed_2 {
51231                                        lastkey: 0 as libc::c_int,
51232                                        keystep: 1 as libc::c_int,
51233                                        limit: 0 as libc::c_int,
51234                                    };
51235                                    init
51236                                },
51237                            },
51238                        };
51239                        init
51240                    },
51241                    keySpec {
51242                        notes: 0 as *const libc::c_char,
51243                        flags: 0,
51244                        begin_search_type: KSPEC_BS_INVALID,
51245                        bs: C2RustUnnamed_3 {
51246                            index: C2RustUnnamed_5 { pos: 0 },
51247                        },
51248                        find_keys_type: KSPEC_FK_INVALID,
51249                        fk: C2RustUnnamed_0 {
51250                            range: C2RustUnnamed_2 {
51251                                lastkey: 0,
51252                                keystep: 0,
51253                                limit: 0,
51254                            },
51255                        },
51256                    },
51257                    keySpec {
51258                        notes: 0 as *const libc::c_char,
51259                        flags: 0,
51260                        begin_search_type: KSPEC_BS_INVALID,
51261                        bs: C2RustUnnamed_3 {
51262                            index: C2RustUnnamed_5 { pos: 0 },
51263                        },
51264                        find_keys_type: KSPEC_FK_INVALID,
51265                        fk: C2RustUnnamed_0 {
51266                            range: C2RustUnnamed_2 {
51267                                lastkey: 0,
51268                                keystep: 0,
51269                                limit: 0,
51270                            },
51271                        },
51272                    },
51273                    keySpec {
51274                        notes: 0 as *const libc::c_char,
51275                        flags: 0,
51276                        begin_search_type: KSPEC_BS_INVALID,
51277                        bs: C2RustUnnamed_3 {
51278                            index: C2RustUnnamed_5 { pos: 0 },
51279                        },
51280                        find_keys_type: KSPEC_FK_INVALID,
51281                        fk: C2RustUnnamed_0 {
51282                            range: C2RustUnnamed_2 {
51283                                lastkey: 0,
51284                                keystep: 0,
51285                                limit: 0,
51286                            },
51287                        },
51288                    },
51289                ],
51290                getkeys_proc: None,
51291                subcommands: 0 as *const redisCommand as *mut redisCommand,
51292                args: LPOS_Args.as_ptr() as *mut _,
51293                microseconds: 0,
51294                calls: 0,
51295                rejected_calls: 0,
51296                failed_calls: 0,
51297                id: 0,
51298                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51299                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51300                key_specs: 0 as *const keySpec as *mut keySpec,
51301                legacy_range_key_spec: keySpec {
51302                    notes: 0 as *const libc::c_char,
51303                    flags: 0,
51304                    begin_search_type: KSPEC_BS_INVALID,
51305                    bs: C2RustUnnamed_3 {
51306                        index: C2RustUnnamed_5 { pos: 0 },
51307                    },
51308                    find_keys_type: KSPEC_FK_INVALID,
51309                    fk: C2RustUnnamed_0 {
51310                        range: C2RustUnnamed_2 {
51311                            lastkey: 0,
51312                            keystep: 0,
51313                            limit: 0,
51314                        },
51315                    },
51316                },
51317                num_args: 0,
51318                num_history: 0,
51319                num_tips: 0,
51320                key_specs_num: 0,
51321                key_specs_max: 0,
51322                subcommands_dict: 0 as *const dict as *mut dict,
51323                parent: 0 as *const redisCommand as *mut redisCommand,
51324                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51325            };
51326            init
51327        },
51328        {
51329            let mut init = redisCommand {
51330                declared_name: b"lpush\0" as *const u8 as *const libc::c_char,
51331                summary: b"Prepend one or multiple elements to a list\0" as *const u8
51332                    as *const libc::c_char,
51333                complexity: b"O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.\0"
51334                    as *const u8 as *const libc::c_char,
51335                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
51336                doc_flags: 0 as libc::c_int,
51337                replaced_by: 0 as *const libc::c_char,
51338                deprecated_since: 0 as *const libc::c_char,
51339                group: COMMAND_GROUP_LIST,
51340                history: LPUSH_History.as_ptr() as *mut _,
51341                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51342                proc_0: Some(lpushCommand as unsafe extern "C" fn(*mut client) -> ()),
51343                arity: -(3 as libc::c_int),
51344                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51345                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
51346                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
51347                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51348                    as uint64_t,
51349                key_specs_static: [
51350                    {
51351                        let mut init = keySpec {
51352                            notes: 0 as *const libc::c_char,
51353                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
51354                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
51355                            begin_search_type: KSPEC_BS_INDEX,
51356                            bs: C2RustUnnamed_3 {
51357                                index: {
51358                                    let mut init = C2RustUnnamed_5 {
51359                                        pos: 1 as libc::c_int,
51360                                    };
51361                                    init
51362                                },
51363                            },
51364                            find_keys_type: KSPEC_FK_RANGE,
51365                            fk: C2RustUnnamed_0 {
51366                                range: {
51367                                    let mut init = C2RustUnnamed_2 {
51368                                        lastkey: 0 as libc::c_int,
51369                                        keystep: 1 as libc::c_int,
51370                                        limit: 0 as libc::c_int,
51371                                    };
51372                                    init
51373                                },
51374                            },
51375                        };
51376                        init
51377                    },
51378                    keySpec {
51379                        notes: 0 as *const libc::c_char,
51380                        flags: 0,
51381                        begin_search_type: KSPEC_BS_INVALID,
51382                        bs: C2RustUnnamed_3 {
51383                            index: C2RustUnnamed_5 { pos: 0 },
51384                        },
51385                        find_keys_type: KSPEC_FK_INVALID,
51386                        fk: C2RustUnnamed_0 {
51387                            range: C2RustUnnamed_2 {
51388                                lastkey: 0,
51389                                keystep: 0,
51390                                limit: 0,
51391                            },
51392                        },
51393                    },
51394                    keySpec {
51395                        notes: 0 as *const libc::c_char,
51396                        flags: 0,
51397                        begin_search_type: KSPEC_BS_INVALID,
51398                        bs: C2RustUnnamed_3 {
51399                            index: C2RustUnnamed_5 { pos: 0 },
51400                        },
51401                        find_keys_type: KSPEC_FK_INVALID,
51402                        fk: C2RustUnnamed_0 {
51403                            range: C2RustUnnamed_2 {
51404                                lastkey: 0,
51405                                keystep: 0,
51406                                limit: 0,
51407                            },
51408                        },
51409                    },
51410                    keySpec {
51411                        notes: 0 as *const libc::c_char,
51412                        flags: 0,
51413                        begin_search_type: KSPEC_BS_INVALID,
51414                        bs: C2RustUnnamed_3 {
51415                            index: C2RustUnnamed_5 { pos: 0 },
51416                        },
51417                        find_keys_type: KSPEC_FK_INVALID,
51418                        fk: C2RustUnnamed_0 {
51419                            range: C2RustUnnamed_2 {
51420                                lastkey: 0,
51421                                keystep: 0,
51422                                limit: 0,
51423                            },
51424                        },
51425                    },
51426                ],
51427                getkeys_proc: None,
51428                subcommands: 0 as *const redisCommand as *mut redisCommand,
51429                args: LPUSH_Args.as_ptr() as *mut _,
51430                microseconds: 0,
51431                calls: 0,
51432                rejected_calls: 0,
51433                failed_calls: 0,
51434                id: 0,
51435                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51436                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51437                key_specs: 0 as *const keySpec as *mut keySpec,
51438                legacy_range_key_spec: keySpec {
51439                    notes: 0 as *const libc::c_char,
51440                    flags: 0,
51441                    begin_search_type: KSPEC_BS_INVALID,
51442                    bs: C2RustUnnamed_3 {
51443                        index: C2RustUnnamed_5 { pos: 0 },
51444                    },
51445                    find_keys_type: KSPEC_FK_INVALID,
51446                    fk: C2RustUnnamed_0 {
51447                        range: C2RustUnnamed_2 {
51448                            lastkey: 0,
51449                            keystep: 0,
51450                            limit: 0,
51451                        },
51452                    },
51453                },
51454                num_args: 0,
51455                num_history: 0,
51456                num_tips: 0,
51457                key_specs_num: 0,
51458                key_specs_max: 0,
51459                subcommands_dict: 0 as *const dict as *mut dict,
51460                parent: 0 as *const redisCommand as *mut redisCommand,
51461                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51462            };
51463            init
51464        },
51465        {
51466            let mut init = redisCommand {
51467                declared_name: b"lpushx\0" as *const u8 as *const libc::c_char,
51468                summary: b"Prepend an element to a list, only if the list exists\0"
51469                    as *const u8 as *const libc::c_char,
51470                complexity: b"O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.\0"
51471                    as *const u8 as *const libc::c_char,
51472                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
51473                doc_flags: 0 as libc::c_int,
51474                replaced_by: 0 as *const libc::c_char,
51475                deprecated_since: 0 as *const libc::c_char,
51476                group: COMMAND_GROUP_LIST,
51477                history: LPUSHX_History.as_ptr() as *mut _,
51478                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51479                proc_0: Some(lpushxCommand as unsafe extern "C" fn(*mut client) -> ()),
51480                arity: -(3 as libc::c_int),
51481                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51482                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
51483                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
51484                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51485                    as uint64_t,
51486                key_specs_static: [
51487                    {
51488                        let mut init = keySpec {
51489                            notes: 0 as *const libc::c_char,
51490                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
51491                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
51492                            begin_search_type: KSPEC_BS_INDEX,
51493                            bs: C2RustUnnamed_3 {
51494                                index: {
51495                                    let mut init = C2RustUnnamed_5 {
51496                                        pos: 1 as libc::c_int,
51497                                    };
51498                                    init
51499                                },
51500                            },
51501                            find_keys_type: KSPEC_FK_RANGE,
51502                            fk: C2RustUnnamed_0 {
51503                                range: {
51504                                    let mut init = C2RustUnnamed_2 {
51505                                        lastkey: 0 as libc::c_int,
51506                                        keystep: 1 as libc::c_int,
51507                                        limit: 0 as libc::c_int,
51508                                    };
51509                                    init
51510                                },
51511                            },
51512                        };
51513                        init
51514                    },
51515                    keySpec {
51516                        notes: 0 as *const libc::c_char,
51517                        flags: 0,
51518                        begin_search_type: KSPEC_BS_INVALID,
51519                        bs: C2RustUnnamed_3 {
51520                            index: C2RustUnnamed_5 { pos: 0 },
51521                        },
51522                        find_keys_type: KSPEC_FK_INVALID,
51523                        fk: C2RustUnnamed_0 {
51524                            range: C2RustUnnamed_2 {
51525                                lastkey: 0,
51526                                keystep: 0,
51527                                limit: 0,
51528                            },
51529                        },
51530                    },
51531                    keySpec {
51532                        notes: 0 as *const libc::c_char,
51533                        flags: 0,
51534                        begin_search_type: KSPEC_BS_INVALID,
51535                        bs: C2RustUnnamed_3 {
51536                            index: C2RustUnnamed_5 { pos: 0 },
51537                        },
51538                        find_keys_type: KSPEC_FK_INVALID,
51539                        fk: C2RustUnnamed_0 {
51540                            range: C2RustUnnamed_2 {
51541                                lastkey: 0,
51542                                keystep: 0,
51543                                limit: 0,
51544                            },
51545                        },
51546                    },
51547                    keySpec {
51548                        notes: 0 as *const libc::c_char,
51549                        flags: 0,
51550                        begin_search_type: KSPEC_BS_INVALID,
51551                        bs: C2RustUnnamed_3 {
51552                            index: C2RustUnnamed_5 { pos: 0 },
51553                        },
51554                        find_keys_type: KSPEC_FK_INVALID,
51555                        fk: C2RustUnnamed_0 {
51556                            range: C2RustUnnamed_2 {
51557                                lastkey: 0,
51558                                keystep: 0,
51559                                limit: 0,
51560                            },
51561                        },
51562                    },
51563                ],
51564                getkeys_proc: None,
51565                subcommands: 0 as *const redisCommand as *mut redisCommand,
51566                args: LPUSHX_Args.as_ptr() as *mut _,
51567                microseconds: 0,
51568                calls: 0,
51569                rejected_calls: 0,
51570                failed_calls: 0,
51571                id: 0,
51572                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51573                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51574                key_specs: 0 as *const keySpec as *mut keySpec,
51575                legacy_range_key_spec: keySpec {
51576                    notes: 0 as *const libc::c_char,
51577                    flags: 0,
51578                    begin_search_type: KSPEC_BS_INVALID,
51579                    bs: C2RustUnnamed_3 {
51580                        index: C2RustUnnamed_5 { pos: 0 },
51581                    },
51582                    find_keys_type: KSPEC_FK_INVALID,
51583                    fk: C2RustUnnamed_0 {
51584                        range: C2RustUnnamed_2 {
51585                            lastkey: 0,
51586                            keystep: 0,
51587                            limit: 0,
51588                        },
51589                    },
51590                },
51591                num_args: 0,
51592                num_history: 0,
51593                num_tips: 0,
51594                key_specs_num: 0,
51595                key_specs_max: 0,
51596                subcommands_dict: 0 as *const dict as *mut dict,
51597                parent: 0 as *const redisCommand as *mut redisCommand,
51598                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51599            };
51600            init
51601        },
51602        {
51603            let mut init = redisCommand {
51604                declared_name: b"lrange\0" as *const u8 as *const libc::c_char,
51605                summary: b"Get a range of elements from a list\0" as *const u8
51606                    as *const libc::c_char,
51607                complexity: b"O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.\0"
51608                    as *const u8 as *const libc::c_char,
51609                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
51610                doc_flags: 0 as libc::c_int,
51611                replaced_by: 0 as *const libc::c_char,
51612                deprecated_since: 0 as *const libc::c_char,
51613                group: COMMAND_GROUP_LIST,
51614                history: 0 as *const commandHistory as *mut commandHistory,
51615                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51616                proc_0: Some(lrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
51617                arity: 4 as libc::c_int,
51618                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
51619                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51620                    as uint64_t,
51621                key_specs_static: [
51622                    {
51623                        let mut init = keySpec {
51624                            notes: 0 as *const libc::c_char,
51625                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51626                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
51627                            begin_search_type: KSPEC_BS_INDEX,
51628                            bs: C2RustUnnamed_3 {
51629                                index: {
51630                                    let mut init = C2RustUnnamed_5 {
51631                                        pos: 1 as libc::c_int,
51632                                    };
51633                                    init
51634                                },
51635                            },
51636                            find_keys_type: KSPEC_FK_RANGE,
51637                            fk: C2RustUnnamed_0 {
51638                                range: {
51639                                    let mut init = C2RustUnnamed_2 {
51640                                        lastkey: 0 as libc::c_int,
51641                                        keystep: 1 as libc::c_int,
51642                                        limit: 0 as libc::c_int,
51643                                    };
51644                                    init
51645                                },
51646                            },
51647                        };
51648                        init
51649                    },
51650                    keySpec {
51651                        notes: 0 as *const libc::c_char,
51652                        flags: 0,
51653                        begin_search_type: KSPEC_BS_INVALID,
51654                        bs: C2RustUnnamed_3 {
51655                            index: C2RustUnnamed_5 { pos: 0 },
51656                        },
51657                        find_keys_type: KSPEC_FK_INVALID,
51658                        fk: C2RustUnnamed_0 {
51659                            range: C2RustUnnamed_2 {
51660                                lastkey: 0,
51661                                keystep: 0,
51662                                limit: 0,
51663                            },
51664                        },
51665                    },
51666                    keySpec {
51667                        notes: 0 as *const libc::c_char,
51668                        flags: 0,
51669                        begin_search_type: KSPEC_BS_INVALID,
51670                        bs: C2RustUnnamed_3 {
51671                            index: C2RustUnnamed_5 { pos: 0 },
51672                        },
51673                        find_keys_type: KSPEC_FK_INVALID,
51674                        fk: C2RustUnnamed_0 {
51675                            range: C2RustUnnamed_2 {
51676                                lastkey: 0,
51677                                keystep: 0,
51678                                limit: 0,
51679                            },
51680                        },
51681                    },
51682                    keySpec {
51683                        notes: 0 as *const libc::c_char,
51684                        flags: 0,
51685                        begin_search_type: KSPEC_BS_INVALID,
51686                        bs: C2RustUnnamed_3 {
51687                            index: C2RustUnnamed_5 { pos: 0 },
51688                        },
51689                        find_keys_type: KSPEC_FK_INVALID,
51690                        fk: C2RustUnnamed_0 {
51691                            range: C2RustUnnamed_2 {
51692                                lastkey: 0,
51693                                keystep: 0,
51694                                limit: 0,
51695                            },
51696                        },
51697                    },
51698                ],
51699                getkeys_proc: None,
51700                subcommands: 0 as *const redisCommand as *mut redisCommand,
51701                args: LRANGE_Args.as_ptr() as *mut _,
51702                microseconds: 0,
51703                calls: 0,
51704                rejected_calls: 0,
51705                failed_calls: 0,
51706                id: 0,
51707                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51708                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51709                key_specs: 0 as *const keySpec as *mut keySpec,
51710                legacy_range_key_spec: keySpec {
51711                    notes: 0 as *const libc::c_char,
51712                    flags: 0,
51713                    begin_search_type: KSPEC_BS_INVALID,
51714                    bs: C2RustUnnamed_3 {
51715                        index: C2RustUnnamed_5 { pos: 0 },
51716                    },
51717                    find_keys_type: KSPEC_FK_INVALID,
51718                    fk: C2RustUnnamed_0 {
51719                        range: C2RustUnnamed_2 {
51720                            lastkey: 0,
51721                            keystep: 0,
51722                            limit: 0,
51723                        },
51724                    },
51725                },
51726                num_args: 0,
51727                num_history: 0,
51728                num_tips: 0,
51729                key_specs_num: 0,
51730                key_specs_max: 0,
51731                subcommands_dict: 0 as *const dict as *mut dict,
51732                parent: 0 as *const redisCommand as *mut redisCommand,
51733                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51734            };
51735            init
51736        },
51737        {
51738            let mut init = redisCommand {
51739                declared_name: b"lrem\0" as *const u8 as *const libc::c_char,
51740                summary: b"Remove elements from a list\0" as *const u8
51741                    as *const libc::c_char,
51742                complexity: b"O(N+M) where N is the length of the list and M is the number of elements removed.\0"
51743                    as *const u8 as *const libc::c_char,
51744                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
51745                doc_flags: 0 as libc::c_int,
51746                replaced_by: 0 as *const libc::c_char,
51747                deprecated_since: 0 as *const libc::c_char,
51748                group: COMMAND_GROUP_LIST,
51749                history: 0 as *const commandHistory as *mut commandHistory,
51750                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51751                proc_0: Some(lremCommand as unsafe extern "C" fn(*mut client) -> ()),
51752                arity: 4 as libc::c_int,
51753                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
51754                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51755                    as uint64_t,
51756                key_specs_static: [
51757                    {
51758                        let mut init = keySpec {
51759                            notes: 0 as *const libc::c_char,
51760                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
51761                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
51762                            begin_search_type: KSPEC_BS_INDEX,
51763                            bs: C2RustUnnamed_3 {
51764                                index: {
51765                                    let mut init = C2RustUnnamed_5 {
51766                                        pos: 1 as libc::c_int,
51767                                    };
51768                                    init
51769                                },
51770                            },
51771                            find_keys_type: KSPEC_FK_RANGE,
51772                            fk: C2RustUnnamed_0 {
51773                                range: {
51774                                    let mut init = C2RustUnnamed_2 {
51775                                        lastkey: 0 as libc::c_int,
51776                                        keystep: 1 as libc::c_int,
51777                                        limit: 0 as libc::c_int,
51778                                    };
51779                                    init
51780                                },
51781                            },
51782                        };
51783                        init
51784                    },
51785                    keySpec {
51786                        notes: 0 as *const libc::c_char,
51787                        flags: 0,
51788                        begin_search_type: KSPEC_BS_INVALID,
51789                        bs: C2RustUnnamed_3 {
51790                            index: C2RustUnnamed_5 { pos: 0 },
51791                        },
51792                        find_keys_type: KSPEC_FK_INVALID,
51793                        fk: C2RustUnnamed_0 {
51794                            range: C2RustUnnamed_2 {
51795                                lastkey: 0,
51796                                keystep: 0,
51797                                limit: 0,
51798                            },
51799                        },
51800                    },
51801                    keySpec {
51802                        notes: 0 as *const libc::c_char,
51803                        flags: 0,
51804                        begin_search_type: KSPEC_BS_INVALID,
51805                        bs: C2RustUnnamed_3 {
51806                            index: C2RustUnnamed_5 { pos: 0 },
51807                        },
51808                        find_keys_type: KSPEC_FK_INVALID,
51809                        fk: C2RustUnnamed_0 {
51810                            range: C2RustUnnamed_2 {
51811                                lastkey: 0,
51812                                keystep: 0,
51813                                limit: 0,
51814                            },
51815                        },
51816                    },
51817                    keySpec {
51818                        notes: 0 as *const libc::c_char,
51819                        flags: 0,
51820                        begin_search_type: KSPEC_BS_INVALID,
51821                        bs: C2RustUnnamed_3 {
51822                            index: C2RustUnnamed_5 { pos: 0 },
51823                        },
51824                        find_keys_type: KSPEC_FK_INVALID,
51825                        fk: C2RustUnnamed_0 {
51826                            range: C2RustUnnamed_2 {
51827                                lastkey: 0,
51828                                keystep: 0,
51829                                limit: 0,
51830                            },
51831                        },
51832                    },
51833                ],
51834                getkeys_proc: None,
51835                subcommands: 0 as *const redisCommand as *mut redisCommand,
51836                args: LREM_Args.as_ptr() as *mut _,
51837                microseconds: 0,
51838                calls: 0,
51839                rejected_calls: 0,
51840                failed_calls: 0,
51841                id: 0,
51842                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51843                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51844                key_specs: 0 as *const keySpec as *mut keySpec,
51845                legacy_range_key_spec: keySpec {
51846                    notes: 0 as *const libc::c_char,
51847                    flags: 0,
51848                    begin_search_type: KSPEC_BS_INVALID,
51849                    bs: C2RustUnnamed_3 {
51850                        index: C2RustUnnamed_5 { pos: 0 },
51851                    },
51852                    find_keys_type: KSPEC_FK_INVALID,
51853                    fk: C2RustUnnamed_0 {
51854                        range: C2RustUnnamed_2 {
51855                            lastkey: 0,
51856                            keystep: 0,
51857                            limit: 0,
51858                        },
51859                    },
51860                },
51861                num_args: 0,
51862                num_history: 0,
51863                num_tips: 0,
51864                key_specs_num: 0,
51865                key_specs_max: 0,
51866                subcommands_dict: 0 as *const dict as *mut dict,
51867                parent: 0 as *const redisCommand as *mut redisCommand,
51868                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
51869            };
51870            init
51871        },
51872        {
51873            let mut init = redisCommand {
51874                declared_name: b"lset\0" as *const u8 as *const libc::c_char,
51875                summary: b"Set the value of an element in a list by its index\0"
51876                    as *const u8 as *const libc::c_char,
51877                complexity: b"O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).\0"
51878                    as *const u8 as *const libc::c_char,
51879                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
51880                doc_flags: 0 as libc::c_int,
51881                replaced_by: 0 as *const libc::c_char,
51882                deprecated_since: 0 as *const libc::c_char,
51883                group: COMMAND_GROUP_LIST,
51884                history: 0 as *const commandHistory as *mut commandHistory,
51885                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
51886                proc_0: Some(lsetCommand as unsafe extern "C" fn(*mut client) -> ()),
51887                arity: 4 as libc::c_int,
51888                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
51889                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
51890                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
51891                    as uint64_t,
51892                key_specs_static: [
51893                    {
51894                        let mut init = keySpec {
51895                            notes: 0 as *const libc::c_char,
51896                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
51897                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
51898                            begin_search_type: KSPEC_BS_INDEX,
51899                            bs: C2RustUnnamed_3 {
51900                                index: {
51901                                    let mut init = C2RustUnnamed_5 {
51902                                        pos: 1 as libc::c_int,
51903                                    };
51904                                    init
51905                                },
51906                            },
51907                            find_keys_type: KSPEC_FK_RANGE,
51908                            fk: C2RustUnnamed_0 {
51909                                range: {
51910                                    let mut init = C2RustUnnamed_2 {
51911                                        lastkey: 0 as libc::c_int,
51912                                        keystep: 1 as libc::c_int,
51913                                        limit: 0 as libc::c_int,
51914                                    };
51915                                    init
51916                                },
51917                            },
51918                        };
51919                        init
51920                    },
51921                    keySpec {
51922                        notes: 0 as *const libc::c_char,
51923                        flags: 0,
51924                        begin_search_type: KSPEC_BS_INVALID,
51925                        bs: C2RustUnnamed_3 {
51926                            index: C2RustUnnamed_5 { pos: 0 },
51927                        },
51928                        find_keys_type: KSPEC_FK_INVALID,
51929                        fk: C2RustUnnamed_0 {
51930                            range: C2RustUnnamed_2 {
51931                                lastkey: 0,
51932                                keystep: 0,
51933                                limit: 0,
51934                            },
51935                        },
51936                    },
51937                    keySpec {
51938                        notes: 0 as *const libc::c_char,
51939                        flags: 0,
51940                        begin_search_type: KSPEC_BS_INVALID,
51941                        bs: C2RustUnnamed_3 {
51942                            index: C2RustUnnamed_5 { pos: 0 },
51943                        },
51944                        find_keys_type: KSPEC_FK_INVALID,
51945                        fk: C2RustUnnamed_0 {
51946                            range: C2RustUnnamed_2 {
51947                                lastkey: 0,
51948                                keystep: 0,
51949                                limit: 0,
51950                            },
51951                        },
51952                    },
51953                    keySpec {
51954                        notes: 0 as *const libc::c_char,
51955                        flags: 0,
51956                        begin_search_type: KSPEC_BS_INVALID,
51957                        bs: C2RustUnnamed_3 {
51958                            index: C2RustUnnamed_5 { pos: 0 },
51959                        },
51960                        find_keys_type: KSPEC_FK_INVALID,
51961                        fk: C2RustUnnamed_0 {
51962                            range: C2RustUnnamed_2 {
51963                                lastkey: 0,
51964                                keystep: 0,
51965                                limit: 0,
51966                            },
51967                        },
51968                    },
51969                ],
51970                getkeys_proc: None,
51971                subcommands: 0 as *const redisCommand as *mut redisCommand,
51972                args: LSET_Args.as_ptr() as *mut _,
51973                microseconds: 0,
51974                calls: 0,
51975                rejected_calls: 0,
51976                failed_calls: 0,
51977                id: 0,
51978                fullname: 0 as *const libc::c_char as *mut libc::c_char,
51979                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
51980                key_specs: 0 as *const keySpec as *mut keySpec,
51981                legacy_range_key_spec: keySpec {
51982                    notes: 0 as *const libc::c_char,
51983                    flags: 0,
51984                    begin_search_type: KSPEC_BS_INVALID,
51985                    bs: C2RustUnnamed_3 {
51986                        index: C2RustUnnamed_5 { pos: 0 },
51987                    },
51988                    find_keys_type: KSPEC_FK_INVALID,
51989                    fk: C2RustUnnamed_0 {
51990                        range: C2RustUnnamed_2 {
51991                            lastkey: 0,
51992                            keystep: 0,
51993                            limit: 0,
51994                        },
51995                    },
51996                },
51997                num_args: 0,
51998                num_history: 0,
51999                num_tips: 0,
52000                key_specs_num: 0,
52001                key_specs_max: 0,
52002                subcommands_dict: 0 as *const dict as *mut dict,
52003                parent: 0 as *const redisCommand as *mut redisCommand,
52004                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52005            };
52006            init
52007        },
52008        {
52009            let mut init = redisCommand {
52010                declared_name: b"ltrim\0" as *const u8 as *const libc::c_char,
52011                summary: b"Trim a list to the specified range\0" as *const u8
52012                    as *const libc::c_char,
52013                complexity: b"O(N) where N is the number of elements to be removed by the operation.\0"
52014                    as *const u8 as *const libc::c_char,
52015                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
52016                doc_flags: 0 as libc::c_int,
52017                replaced_by: 0 as *const libc::c_char,
52018                deprecated_since: 0 as *const libc::c_char,
52019                group: COMMAND_GROUP_LIST,
52020                history: 0 as *const commandHistory as *mut commandHistory,
52021                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52022                proc_0: Some(ltrimCommand as unsafe extern "C" fn(*mut client) -> ()),
52023                arity: 4 as libc::c_int,
52024                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
52025                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
52026                    as uint64_t,
52027                key_specs_static: [
52028                    {
52029                        let mut init = keySpec {
52030                            notes: 0 as *const libc::c_char,
52031                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52032                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
52033                            begin_search_type: KSPEC_BS_INDEX,
52034                            bs: C2RustUnnamed_3 {
52035                                index: {
52036                                    let mut init = C2RustUnnamed_5 {
52037                                        pos: 1 as libc::c_int,
52038                                    };
52039                                    init
52040                                },
52041                            },
52042                            find_keys_type: KSPEC_FK_RANGE,
52043                            fk: C2RustUnnamed_0 {
52044                                range: {
52045                                    let mut init = C2RustUnnamed_2 {
52046                                        lastkey: 0 as libc::c_int,
52047                                        keystep: 1 as libc::c_int,
52048                                        limit: 0 as libc::c_int,
52049                                    };
52050                                    init
52051                                },
52052                            },
52053                        };
52054                        init
52055                    },
52056                    keySpec {
52057                        notes: 0 as *const libc::c_char,
52058                        flags: 0,
52059                        begin_search_type: KSPEC_BS_INVALID,
52060                        bs: C2RustUnnamed_3 {
52061                            index: C2RustUnnamed_5 { pos: 0 },
52062                        },
52063                        find_keys_type: KSPEC_FK_INVALID,
52064                        fk: C2RustUnnamed_0 {
52065                            range: C2RustUnnamed_2 {
52066                                lastkey: 0,
52067                                keystep: 0,
52068                                limit: 0,
52069                            },
52070                        },
52071                    },
52072                    keySpec {
52073                        notes: 0 as *const libc::c_char,
52074                        flags: 0,
52075                        begin_search_type: KSPEC_BS_INVALID,
52076                        bs: C2RustUnnamed_3 {
52077                            index: C2RustUnnamed_5 { pos: 0 },
52078                        },
52079                        find_keys_type: KSPEC_FK_INVALID,
52080                        fk: C2RustUnnamed_0 {
52081                            range: C2RustUnnamed_2 {
52082                                lastkey: 0,
52083                                keystep: 0,
52084                                limit: 0,
52085                            },
52086                        },
52087                    },
52088                    keySpec {
52089                        notes: 0 as *const libc::c_char,
52090                        flags: 0,
52091                        begin_search_type: KSPEC_BS_INVALID,
52092                        bs: C2RustUnnamed_3 {
52093                            index: C2RustUnnamed_5 { pos: 0 },
52094                        },
52095                        find_keys_type: KSPEC_FK_INVALID,
52096                        fk: C2RustUnnamed_0 {
52097                            range: C2RustUnnamed_2 {
52098                                lastkey: 0,
52099                                keystep: 0,
52100                                limit: 0,
52101                            },
52102                        },
52103                    },
52104                ],
52105                getkeys_proc: None,
52106                subcommands: 0 as *const redisCommand as *mut redisCommand,
52107                args: LTRIM_Args.as_ptr() as *mut _,
52108                microseconds: 0,
52109                calls: 0,
52110                rejected_calls: 0,
52111                failed_calls: 0,
52112                id: 0,
52113                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52114                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52115                key_specs: 0 as *const keySpec as *mut keySpec,
52116                legacy_range_key_spec: keySpec {
52117                    notes: 0 as *const libc::c_char,
52118                    flags: 0,
52119                    begin_search_type: KSPEC_BS_INVALID,
52120                    bs: C2RustUnnamed_3 {
52121                        index: C2RustUnnamed_5 { pos: 0 },
52122                    },
52123                    find_keys_type: KSPEC_FK_INVALID,
52124                    fk: C2RustUnnamed_0 {
52125                        range: C2RustUnnamed_2 {
52126                            lastkey: 0,
52127                            keystep: 0,
52128                            limit: 0,
52129                        },
52130                    },
52131                },
52132                num_args: 0,
52133                num_history: 0,
52134                num_tips: 0,
52135                key_specs_num: 0,
52136                key_specs_max: 0,
52137                subcommands_dict: 0 as *const dict as *mut dict,
52138                parent: 0 as *const redisCommand as *mut redisCommand,
52139                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52140            };
52141            init
52142        },
52143        {
52144            let mut init = redisCommand {
52145                declared_name: b"rpop\0" as *const u8 as *const libc::c_char,
52146                summary: b"Remove and get the last elements in a list\0" as *const u8
52147                    as *const libc::c_char,
52148                complexity: b"O(N) where N is the number of elements returned\0"
52149                    as *const u8 as *const libc::c_char,
52150                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
52151                doc_flags: 0 as libc::c_int,
52152                replaced_by: 0 as *const libc::c_char,
52153                deprecated_since: 0 as *const libc::c_char,
52154                group: COMMAND_GROUP_LIST,
52155                history: RPOP_History.as_ptr() as *mut _,
52156                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52157                proc_0: Some(rpopCommand as unsafe extern "C" fn(*mut client) -> ()),
52158                arity: -(2 as libc::c_int),
52159                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
52160                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
52161                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
52162                    as uint64_t,
52163                key_specs_static: [
52164                    {
52165                        let mut init = keySpec {
52166                            notes: 0 as *const libc::c_char,
52167                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52168                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
52169                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
52170                            begin_search_type: KSPEC_BS_INDEX,
52171                            bs: C2RustUnnamed_3 {
52172                                index: {
52173                                    let mut init = C2RustUnnamed_5 {
52174                                        pos: 1 as libc::c_int,
52175                                    };
52176                                    init
52177                                },
52178                            },
52179                            find_keys_type: KSPEC_FK_RANGE,
52180                            fk: C2RustUnnamed_0 {
52181                                range: {
52182                                    let mut init = C2RustUnnamed_2 {
52183                                        lastkey: 0 as libc::c_int,
52184                                        keystep: 1 as libc::c_int,
52185                                        limit: 0 as libc::c_int,
52186                                    };
52187                                    init
52188                                },
52189                            },
52190                        };
52191                        init
52192                    },
52193                    keySpec {
52194                        notes: 0 as *const libc::c_char,
52195                        flags: 0,
52196                        begin_search_type: KSPEC_BS_INVALID,
52197                        bs: C2RustUnnamed_3 {
52198                            index: C2RustUnnamed_5 { pos: 0 },
52199                        },
52200                        find_keys_type: KSPEC_FK_INVALID,
52201                        fk: C2RustUnnamed_0 {
52202                            range: C2RustUnnamed_2 {
52203                                lastkey: 0,
52204                                keystep: 0,
52205                                limit: 0,
52206                            },
52207                        },
52208                    },
52209                    keySpec {
52210                        notes: 0 as *const libc::c_char,
52211                        flags: 0,
52212                        begin_search_type: KSPEC_BS_INVALID,
52213                        bs: C2RustUnnamed_3 {
52214                            index: C2RustUnnamed_5 { pos: 0 },
52215                        },
52216                        find_keys_type: KSPEC_FK_INVALID,
52217                        fk: C2RustUnnamed_0 {
52218                            range: C2RustUnnamed_2 {
52219                                lastkey: 0,
52220                                keystep: 0,
52221                                limit: 0,
52222                            },
52223                        },
52224                    },
52225                    keySpec {
52226                        notes: 0 as *const libc::c_char,
52227                        flags: 0,
52228                        begin_search_type: KSPEC_BS_INVALID,
52229                        bs: C2RustUnnamed_3 {
52230                            index: C2RustUnnamed_5 { pos: 0 },
52231                        },
52232                        find_keys_type: KSPEC_FK_INVALID,
52233                        fk: C2RustUnnamed_0 {
52234                            range: C2RustUnnamed_2 {
52235                                lastkey: 0,
52236                                keystep: 0,
52237                                limit: 0,
52238                            },
52239                        },
52240                    },
52241                ],
52242                getkeys_proc: None,
52243                subcommands: 0 as *const redisCommand as *mut redisCommand,
52244                args: RPOP_Args.as_ptr() as *mut _,
52245                microseconds: 0,
52246                calls: 0,
52247                rejected_calls: 0,
52248                failed_calls: 0,
52249                id: 0,
52250                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52251                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52252                key_specs: 0 as *const keySpec as *mut keySpec,
52253                legacy_range_key_spec: keySpec {
52254                    notes: 0 as *const libc::c_char,
52255                    flags: 0,
52256                    begin_search_type: KSPEC_BS_INVALID,
52257                    bs: C2RustUnnamed_3 {
52258                        index: C2RustUnnamed_5 { pos: 0 },
52259                    },
52260                    find_keys_type: KSPEC_FK_INVALID,
52261                    fk: C2RustUnnamed_0 {
52262                        range: C2RustUnnamed_2 {
52263                            lastkey: 0,
52264                            keystep: 0,
52265                            limit: 0,
52266                        },
52267                    },
52268                },
52269                num_args: 0,
52270                num_history: 0,
52271                num_tips: 0,
52272                key_specs_num: 0,
52273                key_specs_max: 0,
52274                subcommands_dict: 0 as *const dict as *mut dict,
52275                parent: 0 as *const redisCommand as *mut redisCommand,
52276                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52277            };
52278            init
52279        },
52280        {
52281            let mut init = redisCommand {
52282                declared_name: b"rpoplpush\0" as *const u8 as *const libc::c_char,
52283                summary: b"Remove the last element in a list, prepend it to another list and return it\0"
52284                    as *const u8 as *const libc::c_char,
52285                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
52286                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
52287                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
52288                replaced_by: b"`LMOVE` with the `RIGHT` and `LEFT` arguments\0"
52289                    as *const u8 as *const libc::c_char,
52290                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
52291                group: COMMAND_GROUP_LIST,
52292                history: 0 as *const commandHistory as *mut commandHistory,
52293                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52294                proc_0: Some(
52295                    rpoplpushCommand as unsafe extern "C" fn(*mut client) -> (),
52296                ),
52297                arity: 3 as libc::c_int,
52298                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
52299                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
52300                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
52301                    as uint64_t,
52302                key_specs_static: [
52303                    {
52304                        let mut init = keySpec {
52305                            notes: 0 as *const libc::c_char,
52306                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52307                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
52308                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
52309                            begin_search_type: KSPEC_BS_INDEX,
52310                            bs: C2RustUnnamed_3 {
52311                                index: {
52312                                    let mut init = C2RustUnnamed_5 {
52313                                        pos: 1 as libc::c_int,
52314                                    };
52315                                    init
52316                                },
52317                            },
52318                            find_keys_type: KSPEC_FK_RANGE,
52319                            fk: C2RustUnnamed_0 {
52320                                range: {
52321                                    let mut init = C2RustUnnamed_2 {
52322                                        lastkey: 0 as libc::c_int,
52323                                        keystep: 1 as libc::c_int,
52324                                        limit: 0 as libc::c_int,
52325                                    };
52326                                    init
52327                                },
52328                            },
52329                        };
52330                        init
52331                    },
52332                    {
52333                        let mut init = keySpec {
52334                            notes: 0 as *const libc::c_char,
52335                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52336                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
52337                            begin_search_type: KSPEC_BS_INDEX,
52338                            bs: C2RustUnnamed_3 {
52339                                index: {
52340                                    let mut init = C2RustUnnamed_5 {
52341                                        pos: 2 as libc::c_int,
52342                                    };
52343                                    init
52344                                },
52345                            },
52346                            find_keys_type: KSPEC_FK_RANGE,
52347                            fk: C2RustUnnamed_0 {
52348                                range: {
52349                                    let mut init = C2RustUnnamed_2 {
52350                                        lastkey: 0 as libc::c_int,
52351                                        keystep: 1 as libc::c_int,
52352                                        limit: 0 as libc::c_int,
52353                                    };
52354                                    init
52355                                },
52356                            },
52357                        };
52358                        init
52359                    },
52360                    keySpec {
52361                        notes: 0 as *const libc::c_char,
52362                        flags: 0,
52363                        begin_search_type: KSPEC_BS_INVALID,
52364                        bs: C2RustUnnamed_3 {
52365                            index: C2RustUnnamed_5 { pos: 0 },
52366                        },
52367                        find_keys_type: KSPEC_FK_INVALID,
52368                        fk: C2RustUnnamed_0 {
52369                            range: C2RustUnnamed_2 {
52370                                lastkey: 0,
52371                                keystep: 0,
52372                                limit: 0,
52373                            },
52374                        },
52375                    },
52376                    keySpec {
52377                        notes: 0 as *const libc::c_char,
52378                        flags: 0,
52379                        begin_search_type: KSPEC_BS_INVALID,
52380                        bs: C2RustUnnamed_3 {
52381                            index: C2RustUnnamed_5 { pos: 0 },
52382                        },
52383                        find_keys_type: KSPEC_FK_INVALID,
52384                        fk: C2RustUnnamed_0 {
52385                            range: C2RustUnnamed_2 {
52386                                lastkey: 0,
52387                                keystep: 0,
52388                                limit: 0,
52389                            },
52390                        },
52391                    },
52392                ],
52393                getkeys_proc: None,
52394                subcommands: 0 as *const redisCommand as *mut redisCommand,
52395                args: RPOPLPUSH_Args.as_ptr() as *mut _,
52396                microseconds: 0,
52397                calls: 0,
52398                rejected_calls: 0,
52399                failed_calls: 0,
52400                id: 0,
52401                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52402                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52403                key_specs: 0 as *const keySpec as *mut keySpec,
52404                legacy_range_key_spec: keySpec {
52405                    notes: 0 as *const libc::c_char,
52406                    flags: 0,
52407                    begin_search_type: KSPEC_BS_INVALID,
52408                    bs: C2RustUnnamed_3 {
52409                        index: C2RustUnnamed_5 { pos: 0 },
52410                    },
52411                    find_keys_type: KSPEC_FK_INVALID,
52412                    fk: C2RustUnnamed_0 {
52413                        range: C2RustUnnamed_2 {
52414                            lastkey: 0,
52415                            keystep: 0,
52416                            limit: 0,
52417                        },
52418                    },
52419                },
52420                num_args: 0,
52421                num_history: 0,
52422                num_tips: 0,
52423                key_specs_num: 0,
52424                key_specs_max: 0,
52425                subcommands_dict: 0 as *const dict as *mut dict,
52426                parent: 0 as *const redisCommand as *mut redisCommand,
52427                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52428            };
52429            init
52430        },
52431        {
52432            let mut init = redisCommand {
52433                declared_name: b"rpush\0" as *const u8 as *const libc::c_char,
52434                summary: b"Append one or multiple elements to a list\0" as *const u8
52435                    as *const libc::c_char,
52436                complexity: b"O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.\0"
52437                    as *const u8 as *const libc::c_char,
52438                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
52439                doc_flags: 0 as libc::c_int,
52440                replaced_by: 0 as *const libc::c_char,
52441                deprecated_since: 0 as *const libc::c_char,
52442                group: COMMAND_GROUP_LIST,
52443                history: RPUSH_History.as_ptr() as *mut _,
52444                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52445                proc_0: Some(rpushCommand as unsafe extern "C" fn(*mut client) -> ()),
52446                arity: -(3 as libc::c_int),
52447                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
52448                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
52449                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
52450                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
52451                    as uint64_t,
52452                key_specs_static: [
52453                    {
52454                        let mut init = keySpec {
52455                            notes: 0 as *const libc::c_char,
52456                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52457                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
52458                            begin_search_type: KSPEC_BS_INDEX,
52459                            bs: C2RustUnnamed_3 {
52460                                index: {
52461                                    let mut init = C2RustUnnamed_5 {
52462                                        pos: 1 as libc::c_int,
52463                                    };
52464                                    init
52465                                },
52466                            },
52467                            find_keys_type: KSPEC_FK_RANGE,
52468                            fk: C2RustUnnamed_0 {
52469                                range: {
52470                                    let mut init = C2RustUnnamed_2 {
52471                                        lastkey: 0 as libc::c_int,
52472                                        keystep: 1 as libc::c_int,
52473                                        limit: 0 as libc::c_int,
52474                                    };
52475                                    init
52476                                },
52477                            },
52478                        };
52479                        init
52480                    },
52481                    keySpec {
52482                        notes: 0 as *const libc::c_char,
52483                        flags: 0,
52484                        begin_search_type: KSPEC_BS_INVALID,
52485                        bs: C2RustUnnamed_3 {
52486                            index: C2RustUnnamed_5 { pos: 0 },
52487                        },
52488                        find_keys_type: KSPEC_FK_INVALID,
52489                        fk: C2RustUnnamed_0 {
52490                            range: C2RustUnnamed_2 {
52491                                lastkey: 0,
52492                                keystep: 0,
52493                                limit: 0,
52494                            },
52495                        },
52496                    },
52497                    keySpec {
52498                        notes: 0 as *const libc::c_char,
52499                        flags: 0,
52500                        begin_search_type: KSPEC_BS_INVALID,
52501                        bs: C2RustUnnamed_3 {
52502                            index: C2RustUnnamed_5 { pos: 0 },
52503                        },
52504                        find_keys_type: KSPEC_FK_INVALID,
52505                        fk: C2RustUnnamed_0 {
52506                            range: C2RustUnnamed_2 {
52507                                lastkey: 0,
52508                                keystep: 0,
52509                                limit: 0,
52510                            },
52511                        },
52512                    },
52513                    keySpec {
52514                        notes: 0 as *const libc::c_char,
52515                        flags: 0,
52516                        begin_search_type: KSPEC_BS_INVALID,
52517                        bs: C2RustUnnamed_3 {
52518                            index: C2RustUnnamed_5 { pos: 0 },
52519                        },
52520                        find_keys_type: KSPEC_FK_INVALID,
52521                        fk: C2RustUnnamed_0 {
52522                            range: C2RustUnnamed_2 {
52523                                lastkey: 0,
52524                                keystep: 0,
52525                                limit: 0,
52526                            },
52527                        },
52528                    },
52529                ],
52530                getkeys_proc: None,
52531                subcommands: 0 as *const redisCommand as *mut redisCommand,
52532                args: RPUSH_Args.as_ptr() as *mut _,
52533                microseconds: 0,
52534                calls: 0,
52535                rejected_calls: 0,
52536                failed_calls: 0,
52537                id: 0,
52538                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52539                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52540                key_specs: 0 as *const keySpec as *mut keySpec,
52541                legacy_range_key_spec: keySpec {
52542                    notes: 0 as *const libc::c_char,
52543                    flags: 0,
52544                    begin_search_type: KSPEC_BS_INVALID,
52545                    bs: C2RustUnnamed_3 {
52546                        index: C2RustUnnamed_5 { pos: 0 },
52547                    },
52548                    find_keys_type: KSPEC_FK_INVALID,
52549                    fk: C2RustUnnamed_0 {
52550                        range: C2RustUnnamed_2 {
52551                            lastkey: 0,
52552                            keystep: 0,
52553                            limit: 0,
52554                        },
52555                    },
52556                },
52557                num_args: 0,
52558                num_history: 0,
52559                num_tips: 0,
52560                key_specs_num: 0,
52561                key_specs_max: 0,
52562                subcommands_dict: 0 as *const dict as *mut dict,
52563                parent: 0 as *const redisCommand as *mut redisCommand,
52564                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52565            };
52566            init
52567        },
52568        {
52569            let mut init = redisCommand {
52570                declared_name: b"rpushx\0" as *const u8 as *const libc::c_char,
52571                summary: b"Append an element to a list, only if the list exists\0"
52572                    as *const u8 as *const libc::c_char,
52573                complexity: b"O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.\0"
52574                    as *const u8 as *const libc::c_char,
52575                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
52576                doc_flags: 0 as libc::c_int,
52577                replaced_by: 0 as *const libc::c_char,
52578                deprecated_since: 0 as *const libc::c_char,
52579                group: COMMAND_GROUP_LIST,
52580                history: RPUSHX_History.as_ptr() as *mut _,
52581                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52582                proc_0: Some(rpushxCommand as unsafe extern "C" fn(*mut client) -> ()),
52583                arity: -(3 as libc::c_int),
52584                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
52585                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
52586                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
52587                acl_categories: ((1 as libc::c_ulonglong) << 5 as libc::c_int)
52588                    as uint64_t,
52589                key_specs_static: [
52590                    {
52591                        let mut init = keySpec {
52592                            notes: 0 as *const libc::c_char,
52593                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
52594                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
52595                            begin_search_type: KSPEC_BS_INDEX,
52596                            bs: C2RustUnnamed_3 {
52597                                index: {
52598                                    let mut init = C2RustUnnamed_5 {
52599                                        pos: 1 as libc::c_int,
52600                                    };
52601                                    init
52602                                },
52603                            },
52604                            find_keys_type: KSPEC_FK_RANGE,
52605                            fk: C2RustUnnamed_0 {
52606                                range: {
52607                                    let mut init = C2RustUnnamed_2 {
52608                                        lastkey: 0 as libc::c_int,
52609                                        keystep: 1 as libc::c_int,
52610                                        limit: 0 as libc::c_int,
52611                                    };
52612                                    init
52613                                },
52614                            },
52615                        };
52616                        init
52617                    },
52618                    keySpec {
52619                        notes: 0 as *const libc::c_char,
52620                        flags: 0,
52621                        begin_search_type: KSPEC_BS_INVALID,
52622                        bs: C2RustUnnamed_3 {
52623                            index: C2RustUnnamed_5 { pos: 0 },
52624                        },
52625                        find_keys_type: KSPEC_FK_INVALID,
52626                        fk: C2RustUnnamed_0 {
52627                            range: C2RustUnnamed_2 {
52628                                lastkey: 0,
52629                                keystep: 0,
52630                                limit: 0,
52631                            },
52632                        },
52633                    },
52634                    keySpec {
52635                        notes: 0 as *const libc::c_char,
52636                        flags: 0,
52637                        begin_search_type: KSPEC_BS_INVALID,
52638                        bs: C2RustUnnamed_3 {
52639                            index: C2RustUnnamed_5 { pos: 0 },
52640                        },
52641                        find_keys_type: KSPEC_FK_INVALID,
52642                        fk: C2RustUnnamed_0 {
52643                            range: C2RustUnnamed_2 {
52644                                lastkey: 0,
52645                                keystep: 0,
52646                                limit: 0,
52647                            },
52648                        },
52649                    },
52650                    keySpec {
52651                        notes: 0 as *const libc::c_char,
52652                        flags: 0,
52653                        begin_search_type: KSPEC_BS_INVALID,
52654                        bs: C2RustUnnamed_3 {
52655                            index: C2RustUnnamed_5 { pos: 0 },
52656                        },
52657                        find_keys_type: KSPEC_FK_INVALID,
52658                        fk: C2RustUnnamed_0 {
52659                            range: C2RustUnnamed_2 {
52660                                lastkey: 0,
52661                                keystep: 0,
52662                                limit: 0,
52663                            },
52664                        },
52665                    },
52666                ],
52667                getkeys_proc: None,
52668                subcommands: 0 as *const redisCommand as *mut redisCommand,
52669                args: RPUSHX_Args.as_ptr() as *mut _,
52670                microseconds: 0,
52671                calls: 0,
52672                rejected_calls: 0,
52673                failed_calls: 0,
52674                id: 0,
52675                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52676                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52677                key_specs: 0 as *const keySpec as *mut keySpec,
52678                legacy_range_key_spec: keySpec {
52679                    notes: 0 as *const libc::c_char,
52680                    flags: 0,
52681                    begin_search_type: KSPEC_BS_INVALID,
52682                    bs: C2RustUnnamed_3 {
52683                        index: C2RustUnnamed_5 { pos: 0 },
52684                    },
52685                    find_keys_type: KSPEC_FK_INVALID,
52686                    fk: C2RustUnnamed_0 {
52687                        range: C2RustUnnamed_2 {
52688                            lastkey: 0,
52689                            keystep: 0,
52690                            limit: 0,
52691                        },
52692                    },
52693                },
52694                num_args: 0,
52695                num_history: 0,
52696                num_tips: 0,
52697                key_specs_num: 0,
52698                key_specs_max: 0,
52699                subcommands_dict: 0 as *const dict as *mut dict,
52700                parent: 0 as *const redisCommand as *mut redisCommand,
52701                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52702            };
52703            init
52704        },
52705        {
52706            let mut init = redisCommand {
52707                declared_name: b"psubscribe\0" as *const u8 as *const libc::c_char,
52708                summary: b"Listen for messages published to channels matching the given patterns\0"
52709                    as *const u8 as *const libc::c_char,
52710                complexity: b"O(N) where N is the number of patterns the client is already subscribed to.\0"
52711                    as *const u8 as *const libc::c_char,
52712                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
52713                doc_flags: 0 as libc::c_int,
52714                replaced_by: 0 as *const libc::c_char,
52715                deprecated_since: 0 as *const libc::c_char,
52716                group: COMMAND_GROUP_PUBSUB,
52717                history: 0 as *const commandHistory as *mut commandHistory,
52718                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52719                proc_0: Some(
52720                    psubscribeCommand as unsafe extern "C" fn(*mut client) -> (),
52721                ),
52722                arity: -(2 as libc::c_int),
52723                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
52724                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
52725                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
52726                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
52727                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
52728                acl_categories: 0 as libc::c_int as uint64_t,
52729                key_specs_static: [keySpec {
52730                    notes: 0 as *const libc::c_char,
52731                    flags: 0,
52732                    begin_search_type: KSPEC_BS_INVALID,
52733                    bs: C2RustUnnamed_3 {
52734                        index: C2RustUnnamed_5 { pos: 0 },
52735                    },
52736                    find_keys_type: KSPEC_FK_INVALID,
52737                    fk: C2RustUnnamed_0 {
52738                        range: C2RustUnnamed_2 {
52739                            lastkey: 0,
52740                            keystep: 0,
52741                            limit: 0,
52742                        },
52743                    },
52744                }; 4],
52745                getkeys_proc: None,
52746                subcommands: 0 as *const redisCommand as *mut redisCommand,
52747                args: PSUBSCRIBE_Args.as_ptr() as *mut _,
52748                microseconds: 0,
52749                calls: 0,
52750                rejected_calls: 0,
52751                failed_calls: 0,
52752                id: 0,
52753                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52754                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52755                key_specs: 0 as *const keySpec as *mut keySpec,
52756                legacy_range_key_spec: keySpec {
52757                    notes: 0 as *const libc::c_char,
52758                    flags: 0,
52759                    begin_search_type: KSPEC_BS_INVALID,
52760                    bs: C2RustUnnamed_3 {
52761                        index: C2RustUnnamed_5 { pos: 0 },
52762                    },
52763                    find_keys_type: KSPEC_FK_INVALID,
52764                    fk: C2RustUnnamed_0 {
52765                        range: C2RustUnnamed_2 {
52766                            lastkey: 0,
52767                            keystep: 0,
52768                            limit: 0,
52769                        },
52770                    },
52771                },
52772                num_args: 0,
52773                num_history: 0,
52774                num_tips: 0,
52775                key_specs_num: 0,
52776                key_specs_max: 0,
52777                subcommands_dict: 0 as *const dict as *mut dict,
52778                parent: 0 as *const redisCommand as *mut redisCommand,
52779                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52780            };
52781            init
52782        },
52783        {
52784            let mut init = redisCommand {
52785                declared_name: b"publish\0" as *const u8 as *const libc::c_char,
52786                summary: b"Post a message to a channel\0" as *const u8
52787                    as *const libc::c_char,
52788                complexity: b"O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).\0"
52789                    as *const u8 as *const libc::c_char,
52790                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
52791                doc_flags: 0 as libc::c_int,
52792                replaced_by: 0 as *const libc::c_char,
52793                deprecated_since: 0 as *const libc::c_char,
52794                group: COMMAND_GROUP_PUBSUB,
52795                history: 0 as *const commandHistory as *mut commandHistory,
52796                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52797                proc_0: Some(publishCommand as unsafe extern "C" fn(*mut client) -> ()),
52798                arity: 3 as libc::c_int,
52799                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
52800                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
52801                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
52802                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
52803                    | (1 as libc::c_ulonglong) << 16 as libc::c_int
52804                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
52805                acl_categories: 0 as libc::c_int as uint64_t,
52806                key_specs_static: [keySpec {
52807                    notes: 0 as *const libc::c_char,
52808                    flags: 0,
52809                    begin_search_type: KSPEC_BS_INVALID,
52810                    bs: C2RustUnnamed_3 {
52811                        index: C2RustUnnamed_5 { pos: 0 },
52812                    },
52813                    find_keys_type: KSPEC_FK_INVALID,
52814                    fk: C2RustUnnamed_0 {
52815                        range: C2RustUnnamed_2 {
52816                            lastkey: 0,
52817                            keystep: 0,
52818                            limit: 0,
52819                        },
52820                    },
52821                }; 4],
52822                getkeys_proc: None,
52823                subcommands: 0 as *const redisCommand as *mut redisCommand,
52824                args: PUBLISH_Args.as_ptr() as *mut _,
52825                microseconds: 0,
52826                calls: 0,
52827                rejected_calls: 0,
52828                failed_calls: 0,
52829                id: 0,
52830                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52831                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52832                key_specs: 0 as *const keySpec as *mut keySpec,
52833                legacy_range_key_spec: keySpec {
52834                    notes: 0 as *const libc::c_char,
52835                    flags: 0,
52836                    begin_search_type: KSPEC_BS_INVALID,
52837                    bs: C2RustUnnamed_3 {
52838                        index: C2RustUnnamed_5 { pos: 0 },
52839                    },
52840                    find_keys_type: KSPEC_FK_INVALID,
52841                    fk: C2RustUnnamed_0 {
52842                        range: C2RustUnnamed_2 {
52843                            lastkey: 0,
52844                            keystep: 0,
52845                            limit: 0,
52846                        },
52847                    },
52848                },
52849                num_args: 0,
52850                num_history: 0,
52851                num_tips: 0,
52852                key_specs_num: 0,
52853                key_specs_max: 0,
52854                subcommands_dict: 0 as *const dict as *mut dict,
52855                parent: 0 as *const redisCommand as *mut redisCommand,
52856                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52857            };
52858            init
52859        },
52860        {
52861            let mut init = redisCommand {
52862                declared_name: b"pubsub\0" as *const u8 as *const libc::c_char,
52863                summary: b"A container for Pub/Sub commands\0" as *const u8
52864                    as *const libc::c_char,
52865                complexity: b"Depends on subcommand.\0" as *const u8
52866                    as *const libc::c_char,
52867                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
52868                doc_flags: 0 as libc::c_int,
52869                replaced_by: 0 as *const libc::c_char,
52870                deprecated_since: 0 as *const libc::c_char,
52871                group: COMMAND_GROUP_PUBSUB,
52872                history: 0 as *const commandHistory as *mut commandHistory,
52873                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52874                proc_0: None,
52875                arity: -(2 as libc::c_int),
52876                flags: 0 as libc::c_int as uint64_t,
52877                acl_categories: 0 as libc::c_int as uint64_t,
52878                key_specs_static: [keySpec {
52879                    notes: 0 as *const libc::c_char,
52880                    flags: 0,
52881                    begin_search_type: KSPEC_BS_INVALID,
52882                    bs: C2RustUnnamed_3 {
52883                        index: C2RustUnnamed_5 { pos: 0 },
52884                    },
52885                    find_keys_type: KSPEC_FK_INVALID,
52886                    fk: C2RustUnnamed_0 {
52887                        range: C2RustUnnamed_2 {
52888                            lastkey: 0,
52889                            keystep: 0,
52890                            limit: 0,
52891                        },
52892                    },
52893                }; 4],
52894                getkeys_proc: None,
52895                subcommands: PUBSUB_Subcommands.as_ptr() as *mut _,
52896                args: 0 as *const redisCommandArg as *mut redisCommandArg,
52897                microseconds: 0,
52898                calls: 0,
52899                rejected_calls: 0,
52900                failed_calls: 0,
52901                id: 0,
52902                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52903                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52904                key_specs: 0 as *const keySpec as *mut keySpec,
52905                legacy_range_key_spec: keySpec {
52906                    notes: 0 as *const libc::c_char,
52907                    flags: 0,
52908                    begin_search_type: KSPEC_BS_INVALID,
52909                    bs: C2RustUnnamed_3 {
52910                        index: C2RustUnnamed_5 { pos: 0 },
52911                    },
52912                    find_keys_type: KSPEC_FK_INVALID,
52913                    fk: C2RustUnnamed_0 {
52914                        range: C2RustUnnamed_2 {
52915                            lastkey: 0,
52916                            keystep: 0,
52917                            limit: 0,
52918                        },
52919                    },
52920                },
52921                num_args: 0,
52922                num_history: 0,
52923                num_tips: 0,
52924                key_specs_num: 0,
52925                key_specs_max: 0,
52926                subcommands_dict: 0 as *const dict as *mut dict,
52927                parent: 0 as *const redisCommand as *mut redisCommand,
52928                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
52929            };
52930            init
52931        },
52932        {
52933            let mut init = redisCommand {
52934                declared_name: b"punsubscribe\0" as *const u8 as *const libc::c_char,
52935                summary: b"Stop listening for messages posted to channels matching the given patterns\0"
52936                    as *const u8 as *const libc::c_char,
52937                complexity: b"O(N+M) where N is the number of patterns the client is already subscribed and M is the number of total patterns subscribed in the system (by any client).\0"
52938                    as *const u8 as *const libc::c_char,
52939                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
52940                doc_flags: 0 as libc::c_int,
52941                replaced_by: 0 as *const libc::c_char,
52942                deprecated_since: 0 as *const libc::c_char,
52943                group: COMMAND_GROUP_PUBSUB,
52944                history: 0 as *const commandHistory as *mut commandHistory,
52945                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
52946                proc_0: Some(
52947                    punsubscribeCommand as unsafe extern "C" fn(*mut client) -> (),
52948                ),
52949                arity: -(1 as libc::c_int),
52950                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
52951                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
52952                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
52953                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
52954                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
52955                acl_categories: 0 as libc::c_int as uint64_t,
52956                key_specs_static: [keySpec {
52957                    notes: 0 as *const libc::c_char,
52958                    flags: 0,
52959                    begin_search_type: KSPEC_BS_INVALID,
52960                    bs: C2RustUnnamed_3 {
52961                        index: C2RustUnnamed_5 { pos: 0 },
52962                    },
52963                    find_keys_type: KSPEC_FK_INVALID,
52964                    fk: C2RustUnnamed_0 {
52965                        range: C2RustUnnamed_2 {
52966                            lastkey: 0,
52967                            keystep: 0,
52968                            limit: 0,
52969                        },
52970                    },
52971                }; 4],
52972                getkeys_proc: None,
52973                subcommands: 0 as *const redisCommand as *mut redisCommand,
52974                args: PUNSUBSCRIBE_Args.as_ptr() as *mut _,
52975                microseconds: 0,
52976                calls: 0,
52977                rejected_calls: 0,
52978                failed_calls: 0,
52979                id: 0,
52980                fullname: 0 as *const libc::c_char as *mut libc::c_char,
52981                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
52982                key_specs: 0 as *const keySpec as *mut keySpec,
52983                legacy_range_key_spec: keySpec {
52984                    notes: 0 as *const libc::c_char,
52985                    flags: 0,
52986                    begin_search_type: KSPEC_BS_INVALID,
52987                    bs: C2RustUnnamed_3 {
52988                        index: C2RustUnnamed_5 { pos: 0 },
52989                    },
52990                    find_keys_type: KSPEC_FK_INVALID,
52991                    fk: C2RustUnnamed_0 {
52992                        range: C2RustUnnamed_2 {
52993                            lastkey: 0,
52994                            keystep: 0,
52995                            limit: 0,
52996                        },
52997                    },
52998                },
52999                num_args: 0,
53000                num_history: 0,
53001                num_tips: 0,
53002                key_specs_num: 0,
53003                key_specs_max: 0,
53004                subcommands_dict: 0 as *const dict as *mut dict,
53005                parent: 0 as *const redisCommand as *mut redisCommand,
53006                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53007            };
53008            init
53009        },
53010        {
53011            let mut init = redisCommand {
53012                declared_name: b"spublish\0" as *const u8 as *const libc::c_char,
53013                summary: b"Post a message to a shard channel\0" as *const u8
53014                    as *const libc::c_char,
53015                complexity: b"O(N) where N is the number of clients subscribed to the receiving shard channel.\0"
53016                    as *const u8 as *const libc::c_char,
53017                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
53018                doc_flags: 0 as libc::c_int,
53019                replaced_by: 0 as *const libc::c_char,
53020                deprecated_since: 0 as *const libc::c_char,
53021                group: COMMAND_GROUP_PUBSUB,
53022                history: 0 as *const commandHistory as *mut commandHistory,
53023                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53024                proc_0: Some(spublishCommand as unsafe extern "C" fn(*mut client) -> ()),
53025                arity: 3 as libc::c_int,
53026                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
53027                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
53028                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
53029                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
53030                    | (1 as libc::c_ulonglong) << 16 as libc::c_int) as uint64_t,
53031                acl_categories: 0 as libc::c_int as uint64_t,
53032                key_specs_static: [
53033                    {
53034                        let mut init = keySpec {
53035                            notes: 0 as *const libc::c_char,
53036                            flags: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
53037                                as uint64_t,
53038                            begin_search_type: KSPEC_BS_INDEX,
53039                            bs: C2RustUnnamed_3 {
53040                                index: {
53041                                    let mut init = C2RustUnnamed_5 {
53042                                        pos: 1 as libc::c_int,
53043                                    };
53044                                    init
53045                                },
53046                            },
53047                            find_keys_type: KSPEC_FK_RANGE,
53048                            fk: C2RustUnnamed_0 {
53049                                range: {
53050                                    let mut init = C2RustUnnamed_2 {
53051                                        lastkey: 0 as libc::c_int,
53052                                        keystep: 1 as libc::c_int,
53053                                        limit: 0 as libc::c_int,
53054                                    };
53055                                    init
53056                                },
53057                            },
53058                        };
53059                        init
53060                    },
53061                    keySpec {
53062                        notes: 0 as *const libc::c_char,
53063                        flags: 0,
53064                        begin_search_type: KSPEC_BS_INVALID,
53065                        bs: C2RustUnnamed_3 {
53066                            index: C2RustUnnamed_5 { pos: 0 },
53067                        },
53068                        find_keys_type: KSPEC_FK_INVALID,
53069                        fk: C2RustUnnamed_0 {
53070                            range: C2RustUnnamed_2 {
53071                                lastkey: 0,
53072                                keystep: 0,
53073                                limit: 0,
53074                            },
53075                        },
53076                    },
53077                    keySpec {
53078                        notes: 0 as *const libc::c_char,
53079                        flags: 0,
53080                        begin_search_type: KSPEC_BS_INVALID,
53081                        bs: C2RustUnnamed_3 {
53082                            index: C2RustUnnamed_5 { pos: 0 },
53083                        },
53084                        find_keys_type: KSPEC_FK_INVALID,
53085                        fk: C2RustUnnamed_0 {
53086                            range: C2RustUnnamed_2 {
53087                                lastkey: 0,
53088                                keystep: 0,
53089                                limit: 0,
53090                            },
53091                        },
53092                    },
53093                    keySpec {
53094                        notes: 0 as *const libc::c_char,
53095                        flags: 0,
53096                        begin_search_type: KSPEC_BS_INVALID,
53097                        bs: C2RustUnnamed_3 {
53098                            index: C2RustUnnamed_5 { pos: 0 },
53099                        },
53100                        find_keys_type: KSPEC_FK_INVALID,
53101                        fk: C2RustUnnamed_0 {
53102                            range: C2RustUnnamed_2 {
53103                                lastkey: 0,
53104                                keystep: 0,
53105                                limit: 0,
53106                            },
53107                        },
53108                    },
53109                ],
53110                getkeys_proc: None,
53111                subcommands: 0 as *const redisCommand as *mut redisCommand,
53112                args: SPUBLISH_Args.as_ptr() as *mut _,
53113                microseconds: 0,
53114                calls: 0,
53115                rejected_calls: 0,
53116                failed_calls: 0,
53117                id: 0,
53118                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53119                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53120                key_specs: 0 as *const keySpec as *mut keySpec,
53121                legacy_range_key_spec: keySpec {
53122                    notes: 0 as *const libc::c_char,
53123                    flags: 0,
53124                    begin_search_type: KSPEC_BS_INVALID,
53125                    bs: C2RustUnnamed_3 {
53126                        index: C2RustUnnamed_5 { pos: 0 },
53127                    },
53128                    find_keys_type: KSPEC_FK_INVALID,
53129                    fk: C2RustUnnamed_0 {
53130                        range: C2RustUnnamed_2 {
53131                            lastkey: 0,
53132                            keystep: 0,
53133                            limit: 0,
53134                        },
53135                    },
53136                },
53137                num_args: 0,
53138                num_history: 0,
53139                num_tips: 0,
53140                key_specs_num: 0,
53141                key_specs_max: 0,
53142                subcommands_dict: 0 as *const dict as *mut dict,
53143                parent: 0 as *const redisCommand as *mut redisCommand,
53144                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53145            };
53146            init
53147        },
53148        {
53149            let mut init = redisCommand {
53150                declared_name: b"ssubscribe\0" as *const u8 as *const libc::c_char,
53151                summary: b"Listen for messages published to the given shard channels\0"
53152                    as *const u8 as *const libc::c_char,
53153                complexity: b"O(N) where N is the number of shard channels to subscribe to.\0"
53154                    as *const u8 as *const libc::c_char,
53155                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
53156                doc_flags: 0 as libc::c_int,
53157                replaced_by: 0 as *const libc::c_char,
53158                deprecated_since: 0 as *const libc::c_char,
53159                group: COMMAND_GROUP_PUBSUB,
53160                history: 0 as *const commandHistory as *mut commandHistory,
53161                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53162                proc_0: Some(
53163                    ssubscribeCommand as unsafe extern "C" fn(*mut client) -> (),
53164                ),
53165                arity: -(2 as libc::c_int),
53166                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
53167                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
53168                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
53169                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
53170                acl_categories: 0 as libc::c_int as uint64_t,
53171                key_specs_static: [
53172                    {
53173                        let mut init = keySpec {
53174                            notes: 0 as *const libc::c_char,
53175                            flags: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
53176                                as uint64_t,
53177                            begin_search_type: KSPEC_BS_INDEX,
53178                            bs: C2RustUnnamed_3 {
53179                                index: {
53180                                    let mut init = C2RustUnnamed_5 {
53181                                        pos: 1 as libc::c_int,
53182                                    };
53183                                    init
53184                                },
53185                            },
53186                            find_keys_type: KSPEC_FK_RANGE,
53187                            fk: C2RustUnnamed_0 {
53188                                range: {
53189                                    let mut init = C2RustUnnamed_2 {
53190                                        lastkey: -(1 as libc::c_int),
53191                                        keystep: 1 as libc::c_int,
53192                                        limit: 0 as libc::c_int,
53193                                    };
53194                                    init
53195                                },
53196                            },
53197                        };
53198                        init
53199                    },
53200                    keySpec {
53201                        notes: 0 as *const libc::c_char,
53202                        flags: 0,
53203                        begin_search_type: KSPEC_BS_INVALID,
53204                        bs: C2RustUnnamed_3 {
53205                            index: C2RustUnnamed_5 { pos: 0 },
53206                        },
53207                        find_keys_type: KSPEC_FK_INVALID,
53208                        fk: C2RustUnnamed_0 {
53209                            range: C2RustUnnamed_2 {
53210                                lastkey: 0,
53211                                keystep: 0,
53212                                limit: 0,
53213                            },
53214                        },
53215                    },
53216                    keySpec {
53217                        notes: 0 as *const libc::c_char,
53218                        flags: 0,
53219                        begin_search_type: KSPEC_BS_INVALID,
53220                        bs: C2RustUnnamed_3 {
53221                            index: C2RustUnnamed_5 { pos: 0 },
53222                        },
53223                        find_keys_type: KSPEC_FK_INVALID,
53224                        fk: C2RustUnnamed_0 {
53225                            range: C2RustUnnamed_2 {
53226                                lastkey: 0,
53227                                keystep: 0,
53228                                limit: 0,
53229                            },
53230                        },
53231                    },
53232                    keySpec {
53233                        notes: 0 as *const libc::c_char,
53234                        flags: 0,
53235                        begin_search_type: KSPEC_BS_INVALID,
53236                        bs: C2RustUnnamed_3 {
53237                            index: C2RustUnnamed_5 { pos: 0 },
53238                        },
53239                        find_keys_type: KSPEC_FK_INVALID,
53240                        fk: C2RustUnnamed_0 {
53241                            range: C2RustUnnamed_2 {
53242                                lastkey: 0,
53243                                keystep: 0,
53244                                limit: 0,
53245                            },
53246                        },
53247                    },
53248                ],
53249                getkeys_proc: None,
53250                subcommands: 0 as *const redisCommand as *mut redisCommand,
53251                args: SSUBSCRIBE_Args.as_ptr() as *mut _,
53252                microseconds: 0,
53253                calls: 0,
53254                rejected_calls: 0,
53255                failed_calls: 0,
53256                id: 0,
53257                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53258                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53259                key_specs: 0 as *const keySpec as *mut keySpec,
53260                legacy_range_key_spec: keySpec {
53261                    notes: 0 as *const libc::c_char,
53262                    flags: 0,
53263                    begin_search_type: KSPEC_BS_INVALID,
53264                    bs: C2RustUnnamed_3 {
53265                        index: C2RustUnnamed_5 { pos: 0 },
53266                    },
53267                    find_keys_type: KSPEC_FK_INVALID,
53268                    fk: C2RustUnnamed_0 {
53269                        range: C2RustUnnamed_2 {
53270                            lastkey: 0,
53271                            keystep: 0,
53272                            limit: 0,
53273                        },
53274                    },
53275                },
53276                num_args: 0,
53277                num_history: 0,
53278                num_tips: 0,
53279                key_specs_num: 0,
53280                key_specs_max: 0,
53281                subcommands_dict: 0 as *const dict as *mut dict,
53282                parent: 0 as *const redisCommand as *mut redisCommand,
53283                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53284            };
53285            init
53286        },
53287        {
53288            let mut init = redisCommand {
53289                declared_name: b"subscribe\0" as *const u8 as *const libc::c_char,
53290                summary: b"Listen for messages published to the given channels\0"
53291                    as *const u8 as *const libc::c_char,
53292                complexity: b"O(N) where N is the number of channels to subscribe to.\0"
53293                    as *const u8 as *const libc::c_char,
53294                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
53295                doc_flags: 0 as libc::c_int,
53296                replaced_by: 0 as *const libc::c_char,
53297                deprecated_since: 0 as *const libc::c_char,
53298                group: COMMAND_GROUP_PUBSUB,
53299                history: 0 as *const commandHistory as *mut commandHistory,
53300                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53301                proc_0: Some(
53302                    subscribeCommand as unsafe extern "C" fn(*mut client) -> (),
53303                ),
53304                arity: -(2 as libc::c_int),
53305                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
53306                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
53307                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
53308                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
53309                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
53310                acl_categories: 0 as libc::c_int as uint64_t,
53311                key_specs_static: [keySpec {
53312                    notes: 0 as *const libc::c_char,
53313                    flags: 0,
53314                    begin_search_type: KSPEC_BS_INVALID,
53315                    bs: C2RustUnnamed_3 {
53316                        index: C2RustUnnamed_5 { pos: 0 },
53317                    },
53318                    find_keys_type: KSPEC_FK_INVALID,
53319                    fk: C2RustUnnamed_0 {
53320                        range: C2RustUnnamed_2 {
53321                            lastkey: 0,
53322                            keystep: 0,
53323                            limit: 0,
53324                        },
53325                    },
53326                }; 4],
53327                getkeys_proc: None,
53328                subcommands: 0 as *const redisCommand as *mut redisCommand,
53329                args: SUBSCRIBE_Args.as_ptr() as *mut _,
53330                microseconds: 0,
53331                calls: 0,
53332                rejected_calls: 0,
53333                failed_calls: 0,
53334                id: 0,
53335                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53336                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53337                key_specs: 0 as *const keySpec as *mut keySpec,
53338                legacy_range_key_spec: keySpec {
53339                    notes: 0 as *const libc::c_char,
53340                    flags: 0,
53341                    begin_search_type: KSPEC_BS_INVALID,
53342                    bs: C2RustUnnamed_3 {
53343                        index: C2RustUnnamed_5 { pos: 0 },
53344                    },
53345                    find_keys_type: KSPEC_FK_INVALID,
53346                    fk: C2RustUnnamed_0 {
53347                        range: C2RustUnnamed_2 {
53348                            lastkey: 0,
53349                            keystep: 0,
53350                            limit: 0,
53351                        },
53352                    },
53353                },
53354                num_args: 0,
53355                num_history: 0,
53356                num_tips: 0,
53357                key_specs_num: 0,
53358                key_specs_max: 0,
53359                subcommands_dict: 0 as *const dict as *mut dict,
53360                parent: 0 as *const redisCommand as *mut redisCommand,
53361                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53362            };
53363            init
53364        },
53365        {
53366            let mut init = redisCommand {
53367                declared_name: b"sunsubscribe\0" as *const u8 as *const libc::c_char,
53368                summary: b"Stop listening for messages posted to the given shard channels\0"
53369                    as *const u8 as *const libc::c_char,
53370                complexity: b"O(N) where N is the number of clients already subscribed to a shard channel.\0"
53371                    as *const u8 as *const libc::c_char,
53372                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
53373                doc_flags: 0 as libc::c_int,
53374                replaced_by: 0 as *const libc::c_char,
53375                deprecated_since: 0 as *const libc::c_char,
53376                group: COMMAND_GROUP_PUBSUB,
53377                history: 0 as *const commandHistory as *mut commandHistory,
53378                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53379                proc_0: Some(
53380                    sunsubscribeCommand as unsafe extern "C" fn(*mut client) -> (),
53381                ),
53382                arity: -(1 as libc::c_int),
53383                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
53384                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
53385                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
53386                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
53387                acl_categories: 0 as libc::c_int as uint64_t,
53388                key_specs_static: [
53389                    {
53390                        let mut init = keySpec {
53391                            notes: 0 as *const libc::c_char,
53392                            flags: ((1 as libc::c_ulonglong) << 8 as libc::c_int)
53393                                as uint64_t,
53394                            begin_search_type: KSPEC_BS_INDEX,
53395                            bs: C2RustUnnamed_3 {
53396                                index: {
53397                                    let mut init = C2RustUnnamed_5 {
53398                                        pos: 1 as libc::c_int,
53399                                    };
53400                                    init
53401                                },
53402                            },
53403                            find_keys_type: KSPEC_FK_RANGE,
53404                            fk: C2RustUnnamed_0 {
53405                                range: {
53406                                    let mut init = C2RustUnnamed_2 {
53407                                        lastkey: -(1 as libc::c_int),
53408                                        keystep: 1 as libc::c_int,
53409                                        limit: 0 as libc::c_int,
53410                                    };
53411                                    init
53412                                },
53413                            },
53414                        };
53415                        init
53416                    },
53417                    keySpec {
53418                        notes: 0 as *const libc::c_char,
53419                        flags: 0,
53420                        begin_search_type: KSPEC_BS_INVALID,
53421                        bs: C2RustUnnamed_3 {
53422                            index: C2RustUnnamed_5 { pos: 0 },
53423                        },
53424                        find_keys_type: KSPEC_FK_INVALID,
53425                        fk: C2RustUnnamed_0 {
53426                            range: C2RustUnnamed_2 {
53427                                lastkey: 0,
53428                                keystep: 0,
53429                                limit: 0,
53430                            },
53431                        },
53432                    },
53433                    keySpec {
53434                        notes: 0 as *const libc::c_char,
53435                        flags: 0,
53436                        begin_search_type: KSPEC_BS_INVALID,
53437                        bs: C2RustUnnamed_3 {
53438                            index: C2RustUnnamed_5 { pos: 0 },
53439                        },
53440                        find_keys_type: KSPEC_FK_INVALID,
53441                        fk: C2RustUnnamed_0 {
53442                            range: C2RustUnnamed_2 {
53443                                lastkey: 0,
53444                                keystep: 0,
53445                                limit: 0,
53446                            },
53447                        },
53448                    },
53449                    keySpec {
53450                        notes: 0 as *const libc::c_char,
53451                        flags: 0,
53452                        begin_search_type: KSPEC_BS_INVALID,
53453                        bs: C2RustUnnamed_3 {
53454                            index: C2RustUnnamed_5 { pos: 0 },
53455                        },
53456                        find_keys_type: KSPEC_FK_INVALID,
53457                        fk: C2RustUnnamed_0 {
53458                            range: C2RustUnnamed_2 {
53459                                lastkey: 0,
53460                                keystep: 0,
53461                                limit: 0,
53462                            },
53463                        },
53464                    },
53465                ],
53466                getkeys_proc: None,
53467                subcommands: 0 as *const redisCommand as *mut redisCommand,
53468                args: SUNSUBSCRIBE_Args.as_ptr() as *mut _,
53469                microseconds: 0,
53470                calls: 0,
53471                rejected_calls: 0,
53472                failed_calls: 0,
53473                id: 0,
53474                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53475                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53476                key_specs: 0 as *const keySpec as *mut keySpec,
53477                legacy_range_key_spec: keySpec {
53478                    notes: 0 as *const libc::c_char,
53479                    flags: 0,
53480                    begin_search_type: KSPEC_BS_INVALID,
53481                    bs: C2RustUnnamed_3 {
53482                        index: C2RustUnnamed_5 { pos: 0 },
53483                    },
53484                    find_keys_type: KSPEC_FK_INVALID,
53485                    fk: C2RustUnnamed_0 {
53486                        range: C2RustUnnamed_2 {
53487                            lastkey: 0,
53488                            keystep: 0,
53489                            limit: 0,
53490                        },
53491                    },
53492                },
53493                num_args: 0,
53494                num_history: 0,
53495                num_tips: 0,
53496                key_specs_num: 0,
53497                key_specs_max: 0,
53498                subcommands_dict: 0 as *const dict as *mut dict,
53499                parent: 0 as *const redisCommand as *mut redisCommand,
53500                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53501            };
53502            init
53503        },
53504        {
53505            let mut init = redisCommand {
53506                declared_name: b"unsubscribe\0" as *const u8 as *const libc::c_char,
53507                summary: b"Stop listening for messages posted to the given channels\0"
53508                    as *const u8 as *const libc::c_char,
53509                complexity: b"O(N) where N is the number of clients already subscribed to a channel.\0"
53510                    as *const u8 as *const libc::c_char,
53511                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
53512                doc_flags: 0 as libc::c_int,
53513                replaced_by: 0 as *const libc::c_char,
53514                deprecated_since: 0 as *const libc::c_char,
53515                group: COMMAND_GROUP_PUBSUB,
53516                history: 0 as *const commandHistory as *mut commandHistory,
53517                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53518                proc_0: Some(
53519                    unsubscribeCommand as unsafe extern "C" fn(*mut client) -> (),
53520                ),
53521                arity: -(1 as libc::c_int),
53522                flags: ((1 as libc::c_ulonglong) << 5 as libc::c_int
53523                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
53524                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
53525                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
53526                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
53527                acl_categories: 0 as libc::c_int as uint64_t,
53528                key_specs_static: [keySpec {
53529                    notes: 0 as *const libc::c_char,
53530                    flags: 0,
53531                    begin_search_type: KSPEC_BS_INVALID,
53532                    bs: C2RustUnnamed_3 {
53533                        index: C2RustUnnamed_5 { pos: 0 },
53534                    },
53535                    find_keys_type: KSPEC_FK_INVALID,
53536                    fk: C2RustUnnamed_0 {
53537                        range: C2RustUnnamed_2 {
53538                            lastkey: 0,
53539                            keystep: 0,
53540                            limit: 0,
53541                        },
53542                    },
53543                }; 4],
53544                getkeys_proc: None,
53545                subcommands: 0 as *const redisCommand as *mut redisCommand,
53546                args: UNSUBSCRIBE_Args.as_ptr() as *mut _,
53547                microseconds: 0,
53548                calls: 0,
53549                rejected_calls: 0,
53550                failed_calls: 0,
53551                id: 0,
53552                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53553                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53554                key_specs: 0 as *const keySpec as *mut keySpec,
53555                legacy_range_key_spec: keySpec {
53556                    notes: 0 as *const libc::c_char,
53557                    flags: 0,
53558                    begin_search_type: KSPEC_BS_INVALID,
53559                    bs: C2RustUnnamed_3 {
53560                        index: C2RustUnnamed_5 { pos: 0 },
53561                    },
53562                    find_keys_type: KSPEC_FK_INVALID,
53563                    fk: C2RustUnnamed_0 {
53564                        range: C2RustUnnamed_2 {
53565                            lastkey: 0,
53566                            keystep: 0,
53567                            limit: 0,
53568                        },
53569                    },
53570                },
53571                num_args: 0,
53572                num_history: 0,
53573                num_tips: 0,
53574                key_specs_num: 0,
53575                key_specs_max: 0,
53576                subcommands_dict: 0 as *const dict as *mut dict,
53577                parent: 0 as *const redisCommand as *mut redisCommand,
53578                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53579            };
53580            init
53581        },
53582        {
53583            let mut init = redisCommand {
53584                declared_name: b"eval\0" as *const u8 as *const libc::c_char,
53585                summary: b"Execute a Lua script server side\0" as *const u8
53586                    as *const libc::c_char,
53587                complexity: b"Depends on the script that is executed.\0" as *const u8
53588                    as *const libc::c_char,
53589                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
53590                doc_flags: 0 as libc::c_int,
53591                replaced_by: 0 as *const libc::c_char,
53592                deprecated_since: 0 as *const libc::c_char,
53593                group: COMMAND_GROUP_SCRIPTING,
53594                history: 0 as *const commandHistory as *mut commandHistory,
53595                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53596                proc_0: Some(evalCommand as unsafe extern "C" fn(*mut client) -> ()),
53597                arity: -(3 as libc::c_int),
53598                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
53599                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
53600                    | (1 as libc::c_ulonglong) << 16 as libc::c_int
53601                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
53602                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
53603                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
53604                    as uint64_t,
53605                key_specs_static: [
53606                    {
53607                        let mut init = keySpec {
53608                            notes: b"We cannot tell how the keys will be used so we assume the worst, RW and UPDATE\0"
53609                                as *const u8 as *const libc::c_char,
53610                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
53611                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
53612                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
53613                            begin_search_type: KSPEC_BS_INDEX,
53614                            bs: C2RustUnnamed_3 {
53615                                index: {
53616                                    let mut init = C2RustUnnamed_5 {
53617                                        pos: 2 as libc::c_int,
53618                                    };
53619                                    init
53620                                },
53621                            },
53622                            find_keys_type: KSPEC_FK_KEYNUM,
53623                            fk: C2RustUnnamed_0 {
53624                                keynum: {
53625                                    let mut init = C2RustUnnamed_1 {
53626                                        keynumidx: 0 as libc::c_int,
53627                                        firstkey: 1 as libc::c_int,
53628                                        keystep: 1 as libc::c_int,
53629                                    };
53630                                    init
53631                                },
53632                            },
53633                        };
53634                        init
53635                    },
53636                    keySpec {
53637                        notes: 0 as *const libc::c_char,
53638                        flags: 0,
53639                        begin_search_type: KSPEC_BS_INVALID,
53640                        bs: C2RustUnnamed_3 {
53641                            index: C2RustUnnamed_5 { pos: 0 },
53642                        },
53643                        find_keys_type: KSPEC_FK_INVALID,
53644                        fk: C2RustUnnamed_0 {
53645                            range: C2RustUnnamed_2 {
53646                                lastkey: 0,
53647                                keystep: 0,
53648                                limit: 0,
53649                            },
53650                        },
53651                    },
53652                    keySpec {
53653                        notes: 0 as *const libc::c_char,
53654                        flags: 0,
53655                        begin_search_type: KSPEC_BS_INVALID,
53656                        bs: C2RustUnnamed_3 {
53657                            index: C2RustUnnamed_5 { pos: 0 },
53658                        },
53659                        find_keys_type: KSPEC_FK_INVALID,
53660                        fk: C2RustUnnamed_0 {
53661                            range: C2RustUnnamed_2 {
53662                                lastkey: 0,
53663                                keystep: 0,
53664                                limit: 0,
53665                            },
53666                        },
53667                    },
53668                    keySpec {
53669                        notes: 0 as *const libc::c_char,
53670                        flags: 0,
53671                        begin_search_type: KSPEC_BS_INVALID,
53672                        bs: C2RustUnnamed_3 {
53673                            index: C2RustUnnamed_5 { pos: 0 },
53674                        },
53675                        find_keys_type: KSPEC_FK_INVALID,
53676                        fk: C2RustUnnamed_0 {
53677                            range: C2RustUnnamed_2 {
53678                                lastkey: 0,
53679                                keystep: 0,
53680                                limit: 0,
53681                            },
53682                        },
53683                    },
53684                ],
53685                getkeys_proc: Some(
53686                    evalGetKeys
53687                        as unsafe extern "C" fn(
53688                            *mut redisCommand,
53689                            *mut *mut robj,
53690                            libc::c_int,
53691                            *mut getKeysResult,
53692                        ) -> libc::c_int,
53693                ),
53694                subcommands: 0 as *const redisCommand as *mut redisCommand,
53695                args: EVAL_Args.as_ptr() as *mut _,
53696                microseconds: 0,
53697                calls: 0,
53698                rejected_calls: 0,
53699                failed_calls: 0,
53700                id: 0,
53701                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53702                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53703                key_specs: 0 as *const keySpec as *mut keySpec,
53704                legacy_range_key_spec: keySpec {
53705                    notes: 0 as *const libc::c_char,
53706                    flags: 0,
53707                    begin_search_type: KSPEC_BS_INVALID,
53708                    bs: C2RustUnnamed_3 {
53709                        index: C2RustUnnamed_5 { pos: 0 },
53710                    },
53711                    find_keys_type: KSPEC_FK_INVALID,
53712                    fk: C2RustUnnamed_0 {
53713                        range: C2RustUnnamed_2 {
53714                            lastkey: 0,
53715                            keystep: 0,
53716                            limit: 0,
53717                        },
53718                    },
53719                },
53720                num_args: 0,
53721                num_history: 0,
53722                num_tips: 0,
53723                key_specs_num: 0,
53724                key_specs_max: 0,
53725                subcommands_dict: 0 as *const dict as *mut dict,
53726                parent: 0 as *const redisCommand as *mut redisCommand,
53727                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53728            };
53729            init
53730        },
53731        {
53732            let mut init = redisCommand {
53733                declared_name: b"evalsha\0" as *const u8 as *const libc::c_char,
53734                summary: b"Execute a Lua script server side\0" as *const u8
53735                    as *const libc::c_char,
53736                complexity: b"Depends on the script that is executed.\0" as *const u8
53737                    as *const libc::c_char,
53738                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
53739                doc_flags: 0 as libc::c_int,
53740                replaced_by: 0 as *const libc::c_char,
53741                deprecated_since: 0 as *const libc::c_char,
53742                group: COMMAND_GROUP_SCRIPTING,
53743                history: 0 as *const commandHistory as *mut commandHistory,
53744                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53745                proc_0: Some(evalShaCommand as unsafe extern "C" fn(*mut client) -> ()),
53746                arity: -(3 as libc::c_int),
53747                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
53748                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
53749                    | (1 as libc::c_ulonglong) << 16 as libc::c_int
53750                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
53751                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
53752                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
53753                    as uint64_t,
53754                key_specs_static: [
53755                    {
53756                        let mut init = keySpec {
53757                            notes: 0 as *const libc::c_char,
53758                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
53759                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
53760                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
53761                            begin_search_type: KSPEC_BS_INDEX,
53762                            bs: C2RustUnnamed_3 {
53763                                index: {
53764                                    let mut init = C2RustUnnamed_5 {
53765                                        pos: 2 as libc::c_int,
53766                                    };
53767                                    init
53768                                },
53769                            },
53770                            find_keys_type: KSPEC_FK_KEYNUM,
53771                            fk: C2RustUnnamed_0 {
53772                                keynum: {
53773                                    let mut init = C2RustUnnamed_1 {
53774                                        keynumidx: 0 as libc::c_int,
53775                                        firstkey: 1 as libc::c_int,
53776                                        keystep: 1 as libc::c_int,
53777                                    };
53778                                    init
53779                                },
53780                            },
53781                        };
53782                        init
53783                    },
53784                    keySpec {
53785                        notes: 0 as *const libc::c_char,
53786                        flags: 0,
53787                        begin_search_type: KSPEC_BS_INVALID,
53788                        bs: C2RustUnnamed_3 {
53789                            index: C2RustUnnamed_5 { pos: 0 },
53790                        },
53791                        find_keys_type: KSPEC_FK_INVALID,
53792                        fk: C2RustUnnamed_0 {
53793                            range: C2RustUnnamed_2 {
53794                                lastkey: 0,
53795                                keystep: 0,
53796                                limit: 0,
53797                            },
53798                        },
53799                    },
53800                    keySpec {
53801                        notes: 0 as *const libc::c_char,
53802                        flags: 0,
53803                        begin_search_type: KSPEC_BS_INVALID,
53804                        bs: C2RustUnnamed_3 {
53805                            index: C2RustUnnamed_5 { pos: 0 },
53806                        },
53807                        find_keys_type: KSPEC_FK_INVALID,
53808                        fk: C2RustUnnamed_0 {
53809                            range: C2RustUnnamed_2 {
53810                                lastkey: 0,
53811                                keystep: 0,
53812                                limit: 0,
53813                            },
53814                        },
53815                    },
53816                    keySpec {
53817                        notes: 0 as *const libc::c_char,
53818                        flags: 0,
53819                        begin_search_type: KSPEC_BS_INVALID,
53820                        bs: C2RustUnnamed_3 {
53821                            index: C2RustUnnamed_5 { pos: 0 },
53822                        },
53823                        find_keys_type: KSPEC_FK_INVALID,
53824                        fk: C2RustUnnamed_0 {
53825                            range: C2RustUnnamed_2 {
53826                                lastkey: 0,
53827                                keystep: 0,
53828                                limit: 0,
53829                            },
53830                        },
53831                    },
53832                ],
53833                getkeys_proc: Some(
53834                    evalGetKeys
53835                        as unsafe extern "C" fn(
53836                            *mut redisCommand,
53837                            *mut *mut robj,
53838                            libc::c_int,
53839                            *mut getKeysResult,
53840                        ) -> libc::c_int,
53841                ),
53842                subcommands: 0 as *const redisCommand as *mut redisCommand,
53843                args: EVALSHA_Args.as_ptr() as *mut _,
53844                microseconds: 0,
53845                calls: 0,
53846                rejected_calls: 0,
53847                failed_calls: 0,
53848                id: 0,
53849                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53850                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
53851                key_specs: 0 as *const keySpec as *mut keySpec,
53852                legacy_range_key_spec: keySpec {
53853                    notes: 0 as *const libc::c_char,
53854                    flags: 0,
53855                    begin_search_type: KSPEC_BS_INVALID,
53856                    bs: C2RustUnnamed_3 {
53857                        index: C2RustUnnamed_5 { pos: 0 },
53858                    },
53859                    find_keys_type: KSPEC_FK_INVALID,
53860                    fk: C2RustUnnamed_0 {
53861                        range: C2RustUnnamed_2 {
53862                            lastkey: 0,
53863                            keystep: 0,
53864                            limit: 0,
53865                        },
53866                    },
53867                },
53868                num_args: 0,
53869                num_history: 0,
53870                num_tips: 0,
53871                key_specs_num: 0,
53872                key_specs_max: 0,
53873                subcommands_dict: 0 as *const dict as *mut dict,
53874                parent: 0 as *const redisCommand as *mut redisCommand,
53875                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
53876            };
53877            init
53878        },
53879        {
53880            let mut init = redisCommand {
53881                declared_name: b"evalsha_ro\0" as *const u8 as *const libc::c_char,
53882                summary: b"Execute a read-only Lua script server side\0" as *const u8
53883                    as *const libc::c_char,
53884                complexity: b"Depends on the script that is executed.\0" as *const u8
53885                    as *const libc::c_char,
53886                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
53887                doc_flags: 0 as libc::c_int,
53888                replaced_by: 0 as *const libc::c_char,
53889                deprecated_since: 0 as *const libc::c_char,
53890                group: COMMAND_GROUP_SCRIPTING,
53891                history: 0 as *const commandHistory as *mut commandHistory,
53892                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
53893                proc_0: Some(
53894                    evalShaRoCommand as unsafe extern "C" fn(*mut client) -> (),
53895                ),
53896                arity: -(3 as libc::c_int),
53897                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
53898                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
53899                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
53900                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
53901                    | (1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
53902                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
53903                    as uint64_t,
53904                key_specs_static: [
53905                    {
53906                        let mut init = keySpec {
53907                            notes: 0 as *const libc::c_char,
53908                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
53909                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
53910                            begin_search_type: KSPEC_BS_INDEX,
53911                            bs: C2RustUnnamed_3 {
53912                                index: {
53913                                    let mut init = C2RustUnnamed_5 {
53914                                        pos: 2 as libc::c_int,
53915                                    };
53916                                    init
53917                                },
53918                            },
53919                            find_keys_type: KSPEC_FK_KEYNUM,
53920                            fk: C2RustUnnamed_0 {
53921                                keynum: {
53922                                    let mut init = C2RustUnnamed_1 {
53923                                        keynumidx: 0 as libc::c_int,
53924                                        firstkey: 1 as libc::c_int,
53925                                        keystep: 1 as libc::c_int,
53926                                    };
53927                                    init
53928                                },
53929                            },
53930                        };
53931                        init
53932                    },
53933                    keySpec {
53934                        notes: 0 as *const libc::c_char,
53935                        flags: 0,
53936                        begin_search_type: KSPEC_BS_INVALID,
53937                        bs: C2RustUnnamed_3 {
53938                            index: C2RustUnnamed_5 { pos: 0 },
53939                        },
53940                        find_keys_type: KSPEC_FK_INVALID,
53941                        fk: C2RustUnnamed_0 {
53942                            range: C2RustUnnamed_2 {
53943                                lastkey: 0,
53944                                keystep: 0,
53945                                limit: 0,
53946                            },
53947                        },
53948                    },
53949                    keySpec {
53950                        notes: 0 as *const libc::c_char,
53951                        flags: 0,
53952                        begin_search_type: KSPEC_BS_INVALID,
53953                        bs: C2RustUnnamed_3 {
53954                            index: C2RustUnnamed_5 { pos: 0 },
53955                        },
53956                        find_keys_type: KSPEC_FK_INVALID,
53957                        fk: C2RustUnnamed_0 {
53958                            range: C2RustUnnamed_2 {
53959                                lastkey: 0,
53960                                keystep: 0,
53961                                limit: 0,
53962                            },
53963                        },
53964                    },
53965                    keySpec {
53966                        notes: 0 as *const libc::c_char,
53967                        flags: 0,
53968                        begin_search_type: KSPEC_BS_INVALID,
53969                        bs: C2RustUnnamed_3 {
53970                            index: C2RustUnnamed_5 { pos: 0 },
53971                        },
53972                        find_keys_type: KSPEC_FK_INVALID,
53973                        fk: C2RustUnnamed_0 {
53974                            range: C2RustUnnamed_2 {
53975                                lastkey: 0,
53976                                keystep: 0,
53977                                limit: 0,
53978                            },
53979                        },
53980                    },
53981                ],
53982                getkeys_proc: Some(
53983                    evalGetKeys
53984                        as unsafe extern "C" fn(
53985                            *mut redisCommand,
53986                            *mut *mut robj,
53987                            libc::c_int,
53988                            *mut getKeysResult,
53989                        ) -> libc::c_int,
53990                ),
53991                subcommands: 0 as *const redisCommand as *mut redisCommand,
53992                args: EVALSHA_RO_Args.as_ptr() as *mut _,
53993                microseconds: 0,
53994                calls: 0,
53995                rejected_calls: 0,
53996                failed_calls: 0,
53997                id: 0,
53998                fullname: 0 as *const libc::c_char as *mut libc::c_char,
53999                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54000                key_specs: 0 as *const keySpec as *mut keySpec,
54001                legacy_range_key_spec: keySpec {
54002                    notes: 0 as *const libc::c_char,
54003                    flags: 0,
54004                    begin_search_type: KSPEC_BS_INVALID,
54005                    bs: C2RustUnnamed_3 {
54006                        index: C2RustUnnamed_5 { pos: 0 },
54007                    },
54008                    find_keys_type: KSPEC_FK_INVALID,
54009                    fk: C2RustUnnamed_0 {
54010                        range: C2RustUnnamed_2 {
54011                            lastkey: 0,
54012                            keystep: 0,
54013                            limit: 0,
54014                        },
54015                    },
54016                },
54017                num_args: 0,
54018                num_history: 0,
54019                num_tips: 0,
54020                key_specs_num: 0,
54021                key_specs_max: 0,
54022                subcommands_dict: 0 as *const dict as *mut dict,
54023                parent: 0 as *const redisCommand as *mut redisCommand,
54024                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54025            };
54026            init
54027        },
54028        {
54029            let mut init = redisCommand {
54030                declared_name: b"eval_ro\0" as *const u8 as *const libc::c_char,
54031                summary: b"Execute a read-only Lua script server side\0" as *const u8
54032                    as *const libc::c_char,
54033                complexity: b"Depends on the script that is executed.\0" as *const u8
54034                    as *const libc::c_char,
54035                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
54036                doc_flags: 0 as libc::c_int,
54037                replaced_by: 0 as *const libc::c_char,
54038                deprecated_since: 0 as *const libc::c_char,
54039                group: COMMAND_GROUP_SCRIPTING,
54040                history: 0 as *const commandHistory as *mut commandHistory,
54041                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54042                proc_0: Some(evalRoCommand as unsafe extern "C" fn(*mut client) -> ()),
54043                arity: -(3 as libc::c_int),
54044                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
54045                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
54046                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
54047                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
54048                    | (1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
54049                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
54050                    as uint64_t,
54051                key_specs_static: [
54052                    {
54053                        let mut init = keySpec {
54054                            notes: b"We cannot tell how the keys will be used so we assume the worst, RO and ACCESS\0"
54055                                as *const u8 as *const libc::c_char,
54056                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
54057                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
54058                            begin_search_type: KSPEC_BS_INDEX,
54059                            bs: C2RustUnnamed_3 {
54060                                index: {
54061                                    let mut init = C2RustUnnamed_5 {
54062                                        pos: 2 as libc::c_int,
54063                                    };
54064                                    init
54065                                },
54066                            },
54067                            find_keys_type: KSPEC_FK_KEYNUM,
54068                            fk: C2RustUnnamed_0 {
54069                                keynum: {
54070                                    let mut init = C2RustUnnamed_1 {
54071                                        keynumidx: 0 as libc::c_int,
54072                                        firstkey: 1 as libc::c_int,
54073                                        keystep: 1 as libc::c_int,
54074                                    };
54075                                    init
54076                                },
54077                            },
54078                        };
54079                        init
54080                    },
54081                    keySpec {
54082                        notes: 0 as *const libc::c_char,
54083                        flags: 0,
54084                        begin_search_type: KSPEC_BS_INVALID,
54085                        bs: C2RustUnnamed_3 {
54086                            index: C2RustUnnamed_5 { pos: 0 },
54087                        },
54088                        find_keys_type: KSPEC_FK_INVALID,
54089                        fk: C2RustUnnamed_0 {
54090                            range: C2RustUnnamed_2 {
54091                                lastkey: 0,
54092                                keystep: 0,
54093                                limit: 0,
54094                            },
54095                        },
54096                    },
54097                    keySpec {
54098                        notes: 0 as *const libc::c_char,
54099                        flags: 0,
54100                        begin_search_type: KSPEC_BS_INVALID,
54101                        bs: C2RustUnnamed_3 {
54102                            index: C2RustUnnamed_5 { pos: 0 },
54103                        },
54104                        find_keys_type: KSPEC_FK_INVALID,
54105                        fk: C2RustUnnamed_0 {
54106                            range: C2RustUnnamed_2 {
54107                                lastkey: 0,
54108                                keystep: 0,
54109                                limit: 0,
54110                            },
54111                        },
54112                    },
54113                    keySpec {
54114                        notes: 0 as *const libc::c_char,
54115                        flags: 0,
54116                        begin_search_type: KSPEC_BS_INVALID,
54117                        bs: C2RustUnnamed_3 {
54118                            index: C2RustUnnamed_5 { pos: 0 },
54119                        },
54120                        find_keys_type: KSPEC_FK_INVALID,
54121                        fk: C2RustUnnamed_0 {
54122                            range: C2RustUnnamed_2 {
54123                                lastkey: 0,
54124                                keystep: 0,
54125                                limit: 0,
54126                            },
54127                        },
54128                    },
54129                ],
54130                getkeys_proc: Some(
54131                    evalGetKeys
54132                        as unsafe extern "C" fn(
54133                            *mut redisCommand,
54134                            *mut *mut robj,
54135                            libc::c_int,
54136                            *mut getKeysResult,
54137                        ) -> libc::c_int,
54138                ),
54139                subcommands: 0 as *const redisCommand as *mut redisCommand,
54140                args: EVAL_RO_Args.as_ptr() as *mut _,
54141                microseconds: 0,
54142                calls: 0,
54143                rejected_calls: 0,
54144                failed_calls: 0,
54145                id: 0,
54146                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54147                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54148                key_specs: 0 as *const keySpec as *mut keySpec,
54149                legacy_range_key_spec: keySpec {
54150                    notes: 0 as *const libc::c_char,
54151                    flags: 0,
54152                    begin_search_type: KSPEC_BS_INVALID,
54153                    bs: C2RustUnnamed_3 {
54154                        index: C2RustUnnamed_5 { pos: 0 },
54155                    },
54156                    find_keys_type: KSPEC_FK_INVALID,
54157                    fk: C2RustUnnamed_0 {
54158                        range: C2RustUnnamed_2 {
54159                            lastkey: 0,
54160                            keystep: 0,
54161                            limit: 0,
54162                        },
54163                    },
54164                },
54165                num_args: 0,
54166                num_history: 0,
54167                num_tips: 0,
54168                key_specs_num: 0,
54169                key_specs_max: 0,
54170                subcommands_dict: 0 as *const dict as *mut dict,
54171                parent: 0 as *const redisCommand as *mut redisCommand,
54172                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54173            };
54174            init
54175        },
54176        {
54177            let mut init = redisCommand {
54178                declared_name: b"fcall\0" as *const u8 as *const libc::c_char,
54179                summary: b"Invoke a function\0" as *const u8 as *const libc::c_char,
54180                complexity: b"Depends on the function that is executed.\0" as *const u8
54181                    as *const libc::c_char,
54182                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
54183                doc_flags: 0 as libc::c_int,
54184                replaced_by: 0 as *const libc::c_char,
54185                deprecated_since: 0 as *const libc::c_char,
54186                group: COMMAND_GROUP_SCRIPTING,
54187                history: 0 as *const commandHistory as *mut commandHistory,
54188                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54189                proc_0: Some(fcallCommand as unsafe extern "C" fn(*mut client) -> ()),
54190                arity: -(3 as libc::c_int),
54191                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
54192                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
54193                    | (1 as libc::c_ulonglong) << 16 as libc::c_int
54194                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
54195                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
54196                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
54197                    as uint64_t,
54198                key_specs_static: [
54199                    {
54200                        let mut init = keySpec {
54201                            notes: b"We cannot tell how the keys will be used so we assume the worst, RW and UPDATE\0"
54202                                as *const u8 as *const libc::c_char,
54203                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
54204                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
54205                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
54206                            begin_search_type: KSPEC_BS_INDEX,
54207                            bs: C2RustUnnamed_3 {
54208                                index: {
54209                                    let mut init = C2RustUnnamed_5 {
54210                                        pos: 2 as libc::c_int,
54211                                    };
54212                                    init
54213                                },
54214                            },
54215                            find_keys_type: KSPEC_FK_KEYNUM,
54216                            fk: C2RustUnnamed_0 {
54217                                keynum: {
54218                                    let mut init = C2RustUnnamed_1 {
54219                                        keynumidx: 0 as libc::c_int,
54220                                        firstkey: 1 as libc::c_int,
54221                                        keystep: 1 as libc::c_int,
54222                                    };
54223                                    init
54224                                },
54225                            },
54226                        };
54227                        init
54228                    },
54229                    keySpec {
54230                        notes: 0 as *const libc::c_char,
54231                        flags: 0,
54232                        begin_search_type: KSPEC_BS_INVALID,
54233                        bs: C2RustUnnamed_3 {
54234                            index: C2RustUnnamed_5 { pos: 0 },
54235                        },
54236                        find_keys_type: KSPEC_FK_INVALID,
54237                        fk: C2RustUnnamed_0 {
54238                            range: C2RustUnnamed_2 {
54239                                lastkey: 0,
54240                                keystep: 0,
54241                                limit: 0,
54242                            },
54243                        },
54244                    },
54245                    keySpec {
54246                        notes: 0 as *const libc::c_char,
54247                        flags: 0,
54248                        begin_search_type: KSPEC_BS_INVALID,
54249                        bs: C2RustUnnamed_3 {
54250                            index: C2RustUnnamed_5 { pos: 0 },
54251                        },
54252                        find_keys_type: KSPEC_FK_INVALID,
54253                        fk: C2RustUnnamed_0 {
54254                            range: C2RustUnnamed_2 {
54255                                lastkey: 0,
54256                                keystep: 0,
54257                                limit: 0,
54258                            },
54259                        },
54260                    },
54261                    keySpec {
54262                        notes: 0 as *const libc::c_char,
54263                        flags: 0,
54264                        begin_search_type: KSPEC_BS_INVALID,
54265                        bs: C2RustUnnamed_3 {
54266                            index: C2RustUnnamed_5 { pos: 0 },
54267                        },
54268                        find_keys_type: KSPEC_FK_INVALID,
54269                        fk: C2RustUnnamed_0 {
54270                            range: C2RustUnnamed_2 {
54271                                lastkey: 0,
54272                                keystep: 0,
54273                                limit: 0,
54274                            },
54275                        },
54276                    },
54277                ],
54278                getkeys_proc: Some(
54279                    functionGetKeys
54280                        as unsafe extern "C" fn(
54281                            *mut redisCommand,
54282                            *mut *mut robj,
54283                            libc::c_int,
54284                            *mut getKeysResult,
54285                        ) -> libc::c_int,
54286                ),
54287                subcommands: 0 as *const redisCommand as *mut redisCommand,
54288                args: FCALL_Args.as_ptr() as *mut _,
54289                microseconds: 0,
54290                calls: 0,
54291                rejected_calls: 0,
54292                failed_calls: 0,
54293                id: 0,
54294                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54295                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54296                key_specs: 0 as *const keySpec as *mut keySpec,
54297                legacy_range_key_spec: keySpec {
54298                    notes: 0 as *const libc::c_char,
54299                    flags: 0,
54300                    begin_search_type: KSPEC_BS_INVALID,
54301                    bs: C2RustUnnamed_3 {
54302                        index: C2RustUnnamed_5 { pos: 0 },
54303                    },
54304                    find_keys_type: KSPEC_FK_INVALID,
54305                    fk: C2RustUnnamed_0 {
54306                        range: C2RustUnnamed_2 {
54307                            lastkey: 0,
54308                            keystep: 0,
54309                            limit: 0,
54310                        },
54311                    },
54312                },
54313                num_args: 0,
54314                num_history: 0,
54315                num_tips: 0,
54316                key_specs_num: 0,
54317                key_specs_max: 0,
54318                subcommands_dict: 0 as *const dict as *mut dict,
54319                parent: 0 as *const redisCommand as *mut redisCommand,
54320                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54321            };
54322            init
54323        },
54324        {
54325            let mut init = redisCommand {
54326                declared_name: b"fcall_ro\0" as *const u8 as *const libc::c_char,
54327                summary: b"Invoke a read-only function\0" as *const u8
54328                    as *const libc::c_char,
54329                complexity: b"Depends on the function that is executed.\0" as *const u8
54330                    as *const libc::c_char,
54331                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
54332                doc_flags: 0 as libc::c_int,
54333                replaced_by: 0 as *const libc::c_char,
54334                deprecated_since: 0 as *const libc::c_char,
54335                group: COMMAND_GROUP_SCRIPTING,
54336                history: 0 as *const commandHistory as *mut commandHistory,
54337                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54338                proc_0: Some(fcallroCommand as unsafe extern "C" fn(*mut client) -> ()),
54339                arity: -(3 as libc::c_int),
54340                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
54341                    | (1 as libc::c_ulonglong) << 11 as libc::c_int
54342                    | (1 as libc::c_ulonglong) << 19 as libc::c_int
54343                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
54344                    | (1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
54345                acl_categories: ((1 as libc::c_ulonglong) << 20 as libc::c_int)
54346                    as uint64_t,
54347                key_specs_static: [
54348                    {
54349                        let mut init = keySpec {
54350                            notes: b"We cannot tell how the keys will be used so we assume the worst, RO and ACCESS\0"
54351                                as *const u8 as *const libc::c_char,
54352                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
54353                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
54354                            begin_search_type: KSPEC_BS_INDEX,
54355                            bs: C2RustUnnamed_3 {
54356                                index: {
54357                                    let mut init = C2RustUnnamed_5 {
54358                                        pos: 2 as libc::c_int,
54359                                    };
54360                                    init
54361                                },
54362                            },
54363                            find_keys_type: KSPEC_FK_KEYNUM,
54364                            fk: C2RustUnnamed_0 {
54365                                keynum: {
54366                                    let mut init = C2RustUnnamed_1 {
54367                                        keynumidx: 0 as libc::c_int,
54368                                        firstkey: 1 as libc::c_int,
54369                                        keystep: 1 as libc::c_int,
54370                                    };
54371                                    init
54372                                },
54373                            },
54374                        };
54375                        init
54376                    },
54377                    keySpec {
54378                        notes: 0 as *const libc::c_char,
54379                        flags: 0,
54380                        begin_search_type: KSPEC_BS_INVALID,
54381                        bs: C2RustUnnamed_3 {
54382                            index: C2RustUnnamed_5 { pos: 0 },
54383                        },
54384                        find_keys_type: KSPEC_FK_INVALID,
54385                        fk: C2RustUnnamed_0 {
54386                            range: C2RustUnnamed_2 {
54387                                lastkey: 0,
54388                                keystep: 0,
54389                                limit: 0,
54390                            },
54391                        },
54392                    },
54393                    keySpec {
54394                        notes: 0 as *const libc::c_char,
54395                        flags: 0,
54396                        begin_search_type: KSPEC_BS_INVALID,
54397                        bs: C2RustUnnamed_3 {
54398                            index: C2RustUnnamed_5 { pos: 0 },
54399                        },
54400                        find_keys_type: KSPEC_FK_INVALID,
54401                        fk: C2RustUnnamed_0 {
54402                            range: C2RustUnnamed_2 {
54403                                lastkey: 0,
54404                                keystep: 0,
54405                                limit: 0,
54406                            },
54407                        },
54408                    },
54409                    keySpec {
54410                        notes: 0 as *const libc::c_char,
54411                        flags: 0,
54412                        begin_search_type: KSPEC_BS_INVALID,
54413                        bs: C2RustUnnamed_3 {
54414                            index: C2RustUnnamed_5 { pos: 0 },
54415                        },
54416                        find_keys_type: KSPEC_FK_INVALID,
54417                        fk: C2RustUnnamed_0 {
54418                            range: C2RustUnnamed_2 {
54419                                lastkey: 0,
54420                                keystep: 0,
54421                                limit: 0,
54422                            },
54423                        },
54424                    },
54425                ],
54426                getkeys_proc: Some(
54427                    functionGetKeys
54428                        as unsafe extern "C" fn(
54429                            *mut redisCommand,
54430                            *mut *mut robj,
54431                            libc::c_int,
54432                            *mut getKeysResult,
54433                        ) -> libc::c_int,
54434                ),
54435                subcommands: 0 as *const redisCommand as *mut redisCommand,
54436                args: FCALL_RO_Args.as_ptr() as *mut _,
54437                microseconds: 0,
54438                calls: 0,
54439                rejected_calls: 0,
54440                failed_calls: 0,
54441                id: 0,
54442                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54443                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54444                key_specs: 0 as *const keySpec as *mut keySpec,
54445                legacy_range_key_spec: keySpec {
54446                    notes: 0 as *const libc::c_char,
54447                    flags: 0,
54448                    begin_search_type: KSPEC_BS_INVALID,
54449                    bs: C2RustUnnamed_3 {
54450                        index: C2RustUnnamed_5 { pos: 0 },
54451                    },
54452                    find_keys_type: KSPEC_FK_INVALID,
54453                    fk: C2RustUnnamed_0 {
54454                        range: C2RustUnnamed_2 {
54455                            lastkey: 0,
54456                            keystep: 0,
54457                            limit: 0,
54458                        },
54459                    },
54460                },
54461                num_args: 0,
54462                num_history: 0,
54463                num_tips: 0,
54464                key_specs_num: 0,
54465                key_specs_max: 0,
54466                subcommands_dict: 0 as *const dict as *mut dict,
54467                parent: 0 as *const redisCommand as *mut redisCommand,
54468                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54469            };
54470            init
54471        },
54472        {
54473            let mut init = redisCommand {
54474                declared_name: b"function\0" as *const u8 as *const libc::c_char,
54475                summary: b"A container for function commands\0" as *const u8
54476                    as *const libc::c_char,
54477                complexity: b"Depends on subcommand.\0" as *const u8
54478                    as *const libc::c_char,
54479                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
54480                doc_flags: 0 as libc::c_int,
54481                replaced_by: 0 as *const libc::c_char,
54482                deprecated_since: 0 as *const libc::c_char,
54483                group: COMMAND_GROUP_SCRIPTING,
54484                history: 0 as *const commandHistory as *mut commandHistory,
54485                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54486                proc_0: None,
54487                arity: -(2 as libc::c_int),
54488                flags: 0 as libc::c_int as uint64_t,
54489                acl_categories: 0 as libc::c_int as uint64_t,
54490                key_specs_static: [keySpec {
54491                    notes: 0 as *const libc::c_char,
54492                    flags: 0,
54493                    begin_search_type: KSPEC_BS_INVALID,
54494                    bs: C2RustUnnamed_3 {
54495                        index: C2RustUnnamed_5 { pos: 0 },
54496                    },
54497                    find_keys_type: KSPEC_FK_INVALID,
54498                    fk: C2RustUnnamed_0 {
54499                        range: C2RustUnnamed_2 {
54500                            lastkey: 0,
54501                            keystep: 0,
54502                            limit: 0,
54503                        },
54504                    },
54505                }; 4],
54506                getkeys_proc: None,
54507                subcommands: FUNCTION_Subcommands.as_ptr() as *mut _,
54508                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54509                microseconds: 0,
54510                calls: 0,
54511                rejected_calls: 0,
54512                failed_calls: 0,
54513                id: 0,
54514                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54515                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54516                key_specs: 0 as *const keySpec as *mut keySpec,
54517                legacy_range_key_spec: keySpec {
54518                    notes: 0 as *const libc::c_char,
54519                    flags: 0,
54520                    begin_search_type: KSPEC_BS_INVALID,
54521                    bs: C2RustUnnamed_3 {
54522                        index: C2RustUnnamed_5 { pos: 0 },
54523                    },
54524                    find_keys_type: KSPEC_FK_INVALID,
54525                    fk: C2RustUnnamed_0 {
54526                        range: C2RustUnnamed_2 {
54527                            lastkey: 0,
54528                            keystep: 0,
54529                            limit: 0,
54530                        },
54531                    },
54532                },
54533                num_args: 0,
54534                num_history: 0,
54535                num_tips: 0,
54536                key_specs_num: 0,
54537                key_specs_max: 0,
54538                subcommands_dict: 0 as *const dict as *mut dict,
54539                parent: 0 as *const redisCommand as *mut redisCommand,
54540                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54541            };
54542            init
54543        },
54544        {
54545            let mut init = redisCommand {
54546                declared_name: b"script\0" as *const u8 as *const libc::c_char,
54547                summary: b"A container for Lua scripts management commands\0"
54548                    as *const u8 as *const libc::c_char,
54549                complexity: b"Depends on subcommand.\0" as *const u8
54550                    as *const libc::c_char,
54551                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
54552                doc_flags: 0 as libc::c_int,
54553                replaced_by: 0 as *const libc::c_char,
54554                deprecated_since: 0 as *const libc::c_char,
54555                group: COMMAND_GROUP_SCRIPTING,
54556                history: 0 as *const commandHistory as *mut commandHistory,
54557                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54558                proc_0: None,
54559                arity: -(2 as libc::c_int),
54560                flags: 0 as libc::c_int as uint64_t,
54561                acl_categories: 0 as libc::c_int as uint64_t,
54562                key_specs_static: [keySpec {
54563                    notes: 0 as *const libc::c_char,
54564                    flags: 0,
54565                    begin_search_type: KSPEC_BS_INVALID,
54566                    bs: C2RustUnnamed_3 {
54567                        index: C2RustUnnamed_5 { pos: 0 },
54568                    },
54569                    find_keys_type: KSPEC_FK_INVALID,
54570                    fk: C2RustUnnamed_0 {
54571                        range: C2RustUnnamed_2 {
54572                            lastkey: 0,
54573                            keystep: 0,
54574                            limit: 0,
54575                        },
54576                    },
54577                }; 4],
54578                getkeys_proc: None,
54579                subcommands: SCRIPT_Subcommands.as_ptr() as *mut _,
54580                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54581                microseconds: 0,
54582                calls: 0,
54583                rejected_calls: 0,
54584                failed_calls: 0,
54585                id: 0,
54586                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54587                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54588                key_specs: 0 as *const keySpec as *mut keySpec,
54589                legacy_range_key_spec: keySpec {
54590                    notes: 0 as *const libc::c_char,
54591                    flags: 0,
54592                    begin_search_type: KSPEC_BS_INVALID,
54593                    bs: C2RustUnnamed_3 {
54594                        index: C2RustUnnamed_5 { pos: 0 },
54595                    },
54596                    find_keys_type: KSPEC_FK_INVALID,
54597                    fk: C2RustUnnamed_0 {
54598                        range: C2RustUnnamed_2 {
54599                            lastkey: 0,
54600                            keystep: 0,
54601                            limit: 0,
54602                        },
54603                    },
54604                },
54605                num_args: 0,
54606                num_history: 0,
54607                num_tips: 0,
54608                key_specs_num: 0,
54609                key_specs_max: 0,
54610                subcommands_dict: 0 as *const dict as *mut dict,
54611                parent: 0 as *const redisCommand as *mut redisCommand,
54612                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54613            };
54614            init
54615        },
54616        {
54617            let mut init = redisCommand {
54618                declared_name: b"sentinel\0" as *const u8 as *const libc::c_char,
54619                summary: b"A container for Sentinel commands\0" as *const u8
54620                    as *const libc::c_char,
54621                complexity: b"Depends on subcommand.\0" as *const u8
54622                    as *const libc::c_char,
54623                since: b"2.8.4\0" as *const u8 as *const libc::c_char,
54624                doc_flags: 0 as libc::c_int,
54625                replaced_by: 0 as *const libc::c_char,
54626                deprecated_since: 0 as *const libc::c_char,
54627                group: COMMAND_GROUP_SENTINEL,
54628                history: 0 as *const commandHistory as *mut commandHistory,
54629                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54630                proc_0: None,
54631                arity: -(2 as libc::c_int),
54632                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
54633                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
54634                    | (1 as libc::c_ulonglong) << 18 as libc::c_int) as uint64_t,
54635                acl_categories: 0 as libc::c_int as uint64_t,
54636                key_specs_static: [keySpec {
54637                    notes: 0 as *const libc::c_char,
54638                    flags: 0,
54639                    begin_search_type: KSPEC_BS_INVALID,
54640                    bs: C2RustUnnamed_3 {
54641                        index: C2RustUnnamed_5 { pos: 0 },
54642                    },
54643                    find_keys_type: KSPEC_FK_INVALID,
54644                    fk: C2RustUnnamed_0 {
54645                        range: C2RustUnnamed_2 {
54646                            lastkey: 0,
54647                            keystep: 0,
54648                            limit: 0,
54649                        },
54650                    },
54651                }; 4],
54652                getkeys_proc: None,
54653                subcommands: SENTINEL_Subcommands.as_ptr() as *mut _,
54654                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54655                microseconds: 0,
54656                calls: 0,
54657                rejected_calls: 0,
54658                failed_calls: 0,
54659                id: 0,
54660                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54661                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54662                key_specs: 0 as *const keySpec as *mut keySpec,
54663                legacy_range_key_spec: keySpec {
54664                    notes: 0 as *const libc::c_char,
54665                    flags: 0,
54666                    begin_search_type: KSPEC_BS_INVALID,
54667                    bs: C2RustUnnamed_3 {
54668                        index: C2RustUnnamed_5 { pos: 0 },
54669                    },
54670                    find_keys_type: KSPEC_FK_INVALID,
54671                    fk: C2RustUnnamed_0 {
54672                        range: C2RustUnnamed_2 {
54673                            lastkey: 0,
54674                            keystep: 0,
54675                            limit: 0,
54676                        },
54677                    },
54678                },
54679                num_args: 0,
54680                num_history: 0,
54681                num_tips: 0,
54682                key_specs_num: 0,
54683                key_specs_max: 0,
54684                subcommands_dict: 0 as *const dict as *mut dict,
54685                parent: 0 as *const redisCommand as *mut redisCommand,
54686                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54687            };
54688            init
54689        },
54690        {
54691            let mut init = redisCommand {
54692                declared_name: b"acl\0" as *const u8 as *const libc::c_char,
54693                summary: b"A container for Access List Control commands \0" as *const u8
54694                    as *const libc::c_char,
54695                complexity: b"Depends on subcommand.\0" as *const u8
54696                    as *const libc::c_char,
54697                since: b"6.0.0\0" as *const u8 as *const libc::c_char,
54698                doc_flags: 0 as libc::c_int,
54699                replaced_by: 0 as *const libc::c_char,
54700                deprecated_since: 0 as *const libc::c_char,
54701                group: COMMAND_GROUP_SERVER,
54702                history: 0 as *const commandHistory as *mut commandHistory,
54703                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54704                proc_0: None,
54705                arity: -(2 as libc::c_int),
54706                flags: ((1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
54707                acl_categories: 0 as libc::c_int as uint64_t,
54708                key_specs_static: [keySpec {
54709                    notes: 0 as *const libc::c_char,
54710                    flags: 0,
54711                    begin_search_type: KSPEC_BS_INVALID,
54712                    bs: C2RustUnnamed_3 {
54713                        index: C2RustUnnamed_5 { pos: 0 },
54714                    },
54715                    find_keys_type: KSPEC_FK_INVALID,
54716                    fk: C2RustUnnamed_0 {
54717                        range: C2RustUnnamed_2 {
54718                            lastkey: 0,
54719                            keystep: 0,
54720                            limit: 0,
54721                        },
54722                    },
54723                }; 4],
54724                getkeys_proc: None,
54725                subcommands: ACL_Subcommands.as_ptr() as *mut _,
54726                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54727                microseconds: 0,
54728                calls: 0,
54729                rejected_calls: 0,
54730                failed_calls: 0,
54731                id: 0,
54732                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54733                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54734                key_specs: 0 as *const keySpec as *mut keySpec,
54735                legacy_range_key_spec: keySpec {
54736                    notes: 0 as *const libc::c_char,
54737                    flags: 0,
54738                    begin_search_type: KSPEC_BS_INVALID,
54739                    bs: C2RustUnnamed_3 {
54740                        index: C2RustUnnamed_5 { pos: 0 },
54741                    },
54742                    find_keys_type: KSPEC_FK_INVALID,
54743                    fk: C2RustUnnamed_0 {
54744                        range: C2RustUnnamed_2 {
54745                            lastkey: 0,
54746                            keystep: 0,
54747                            limit: 0,
54748                        },
54749                    },
54750                },
54751                num_args: 0,
54752                num_history: 0,
54753                num_tips: 0,
54754                key_specs_num: 0,
54755                key_specs_max: 0,
54756                subcommands_dict: 0 as *const dict as *mut dict,
54757                parent: 0 as *const redisCommand as *mut redisCommand,
54758                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54759            };
54760            init
54761        },
54762        {
54763            let mut init = redisCommand {
54764                declared_name: b"bgrewriteaof\0" as *const u8 as *const libc::c_char,
54765                summary: b"Asynchronously rewrite the append-only file\0" as *const u8
54766                    as *const libc::c_char,
54767                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
54768                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
54769                doc_flags: 0 as libc::c_int,
54770                replaced_by: 0 as *const libc::c_char,
54771                deprecated_since: 0 as *const libc::c_char,
54772                group: COMMAND_GROUP_SERVER,
54773                history: 0 as *const commandHistory as *mut commandHistory,
54774                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54775                proc_0: Some(
54776                    bgrewriteaofCommand as unsafe extern "C" fn(*mut client) -> (),
54777                ),
54778                arity: 1 as libc::c_int,
54779                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
54780                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
54781                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
54782                acl_categories: 0 as libc::c_int as uint64_t,
54783                key_specs_static: [keySpec {
54784                    notes: 0 as *const libc::c_char,
54785                    flags: 0,
54786                    begin_search_type: KSPEC_BS_INVALID,
54787                    bs: C2RustUnnamed_3 {
54788                        index: C2RustUnnamed_5 { pos: 0 },
54789                    },
54790                    find_keys_type: KSPEC_FK_INVALID,
54791                    fk: C2RustUnnamed_0 {
54792                        range: C2RustUnnamed_2 {
54793                            lastkey: 0,
54794                            keystep: 0,
54795                            limit: 0,
54796                        },
54797                    },
54798                }; 4],
54799                getkeys_proc: None,
54800                subcommands: 0 as *const redisCommand as *mut redisCommand,
54801                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54802                microseconds: 0,
54803                calls: 0,
54804                rejected_calls: 0,
54805                failed_calls: 0,
54806                id: 0,
54807                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54808                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54809                key_specs: 0 as *const keySpec as *mut keySpec,
54810                legacy_range_key_spec: keySpec {
54811                    notes: 0 as *const libc::c_char,
54812                    flags: 0,
54813                    begin_search_type: KSPEC_BS_INVALID,
54814                    bs: C2RustUnnamed_3 {
54815                        index: C2RustUnnamed_5 { pos: 0 },
54816                    },
54817                    find_keys_type: KSPEC_FK_INVALID,
54818                    fk: C2RustUnnamed_0 {
54819                        range: C2RustUnnamed_2 {
54820                            lastkey: 0,
54821                            keystep: 0,
54822                            limit: 0,
54823                        },
54824                    },
54825                },
54826                num_args: 0,
54827                num_history: 0,
54828                num_tips: 0,
54829                key_specs_num: 0,
54830                key_specs_max: 0,
54831                subcommands_dict: 0 as *const dict as *mut dict,
54832                parent: 0 as *const redisCommand as *mut redisCommand,
54833                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54834            };
54835            init
54836        },
54837        {
54838            let mut init = redisCommand {
54839                declared_name: b"bgsave\0" as *const u8 as *const libc::c_char,
54840                summary: b"Asynchronously save the dataset to disk\0" as *const u8
54841                    as *const libc::c_char,
54842                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
54843                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
54844                doc_flags: 0 as libc::c_int,
54845                replaced_by: 0 as *const libc::c_char,
54846                deprecated_since: 0 as *const libc::c_char,
54847                group: COMMAND_GROUP_SERVER,
54848                history: BGSAVE_History.as_ptr() as *mut _,
54849                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54850                proc_0: Some(bgsaveCommand as unsafe extern "C" fn(*mut client) -> ()),
54851                arity: -(1 as libc::c_int),
54852                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
54853                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
54854                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
54855                acl_categories: 0 as libc::c_int as uint64_t,
54856                key_specs_static: [keySpec {
54857                    notes: 0 as *const libc::c_char,
54858                    flags: 0,
54859                    begin_search_type: KSPEC_BS_INVALID,
54860                    bs: C2RustUnnamed_3 {
54861                        index: C2RustUnnamed_5 { pos: 0 },
54862                    },
54863                    find_keys_type: KSPEC_FK_INVALID,
54864                    fk: C2RustUnnamed_0 {
54865                        range: C2RustUnnamed_2 {
54866                            lastkey: 0,
54867                            keystep: 0,
54868                            limit: 0,
54869                        },
54870                    },
54871                }; 4],
54872                getkeys_proc: None,
54873                subcommands: 0 as *const redisCommand as *mut redisCommand,
54874                args: BGSAVE_Args.as_ptr() as *mut _,
54875                microseconds: 0,
54876                calls: 0,
54877                rejected_calls: 0,
54878                failed_calls: 0,
54879                id: 0,
54880                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54881                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54882                key_specs: 0 as *const keySpec as *mut keySpec,
54883                legacy_range_key_spec: keySpec {
54884                    notes: 0 as *const libc::c_char,
54885                    flags: 0,
54886                    begin_search_type: KSPEC_BS_INVALID,
54887                    bs: C2RustUnnamed_3 {
54888                        index: C2RustUnnamed_5 { pos: 0 },
54889                    },
54890                    find_keys_type: KSPEC_FK_INVALID,
54891                    fk: C2RustUnnamed_0 {
54892                        range: C2RustUnnamed_2 {
54893                            lastkey: 0,
54894                            keystep: 0,
54895                            limit: 0,
54896                        },
54897                    },
54898                },
54899                num_args: 0,
54900                num_history: 0,
54901                num_tips: 0,
54902                key_specs_num: 0,
54903                key_specs_max: 0,
54904                subcommands_dict: 0 as *const dict as *mut dict,
54905                parent: 0 as *const redisCommand as *mut redisCommand,
54906                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54907            };
54908            init
54909        },
54910        {
54911            let mut init = redisCommand {
54912                declared_name: b"command\0" as *const u8 as *const libc::c_char,
54913                summary: b"Get array of Redis command details\0" as *const u8
54914                    as *const libc::c_char,
54915                complexity: b"O(N) where N is the total number of Redis commands\0"
54916                    as *const u8 as *const libc::c_char,
54917                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
54918                doc_flags: 0 as libc::c_int,
54919                replaced_by: 0 as *const libc::c_char,
54920                deprecated_since: 0 as *const libc::c_char,
54921                group: COMMAND_GROUP_SERVER,
54922                history: 0 as *const commandHistory as *mut commandHistory,
54923                tips: COMMAND_tips.as_ptr() as *mut _,
54924                proc_0: Some(commandCommand as unsafe extern "C" fn(*mut client) -> ()),
54925                arity: -(1 as libc::c_int),
54926                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
54927                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
54928                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
54929                acl_categories: ((1 as libc::c_ulonglong) << 18 as libc::c_int)
54930                    as uint64_t,
54931                key_specs_static: [keySpec {
54932                    notes: 0 as *const libc::c_char,
54933                    flags: 0,
54934                    begin_search_type: KSPEC_BS_INVALID,
54935                    bs: C2RustUnnamed_3 {
54936                        index: C2RustUnnamed_5 { pos: 0 },
54937                    },
54938                    find_keys_type: KSPEC_FK_INVALID,
54939                    fk: C2RustUnnamed_0 {
54940                        range: C2RustUnnamed_2 {
54941                            lastkey: 0,
54942                            keystep: 0,
54943                            limit: 0,
54944                        },
54945                    },
54946                }; 4],
54947                getkeys_proc: None,
54948                subcommands: COMMAND_Subcommands.as_ptr() as *mut _,
54949                args: 0 as *const redisCommandArg as *mut redisCommandArg,
54950                microseconds: 0,
54951                calls: 0,
54952                rejected_calls: 0,
54953                failed_calls: 0,
54954                id: 0,
54955                fullname: 0 as *const libc::c_char as *mut libc::c_char,
54956                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
54957                key_specs: 0 as *const keySpec as *mut keySpec,
54958                legacy_range_key_spec: keySpec {
54959                    notes: 0 as *const libc::c_char,
54960                    flags: 0,
54961                    begin_search_type: KSPEC_BS_INVALID,
54962                    bs: C2RustUnnamed_3 {
54963                        index: C2RustUnnamed_5 { pos: 0 },
54964                    },
54965                    find_keys_type: KSPEC_FK_INVALID,
54966                    fk: C2RustUnnamed_0 {
54967                        range: C2RustUnnamed_2 {
54968                            lastkey: 0,
54969                            keystep: 0,
54970                            limit: 0,
54971                        },
54972                    },
54973                },
54974                num_args: 0,
54975                num_history: 0,
54976                num_tips: 0,
54977                key_specs_num: 0,
54978                key_specs_max: 0,
54979                subcommands_dict: 0 as *const dict as *mut dict,
54980                parent: 0 as *const redisCommand as *mut redisCommand,
54981                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
54982            };
54983            init
54984        },
54985        {
54986            let mut init = redisCommand {
54987                declared_name: b"config\0" as *const u8 as *const libc::c_char,
54988                summary: b"A container for server configuration commands\0" as *const u8
54989                    as *const libc::c_char,
54990                complexity: b"Depends on subcommand.\0" as *const u8
54991                    as *const libc::c_char,
54992                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
54993                doc_flags: 0 as libc::c_int,
54994                replaced_by: 0 as *const libc::c_char,
54995                deprecated_since: 0 as *const libc::c_char,
54996                group: COMMAND_GROUP_SERVER,
54997                history: 0 as *const commandHistory as *mut commandHistory,
54998                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
54999                proc_0: None,
55000                arity: -(2 as libc::c_int),
55001                flags: 0 as libc::c_int as uint64_t,
55002                acl_categories: 0 as libc::c_int as uint64_t,
55003                key_specs_static: [keySpec {
55004                    notes: 0 as *const libc::c_char,
55005                    flags: 0,
55006                    begin_search_type: KSPEC_BS_INVALID,
55007                    bs: C2RustUnnamed_3 {
55008                        index: C2RustUnnamed_5 { pos: 0 },
55009                    },
55010                    find_keys_type: KSPEC_FK_INVALID,
55011                    fk: C2RustUnnamed_0 {
55012                        range: C2RustUnnamed_2 {
55013                            lastkey: 0,
55014                            keystep: 0,
55015                            limit: 0,
55016                        },
55017                    },
55018                }; 4],
55019                getkeys_proc: None,
55020                subcommands: CONFIG_Subcommands.as_ptr() as *mut _,
55021                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55022                microseconds: 0,
55023                calls: 0,
55024                rejected_calls: 0,
55025                failed_calls: 0,
55026                id: 0,
55027                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55028                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55029                key_specs: 0 as *const keySpec as *mut keySpec,
55030                legacy_range_key_spec: keySpec {
55031                    notes: 0 as *const libc::c_char,
55032                    flags: 0,
55033                    begin_search_type: KSPEC_BS_INVALID,
55034                    bs: C2RustUnnamed_3 {
55035                        index: C2RustUnnamed_5 { pos: 0 },
55036                    },
55037                    find_keys_type: KSPEC_FK_INVALID,
55038                    fk: C2RustUnnamed_0 {
55039                        range: C2RustUnnamed_2 {
55040                            lastkey: 0,
55041                            keystep: 0,
55042                            limit: 0,
55043                        },
55044                    },
55045                },
55046                num_args: 0,
55047                num_history: 0,
55048                num_tips: 0,
55049                key_specs_num: 0,
55050                key_specs_max: 0,
55051                subcommands_dict: 0 as *const dict as *mut dict,
55052                parent: 0 as *const redisCommand as *mut redisCommand,
55053                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55054            };
55055            init
55056        },
55057        {
55058            let mut init = redisCommand {
55059                declared_name: b"dbsize\0" as *const u8 as *const libc::c_char,
55060                summary: b"Return the number of keys in the selected database\0"
55061                    as *const u8 as *const libc::c_char,
55062                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
55063                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55064                doc_flags: 0 as libc::c_int,
55065                replaced_by: 0 as *const libc::c_char,
55066                deprecated_since: 0 as *const libc::c_char,
55067                group: COMMAND_GROUP_SERVER,
55068                history: 0 as *const commandHistory as *mut commandHistory,
55069                tips: DBSIZE_tips.as_ptr() as *mut _,
55070                proc_0: Some(dbsizeCommand as unsafe extern "C" fn(*mut client) -> ()),
55071                arity: 1 as libc::c_int,
55072                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
55073                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
55074                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
55075                    as uint64_t,
55076                key_specs_static: [keySpec {
55077                    notes: 0 as *const libc::c_char,
55078                    flags: 0,
55079                    begin_search_type: KSPEC_BS_INVALID,
55080                    bs: C2RustUnnamed_3 {
55081                        index: C2RustUnnamed_5 { pos: 0 },
55082                    },
55083                    find_keys_type: KSPEC_FK_INVALID,
55084                    fk: C2RustUnnamed_0 {
55085                        range: C2RustUnnamed_2 {
55086                            lastkey: 0,
55087                            keystep: 0,
55088                            limit: 0,
55089                        },
55090                    },
55091                }; 4],
55092                getkeys_proc: None,
55093                subcommands: 0 as *const redisCommand as *mut redisCommand,
55094                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55095                microseconds: 0,
55096                calls: 0,
55097                rejected_calls: 0,
55098                failed_calls: 0,
55099                id: 0,
55100                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55101                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55102                key_specs: 0 as *const keySpec as *mut keySpec,
55103                legacy_range_key_spec: keySpec {
55104                    notes: 0 as *const libc::c_char,
55105                    flags: 0,
55106                    begin_search_type: KSPEC_BS_INVALID,
55107                    bs: C2RustUnnamed_3 {
55108                        index: C2RustUnnamed_5 { pos: 0 },
55109                    },
55110                    find_keys_type: KSPEC_FK_INVALID,
55111                    fk: C2RustUnnamed_0 {
55112                        range: C2RustUnnamed_2 {
55113                            lastkey: 0,
55114                            keystep: 0,
55115                            limit: 0,
55116                        },
55117                    },
55118                },
55119                num_args: 0,
55120                num_history: 0,
55121                num_tips: 0,
55122                key_specs_num: 0,
55123                key_specs_max: 0,
55124                subcommands_dict: 0 as *const dict as *mut dict,
55125                parent: 0 as *const redisCommand as *mut redisCommand,
55126                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55127            };
55128            init
55129        },
55130        {
55131            let mut init = redisCommand {
55132                declared_name: b"debug\0" as *const u8 as *const libc::c_char,
55133                summary: b"A container for debugging commands\0" as *const u8
55134                    as *const libc::c_char,
55135                complexity: b"Depends on subcommand.\0" as *const u8
55136                    as *const libc::c_char,
55137                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55138                doc_flags: (1 as libc::c_int) << 1 as libc::c_int,
55139                replaced_by: 0 as *const libc::c_char,
55140                deprecated_since: 0 as *const libc::c_char,
55141                group: COMMAND_GROUP_SERVER,
55142                history: 0 as *const commandHistory as *mut commandHistory,
55143                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55144                proc_0: Some(debugCommand as unsafe extern "C" fn(*mut client) -> ()),
55145                arity: -(2 as libc::c_int),
55146                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
55147                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
55148                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
55149                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
55150                    | (1 as libc::c_ulonglong) << 20 as libc::c_int) as uint64_t,
55151                acl_categories: 0 as libc::c_int as uint64_t,
55152                key_specs_static: [keySpec {
55153                    notes: 0 as *const libc::c_char,
55154                    flags: 0,
55155                    begin_search_type: KSPEC_BS_INVALID,
55156                    bs: C2RustUnnamed_3 {
55157                        index: C2RustUnnamed_5 { pos: 0 },
55158                    },
55159                    find_keys_type: KSPEC_FK_INVALID,
55160                    fk: C2RustUnnamed_0 {
55161                        range: C2RustUnnamed_2 {
55162                            lastkey: 0,
55163                            keystep: 0,
55164                            limit: 0,
55165                        },
55166                    },
55167                }; 4],
55168                getkeys_proc: None,
55169                subcommands: 0 as *const redisCommand as *mut redisCommand,
55170                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55171                microseconds: 0,
55172                calls: 0,
55173                rejected_calls: 0,
55174                failed_calls: 0,
55175                id: 0,
55176                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55177                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55178                key_specs: 0 as *const keySpec as *mut keySpec,
55179                legacy_range_key_spec: keySpec {
55180                    notes: 0 as *const libc::c_char,
55181                    flags: 0,
55182                    begin_search_type: KSPEC_BS_INVALID,
55183                    bs: C2RustUnnamed_3 {
55184                        index: C2RustUnnamed_5 { pos: 0 },
55185                    },
55186                    find_keys_type: KSPEC_FK_INVALID,
55187                    fk: C2RustUnnamed_0 {
55188                        range: C2RustUnnamed_2 {
55189                            lastkey: 0,
55190                            keystep: 0,
55191                            limit: 0,
55192                        },
55193                    },
55194                },
55195                num_args: 0,
55196                num_history: 0,
55197                num_tips: 0,
55198                key_specs_num: 0,
55199                key_specs_max: 0,
55200                subcommands_dict: 0 as *const dict as *mut dict,
55201                parent: 0 as *const redisCommand as *mut redisCommand,
55202                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55203            };
55204            init
55205        },
55206        {
55207            let mut init = redisCommand {
55208                declared_name: b"failover\0" as *const u8 as *const libc::c_char,
55209                summary: b"Start a coordinated failover between this server and one of its replicas.\0"
55210                    as *const u8 as *const libc::c_char,
55211                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
55212                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
55213                doc_flags: 0 as libc::c_int,
55214                replaced_by: 0 as *const libc::c_char,
55215                deprecated_since: 0 as *const libc::c_char,
55216                group: COMMAND_GROUP_SERVER,
55217                history: 0 as *const commandHistory as *mut commandHistory,
55218                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55219                proc_0: Some(failoverCommand as unsafe extern "C" fn(*mut client) -> ()),
55220                arity: -(1 as libc::c_int),
55221                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
55222                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
55223                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
55224                acl_categories: 0 as libc::c_int as uint64_t,
55225                key_specs_static: [keySpec {
55226                    notes: 0 as *const libc::c_char,
55227                    flags: 0,
55228                    begin_search_type: KSPEC_BS_INVALID,
55229                    bs: C2RustUnnamed_3 {
55230                        index: C2RustUnnamed_5 { pos: 0 },
55231                    },
55232                    find_keys_type: KSPEC_FK_INVALID,
55233                    fk: C2RustUnnamed_0 {
55234                        range: C2RustUnnamed_2 {
55235                            lastkey: 0,
55236                            keystep: 0,
55237                            limit: 0,
55238                        },
55239                    },
55240                }; 4],
55241                getkeys_proc: None,
55242                subcommands: 0 as *const redisCommand as *mut redisCommand,
55243                args: FAILOVER_Args.as_ptr() as *mut _,
55244                microseconds: 0,
55245                calls: 0,
55246                rejected_calls: 0,
55247                failed_calls: 0,
55248                id: 0,
55249                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55250                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55251                key_specs: 0 as *const keySpec as *mut keySpec,
55252                legacy_range_key_spec: keySpec {
55253                    notes: 0 as *const libc::c_char,
55254                    flags: 0,
55255                    begin_search_type: KSPEC_BS_INVALID,
55256                    bs: C2RustUnnamed_3 {
55257                        index: C2RustUnnamed_5 { pos: 0 },
55258                    },
55259                    find_keys_type: KSPEC_FK_INVALID,
55260                    fk: C2RustUnnamed_0 {
55261                        range: C2RustUnnamed_2 {
55262                            lastkey: 0,
55263                            keystep: 0,
55264                            limit: 0,
55265                        },
55266                    },
55267                },
55268                num_args: 0,
55269                num_history: 0,
55270                num_tips: 0,
55271                key_specs_num: 0,
55272                key_specs_max: 0,
55273                subcommands_dict: 0 as *const dict as *mut dict,
55274                parent: 0 as *const redisCommand as *mut redisCommand,
55275                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55276            };
55277            init
55278        },
55279        {
55280            let mut init = redisCommand {
55281                declared_name: b"flushall\0" as *const u8 as *const libc::c_char,
55282                summary: b"Remove all keys from all databases\0" as *const u8
55283                    as *const libc::c_char,
55284                complexity: b"O(N) where N is the total number of keys in all databases\0"
55285                    as *const u8 as *const libc::c_char,
55286                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55287                doc_flags: 0 as libc::c_int,
55288                replaced_by: 0 as *const libc::c_char,
55289                deprecated_since: 0 as *const libc::c_char,
55290                group: COMMAND_GROUP_SERVER,
55291                history: FLUSHALL_History.as_ptr() as *mut _,
55292                tips: FLUSHALL_tips.as_ptr() as *mut _,
55293                proc_0: Some(flushallCommand as unsafe extern "C" fn(*mut client) -> ()),
55294                arity: -(1 as libc::c_int),
55295                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
55296                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
55297                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
55298                key_specs_static: [keySpec {
55299                    notes: 0 as *const libc::c_char,
55300                    flags: 0,
55301                    begin_search_type: KSPEC_BS_INVALID,
55302                    bs: C2RustUnnamed_3 {
55303                        index: C2RustUnnamed_5 { pos: 0 },
55304                    },
55305                    find_keys_type: KSPEC_FK_INVALID,
55306                    fk: C2RustUnnamed_0 {
55307                        range: C2RustUnnamed_2 {
55308                            lastkey: 0,
55309                            keystep: 0,
55310                            limit: 0,
55311                        },
55312                    },
55313                }; 4],
55314                getkeys_proc: None,
55315                subcommands: 0 as *const redisCommand as *mut redisCommand,
55316                args: FLUSHALL_Args.as_ptr() as *mut _,
55317                microseconds: 0,
55318                calls: 0,
55319                rejected_calls: 0,
55320                failed_calls: 0,
55321                id: 0,
55322                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55323                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55324                key_specs: 0 as *const keySpec as *mut keySpec,
55325                legacy_range_key_spec: keySpec {
55326                    notes: 0 as *const libc::c_char,
55327                    flags: 0,
55328                    begin_search_type: KSPEC_BS_INVALID,
55329                    bs: C2RustUnnamed_3 {
55330                        index: C2RustUnnamed_5 { pos: 0 },
55331                    },
55332                    find_keys_type: KSPEC_FK_INVALID,
55333                    fk: C2RustUnnamed_0 {
55334                        range: C2RustUnnamed_2 {
55335                            lastkey: 0,
55336                            keystep: 0,
55337                            limit: 0,
55338                        },
55339                    },
55340                },
55341                num_args: 0,
55342                num_history: 0,
55343                num_tips: 0,
55344                key_specs_num: 0,
55345                key_specs_max: 0,
55346                subcommands_dict: 0 as *const dict as *mut dict,
55347                parent: 0 as *const redisCommand as *mut redisCommand,
55348                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55349            };
55350            init
55351        },
55352        {
55353            let mut init = redisCommand {
55354                declared_name: b"flushdb\0" as *const u8 as *const libc::c_char,
55355                summary: b"Remove all keys from the current database\0" as *const u8
55356                    as *const libc::c_char,
55357                complexity: b"O(N) where N is the number of keys in the selected database\0"
55358                    as *const u8 as *const libc::c_char,
55359                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55360                doc_flags: 0 as libc::c_int,
55361                replaced_by: 0 as *const libc::c_char,
55362                deprecated_since: 0 as *const libc::c_char,
55363                group: COMMAND_GROUP_SERVER,
55364                history: FLUSHDB_History.as_ptr() as *mut _,
55365                tips: FLUSHDB_tips.as_ptr() as *mut _,
55366                proc_0: Some(flushdbCommand as unsafe extern "C" fn(*mut client) -> ()),
55367                arity: -(1 as libc::c_int),
55368                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
55369                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
55370                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
55371                key_specs_static: [keySpec {
55372                    notes: 0 as *const libc::c_char,
55373                    flags: 0,
55374                    begin_search_type: KSPEC_BS_INVALID,
55375                    bs: C2RustUnnamed_3 {
55376                        index: C2RustUnnamed_5 { pos: 0 },
55377                    },
55378                    find_keys_type: KSPEC_FK_INVALID,
55379                    fk: C2RustUnnamed_0 {
55380                        range: C2RustUnnamed_2 {
55381                            lastkey: 0,
55382                            keystep: 0,
55383                            limit: 0,
55384                        },
55385                    },
55386                }; 4],
55387                getkeys_proc: None,
55388                subcommands: 0 as *const redisCommand as *mut redisCommand,
55389                args: FLUSHDB_Args.as_ptr() as *mut _,
55390                microseconds: 0,
55391                calls: 0,
55392                rejected_calls: 0,
55393                failed_calls: 0,
55394                id: 0,
55395                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55396                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55397                key_specs: 0 as *const keySpec as *mut keySpec,
55398                legacy_range_key_spec: keySpec {
55399                    notes: 0 as *const libc::c_char,
55400                    flags: 0,
55401                    begin_search_type: KSPEC_BS_INVALID,
55402                    bs: C2RustUnnamed_3 {
55403                        index: C2RustUnnamed_5 { pos: 0 },
55404                    },
55405                    find_keys_type: KSPEC_FK_INVALID,
55406                    fk: C2RustUnnamed_0 {
55407                        range: C2RustUnnamed_2 {
55408                            lastkey: 0,
55409                            keystep: 0,
55410                            limit: 0,
55411                        },
55412                    },
55413                },
55414                num_args: 0,
55415                num_history: 0,
55416                num_tips: 0,
55417                key_specs_num: 0,
55418                key_specs_max: 0,
55419                subcommands_dict: 0 as *const dict as *mut dict,
55420                parent: 0 as *const redisCommand as *mut redisCommand,
55421                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55422            };
55423            init
55424        },
55425        {
55426            let mut init = redisCommand {
55427                declared_name: b"info\0" as *const u8 as *const libc::c_char,
55428                summary: b"Get information and statistics about the server\0"
55429                    as *const u8 as *const libc::c_char,
55430                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
55431                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55432                doc_flags: 0 as libc::c_int,
55433                replaced_by: 0 as *const libc::c_char,
55434                deprecated_since: 0 as *const libc::c_char,
55435                group: COMMAND_GROUP_SERVER,
55436                history: INFO_History.as_ptr() as *mut _,
55437                tips: INFO_tips.as_ptr() as *mut _,
55438                proc_0: Some(infoCommand as unsafe extern "C" fn(*mut client) -> ()),
55439                arity: -(1 as libc::c_int),
55440                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
55441                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
55442                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
55443                acl_categories: ((1 as libc::c_ulonglong) << 17 as libc::c_int)
55444                    as uint64_t,
55445                key_specs_static: [keySpec {
55446                    notes: 0 as *const libc::c_char,
55447                    flags: 0,
55448                    begin_search_type: KSPEC_BS_INVALID,
55449                    bs: C2RustUnnamed_3 {
55450                        index: C2RustUnnamed_5 { pos: 0 },
55451                    },
55452                    find_keys_type: KSPEC_FK_INVALID,
55453                    fk: C2RustUnnamed_0 {
55454                        range: C2RustUnnamed_2 {
55455                            lastkey: 0,
55456                            keystep: 0,
55457                            limit: 0,
55458                        },
55459                    },
55460                }; 4],
55461                getkeys_proc: None,
55462                subcommands: 0 as *const redisCommand as *mut redisCommand,
55463                args: INFO_Args.as_ptr() as *mut _,
55464                microseconds: 0,
55465                calls: 0,
55466                rejected_calls: 0,
55467                failed_calls: 0,
55468                id: 0,
55469                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55470                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55471                key_specs: 0 as *const keySpec as *mut keySpec,
55472                legacy_range_key_spec: keySpec {
55473                    notes: 0 as *const libc::c_char,
55474                    flags: 0,
55475                    begin_search_type: KSPEC_BS_INVALID,
55476                    bs: C2RustUnnamed_3 {
55477                        index: C2RustUnnamed_5 { pos: 0 },
55478                    },
55479                    find_keys_type: KSPEC_FK_INVALID,
55480                    fk: C2RustUnnamed_0 {
55481                        range: C2RustUnnamed_2 {
55482                            lastkey: 0,
55483                            keystep: 0,
55484                            limit: 0,
55485                        },
55486                    },
55487                },
55488                num_args: 0,
55489                num_history: 0,
55490                num_tips: 0,
55491                key_specs_num: 0,
55492                key_specs_max: 0,
55493                subcommands_dict: 0 as *const dict as *mut dict,
55494                parent: 0 as *const redisCommand as *mut redisCommand,
55495                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55496            };
55497            init
55498        },
55499        {
55500            let mut init = redisCommand {
55501                declared_name: b"lastsave\0" as *const u8 as *const libc::c_char,
55502                summary: b"Get the UNIX time stamp of the last successful save to disk\0"
55503                    as *const u8 as *const libc::c_char,
55504                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
55505                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55506                doc_flags: 0 as libc::c_int,
55507                replaced_by: 0 as *const libc::c_char,
55508                deprecated_since: 0 as *const libc::c_char,
55509                group: COMMAND_GROUP_SERVER,
55510                history: 0 as *const commandHistory as *mut commandHistory,
55511                tips: LASTSAVE_tips.as_ptr() as *mut _,
55512                proc_0: Some(lastsaveCommand as unsafe extern "C" fn(*mut client) -> ()),
55513                arity: 1 as libc::c_int,
55514                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
55515                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
55516                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
55517                acl_categories: ((1 as libc::c_ulonglong) << 13 as libc::c_int
55518                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
55519                key_specs_static: [keySpec {
55520                    notes: 0 as *const libc::c_char,
55521                    flags: 0,
55522                    begin_search_type: KSPEC_BS_INVALID,
55523                    bs: C2RustUnnamed_3 {
55524                        index: C2RustUnnamed_5 { pos: 0 },
55525                    },
55526                    find_keys_type: KSPEC_FK_INVALID,
55527                    fk: C2RustUnnamed_0 {
55528                        range: C2RustUnnamed_2 {
55529                            lastkey: 0,
55530                            keystep: 0,
55531                            limit: 0,
55532                        },
55533                    },
55534                }; 4],
55535                getkeys_proc: None,
55536                subcommands: 0 as *const redisCommand as *mut redisCommand,
55537                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55538                microseconds: 0,
55539                calls: 0,
55540                rejected_calls: 0,
55541                failed_calls: 0,
55542                id: 0,
55543                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55544                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55545                key_specs: 0 as *const keySpec as *mut keySpec,
55546                legacy_range_key_spec: keySpec {
55547                    notes: 0 as *const libc::c_char,
55548                    flags: 0,
55549                    begin_search_type: KSPEC_BS_INVALID,
55550                    bs: C2RustUnnamed_3 {
55551                        index: C2RustUnnamed_5 { pos: 0 },
55552                    },
55553                    find_keys_type: KSPEC_FK_INVALID,
55554                    fk: C2RustUnnamed_0 {
55555                        range: C2RustUnnamed_2 {
55556                            lastkey: 0,
55557                            keystep: 0,
55558                            limit: 0,
55559                        },
55560                    },
55561                },
55562                num_args: 0,
55563                num_history: 0,
55564                num_tips: 0,
55565                key_specs_num: 0,
55566                key_specs_max: 0,
55567                subcommands_dict: 0 as *const dict as *mut dict,
55568                parent: 0 as *const redisCommand as *mut redisCommand,
55569                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55570            };
55571            init
55572        },
55573        {
55574            let mut init = redisCommand {
55575                declared_name: b"latency\0" as *const u8 as *const libc::c_char,
55576                summary: b"A container for latency diagnostics commands\0" as *const u8
55577                    as *const libc::c_char,
55578                complexity: b"Depends on subcommand.\0" as *const u8
55579                    as *const libc::c_char,
55580                since: b"2.8.13\0" as *const u8 as *const libc::c_char,
55581                doc_flags: 0 as libc::c_int,
55582                replaced_by: 0 as *const libc::c_char,
55583                deprecated_since: 0 as *const libc::c_char,
55584                group: COMMAND_GROUP_SERVER,
55585                history: 0 as *const commandHistory as *mut commandHistory,
55586                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55587                proc_0: None,
55588                arity: -(2 as libc::c_int),
55589                flags: 0 as libc::c_int as uint64_t,
55590                acl_categories: 0 as libc::c_int as uint64_t,
55591                key_specs_static: [keySpec {
55592                    notes: 0 as *const libc::c_char,
55593                    flags: 0,
55594                    begin_search_type: KSPEC_BS_INVALID,
55595                    bs: C2RustUnnamed_3 {
55596                        index: C2RustUnnamed_5 { pos: 0 },
55597                    },
55598                    find_keys_type: KSPEC_FK_INVALID,
55599                    fk: C2RustUnnamed_0 {
55600                        range: C2RustUnnamed_2 {
55601                            lastkey: 0,
55602                            keystep: 0,
55603                            limit: 0,
55604                        },
55605                    },
55606                }; 4],
55607                getkeys_proc: None,
55608                subcommands: LATENCY_Subcommands.as_ptr() as *mut _,
55609                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55610                microseconds: 0,
55611                calls: 0,
55612                rejected_calls: 0,
55613                failed_calls: 0,
55614                id: 0,
55615                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55616                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55617                key_specs: 0 as *const keySpec as *mut keySpec,
55618                legacy_range_key_spec: keySpec {
55619                    notes: 0 as *const libc::c_char,
55620                    flags: 0,
55621                    begin_search_type: KSPEC_BS_INVALID,
55622                    bs: C2RustUnnamed_3 {
55623                        index: C2RustUnnamed_5 { pos: 0 },
55624                    },
55625                    find_keys_type: KSPEC_FK_INVALID,
55626                    fk: C2RustUnnamed_0 {
55627                        range: C2RustUnnamed_2 {
55628                            lastkey: 0,
55629                            keystep: 0,
55630                            limit: 0,
55631                        },
55632                    },
55633                },
55634                num_args: 0,
55635                num_history: 0,
55636                num_tips: 0,
55637                key_specs_num: 0,
55638                key_specs_max: 0,
55639                subcommands_dict: 0 as *const dict as *mut dict,
55640                parent: 0 as *const redisCommand as *mut redisCommand,
55641                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55642            };
55643            init
55644        },
55645        {
55646            let mut init = redisCommand {
55647                declared_name: b"lolwut\0" as *const u8 as *const libc::c_char,
55648                summary: b"Display some computer art and the Redis version\0"
55649                    as *const u8 as *const libc::c_char,
55650                complexity: 0 as *const libc::c_char,
55651                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
55652                doc_flags: 0 as libc::c_int,
55653                replaced_by: 0 as *const libc::c_char,
55654                deprecated_since: 0 as *const libc::c_char,
55655                group: COMMAND_GROUP_SERVER,
55656                history: 0 as *const commandHistory as *mut commandHistory,
55657                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55658                proc_0: Some(lolwutCommand as unsafe extern "C" fn(*mut client) -> ()),
55659                arity: -(1 as libc::c_int),
55660                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
55661                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
55662                acl_categories: 0 as libc::c_int as uint64_t,
55663                key_specs_static: [keySpec {
55664                    notes: 0 as *const libc::c_char,
55665                    flags: 0,
55666                    begin_search_type: KSPEC_BS_INVALID,
55667                    bs: C2RustUnnamed_3 {
55668                        index: C2RustUnnamed_5 { pos: 0 },
55669                    },
55670                    find_keys_type: KSPEC_FK_INVALID,
55671                    fk: C2RustUnnamed_0 {
55672                        range: C2RustUnnamed_2 {
55673                            lastkey: 0,
55674                            keystep: 0,
55675                            limit: 0,
55676                        },
55677                    },
55678                }; 4],
55679                getkeys_proc: None,
55680                subcommands: 0 as *const redisCommand as *mut redisCommand,
55681                args: LOLWUT_Args.as_ptr() as *mut _,
55682                microseconds: 0,
55683                calls: 0,
55684                rejected_calls: 0,
55685                failed_calls: 0,
55686                id: 0,
55687                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55688                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55689                key_specs: 0 as *const keySpec as *mut keySpec,
55690                legacy_range_key_spec: keySpec {
55691                    notes: 0 as *const libc::c_char,
55692                    flags: 0,
55693                    begin_search_type: KSPEC_BS_INVALID,
55694                    bs: C2RustUnnamed_3 {
55695                        index: C2RustUnnamed_5 { pos: 0 },
55696                    },
55697                    find_keys_type: KSPEC_FK_INVALID,
55698                    fk: C2RustUnnamed_0 {
55699                        range: C2RustUnnamed_2 {
55700                            lastkey: 0,
55701                            keystep: 0,
55702                            limit: 0,
55703                        },
55704                    },
55705                },
55706                num_args: 0,
55707                num_history: 0,
55708                num_tips: 0,
55709                key_specs_num: 0,
55710                key_specs_max: 0,
55711                subcommands_dict: 0 as *const dict as *mut dict,
55712                parent: 0 as *const redisCommand as *mut redisCommand,
55713                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55714            };
55715            init
55716        },
55717        {
55718            let mut init = redisCommand {
55719                declared_name: b"memory\0" as *const u8 as *const libc::c_char,
55720                summary: b"A container for memory diagnostics commands\0" as *const u8
55721                    as *const libc::c_char,
55722                complexity: b"Depends on subcommand.\0" as *const u8
55723                    as *const libc::c_char,
55724                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
55725                doc_flags: 0 as libc::c_int,
55726                replaced_by: 0 as *const libc::c_char,
55727                deprecated_since: 0 as *const libc::c_char,
55728                group: COMMAND_GROUP_SERVER,
55729                history: 0 as *const commandHistory as *mut commandHistory,
55730                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55731                proc_0: None,
55732                arity: -(2 as libc::c_int),
55733                flags: 0 as libc::c_int as uint64_t,
55734                acl_categories: 0 as libc::c_int as uint64_t,
55735                key_specs_static: [keySpec {
55736                    notes: 0 as *const libc::c_char,
55737                    flags: 0,
55738                    begin_search_type: KSPEC_BS_INVALID,
55739                    bs: C2RustUnnamed_3 {
55740                        index: C2RustUnnamed_5 { pos: 0 },
55741                    },
55742                    find_keys_type: KSPEC_FK_INVALID,
55743                    fk: C2RustUnnamed_0 {
55744                        range: C2RustUnnamed_2 {
55745                            lastkey: 0,
55746                            keystep: 0,
55747                            limit: 0,
55748                        },
55749                    },
55750                }; 4],
55751                getkeys_proc: None,
55752                subcommands: MEMORY_Subcommands.as_ptr() as *mut _,
55753                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55754                microseconds: 0,
55755                calls: 0,
55756                rejected_calls: 0,
55757                failed_calls: 0,
55758                id: 0,
55759                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55760                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55761                key_specs: 0 as *const keySpec as *mut keySpec,
55762                legacy_range_key_spec: keySpec {
55763                    notes: 0 as *const libc::c_char,
55764                    flags: 0,
55765                    begin_search_type: KSPEC_BS_INVALID,
55766                    bs: C2RustUnnamed_3 {
55767                        index: C2RustUnnamed_5 { pos: 0 },
55768                    },
55769                    find_keys_type: KSPEC_FK_INVALID,
55770                    fk: C2RustUnnamed_0 {
55771                        range: C2RustUnnamed_2 {
55772                            lastkey: 0,
55773                            keystep: 0,
55774                            limit: 0,
55775                        },
55776                    },
55777                },
55778                num_args: 0,
55779                num_history: 0,
55780                num_tips: 0,
55781                key_specs_num: 0,
55782                key_specs_max: 0,
55783                subcommands_dict: 0 as *const dict as *mut dict,
55784                parent: 0 as *const redisCommand as *mut redisCommand,
55785                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55786            };
55787            init
55788        },
55789        {
55790            let mut init = redisCommand {
55791                declared_name: b"module\0" as *const u8 as *const libc::c_char,
55792                summary: b"A container for module commands\0" as *const u8
55793                    as *const libc::c_char,
55794                complexity: b"Depends on subcommand.\0" as *const u8
55795                    as *const libc::c_char,
55796                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
55797                doc_flags: 0 as libc::c_int,
55798                replaced_by: 0 as *const libc::c_char,
55799                deprecated_since: 0 as *const libc::c_char,
55800                group: COMMAND_GROUP_SERVER,
55801                history: 0 as *const commandHistory as *mut commandHistory,
55802                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55803                proc_0: None,
55804                arity: -(2 as libc::c_int),
55805                flags: 0 as libc::c_int as uint64_t,
55806                acl_categories: 0 as libc::c_int as uint64_t,
55807                key_specs_static: [keySpec {
55808                    notes: 0 as *const libc::c_char,
55809                    flags: 0,
55810                    begin_search_type: KSPEC_BS_INVALID,
55811                    bs: C2RustUnnamed_3 {
55812                        index: C2RustUnnamed_5 { pos: 0 },
55813                    },
55814                    find_keys_type: KSPEC_FK_INVALID,
55815                    fk: C2RustUnnamed_0 {
55816                        range: C2RustUnnamed_2 {
55817                            lastkey: 0,
55818                            keystep: 0,
55819                            limit: 0,
55820                        },
55821                    },
55822                }; 4],
55823                getkeys_proc: None,
55824                subcommands: MODULE_Subcommands.as_ptr() as *mut _,
55825                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55826                microseconds: 0,
55827                calls: 0,
55828                rejected_calls: 0,
55829                failed_calls: 0,
55830                id: 0,
55831                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55832                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55833                key_specs: 0 as *const keySpec as *mut keySpec,
55834                legacy_range_key_spec: keySpec {
55835                    notes: 0 as *const libc::c_char,
55836                    flags: 0,
55837                    begin_search_type: KSPEC_BS_INVALID,
55838                    bs: C2RustUnnamed_3 {
55839                        index: C2RustUnnamed_5 { pos: 0 },
55840                    },
55841                    find_keys_type: KSPEC_FK_INVALID,
55842                    fk: C2RustUnnamed_0 {
55843                        range: C2RustUnnamed_2 {
55844                            lastkey: 0,
55845                            keystep: 0,
55846                            limit: 0,
55847                        },
55848                    },
55849                },
55850                num_args: 0,
55851                num_history: 0,
55852                num_tips: 0,
55853                key_specs_num: 0,
55854                key_specs_max: 0,
55855                subcommands_dict: 0 as *const dict as *mut dict,
55856                parent: 0 as *const redisCommand as *mut redisCommand,
55857                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55858            };
55859            init
55860        },
55861        {
55862            let mut init = redisCommand {
55863                declared_name: b"monitor\0" as *const u8 as *const libc::c_char,
55864                summary: b"Listen for all requests received by the server in real time\0"
55865                    as *const u8 as *const libc::c_char,
55866                complexity: 0 as *const libc::c_char,
55867                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
55868                doc_flags: 0 as libc::c_int,
55869                replaced_by: 0 as *const libc::c_char,
55870                deprecated_since: 0 as *const libc::c_char,
55871                group: COMMAND_GROUP_SERVER,
55872                history: 0 as *const commandHistory as *mut commandHistory,
55873                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55874                proc_0: Some(monitorCommand as unsafe extern "C" fn(*mut client) -> ()),
55875                arity: 1 as libc::c_int,
55876                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
55877                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
55878                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
55879                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
55880                acl_categories: 0 as libc::c_int as uint64_t,
55881                key_specs_static: [keySpec {
55882                    notes: 0 as *const libc::c_char,
55883                    flags: 0,
55884                    begin_search_type: KSPEC_BS_INVALID,
55885                    bs: C2RustUnnamed_3 {
55886                        index: C2RustUnnamed_5 { pos: 0 },
55887                    },
55888                    find_keys_type: KSPEC_FK_INVALID,
55889                    fk: C2RustUnnamed_0 {
55890                        range: C2RustUnnamed_2 {
55891                            lastkey: 0,
55892                            keystep: 0,
55893                            limit: 0,
55894                        },
55895                    },
55896                }; 4],
55897                getkeys_proc: None,
55898                subcommands: 0 as *const redisCommand as *mut redisCommand,
55899                args: 0 as *const redisCommandArg as *mut redisCommandArg,
55900                microseconds: 0,
55901                calls: 0,
55902                rejected_calls: 0,
55903                failed_calls: 0,
55904                id: 0,
55905                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55906                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55907                key_specs: 0 as *const keySpec as *mut keySpec,
55908                legacy_range_key_spec: keySpec {
55909                    notes: 0 as *const libc::c_char,
55910                    flags: 0,
55911                    begin_search_type: KSPEC_BS_INVALID,
55912                    bs: C2RustUnnamed_3 {
55913                        index: C2RustUnnamed_5 { pos: 0 },
55914                    },
55915                    find_keys_type: KSPEC_FK_INVALID,
55916                    fk: C2RustUnnamed_0 {
55917                        range: C2RustUnnamed_2 {
55918                            lastkey: 0,
55919                            keystep: 0,
55920                            limit: 0,
55921                        },
55922                    },
55923                },
55924                num_args: 0,
55925                num_history: 0,
55926                num_tips: 0,
55927                key_specs_num: 0,
55928                key_specs_max: 0,
55929                subcommands_dict: 0 as *const dict as *mut dict,
55930                parent: 0 as *const redisCommand as *mut redisCommand,
55931                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
55932            };
55933            init
55934        },
55935        {
55936            let mut init = redisCommand {
55937                declared_name: b"psync\0" as *const u8 as *const libc::c_char,
55938                summary: b"Internal command used for replication\0" as *const u8
55939                    as *const libc::c_char,
55940                complexity: 0 as *const libc::c_char,
55941                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
55942                doc_flags: 0 as libc::c_int,
55943                replaced_by: 0 as *const libc::c_char,
55944                deprecated_since: 0 as *const libc::c_char,
55945                group: COMMAND_GROUP_SERVER,
55946                history: 0 as *const commandHistory as *mut commandHistory,
55947                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
55948                proc_0: Some(syncCommand as unsafe extern "C" fn(*mut client) -> ()),
55949                arity: -(3 as libc::c_int),
55950                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
55951                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
55952                    | (1 as libc::c_ulonglong) << 24 as libc::c_int
55953                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
55954                acl_categories: 0 as libc::c_int as uint64_t,
55955                key_specs_static: [keySpec {
55956                    notes: 0 as *const libc::c_char,
55957                    flags: 0,
55958                    begin_search_type: KSPEC_BS_INVALID,
55959                    bs: C2RustUnnamed_3 {
55960                        index: C2RustUnnamed_5 { pos: 0 },
55961                    },
55962                    find_keys_type: KSPEC_FK_INVALID,
55963                    fk: C2RustUnnamed_0 {
55964                        range: C2RustUnnamed_2 {
55965                            lastkey: 0,
55966                            keystep: 0,
55967                            limit: 0,
55968                        },
55969                    },
55970                }; 4],
55971                getkeys_proc: None,
55972                subcommands: 0 as *const redisCommand as *mut redisCommand,
55973                args: PSYNC_Args.as_ptr() as *mut _,
55974                microseconds: 0,
55975                calls: 0,
55976                rejected_calls: 0,
55977                failed_calls: 0,
55978                id: 0,
55979                fullname: 0 as *const libc::c_char as *mut libc::c_char,
55980                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
55981                key_specs: 0 as *const keySpec as *mut keySpec,
55982                legacy_range_key_spec: keySpec {
55983                    notes: 0 as *const libc::c_char,
55984                    flags: 0,
55985                    begin_search_type: KSPEC_BS_INVALID,
55986                    bs: C2RustUnnamed_3 {
55987                        index: C2RustUnnamed_5 { pos: 0 },
55988                    },
55989                    find_keys_type: KSPEC_FK_INVALID,
55990                    fk: C2RustUnnamed_0 {
55991                        range: C2RustUnnamed_2 {
55992                            lastkey: 0,
55993                            keystep: 0,
55994                            limit: 0,
55995                        },
55996                    },
55997                },
55998                num_args: 0,
55999                num_history: 0,
56000                num_tips: 0,
56001                key_specs_num: 0,
56002                key_specs_max: 0,
56003                subcommands_dict: 0 as *const dict as *mut dict,
56004                parent: 0 as *const redisCommand as *mut redisCommand,
56005                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56006            };
56007            init
56008        },
56009        {
56010            let mut init = redisCommand {
56011                declared_name: b"replconf\0" as *const u8 as *const libc::c_char,
56012                summary: b"An internal command for configuring the replication stream\0"
56013                    as *const u8 as *const libc::c_char,
56014                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
56015                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
56016                doc_flags: (1 as libc::c_int) << 1 as libc::c_int,
56017                replaced_by: 0 as *const libc::c_char,
56018                deprecated_since: 0 as *const libc::c_char,
56019                group: COMMAND_GROUP_SERVER,
56020                history: 0 as *const commandHistory as *mut commandHistory,
56021                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56022                proc_0: Some(replconfCommand as unsafe extern "C" fn(*mut client) -> ()),
56023                arity: -(1 as libc::c_int),
56024                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
56025                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
56026                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
56027                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
56028                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
56029                acl_categories: 0 as libc::c_int as uint64_t,
56030                key_specs_static: [keySpec {
56031                    notes: 0 as *const libc::c_char,
56032                    flags: 0,
56033                    begin_search_type: KSPEC_BS_INVALID,
56034                    bs: C2RustUnnamed_3 {
56035                        index: C2RustUnnamed_5 { pos: 0 },
56036                    },
56037                    find_keys_type: KSPEC_FK_INVALID,
56038                    fk: C2RustUnnamed_0 {
56039                        range: C2RustUnnamed_2 {
56040                            lastkey: 0,
56041                            keystep: 0,
56042                            limit: 0,
56043                        },
56044                    },
56045                }; 4],
56046                getkeys_proc: None,
56047                subcommands: 0 as *const redisCommand as *mut redisCommand,
56048                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56049                microseconds: 0,
56050                calls: 0,
56051                rejected_calls: 0,
56052                failed_calls: 0,
56053                id: 0,
56054                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56055                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56056                key_specs: 0 as *const keySpec as *mut keySpec,
56057                legacy_range_key_spec: keySpec {
56058                    notes: 0 as *const libc::c_char,
56059                    flags: 0,
56060                    begin_search_type: KSPEC_BS_INVALID,
56061                    bs: C2RustUnnamed_3 {
56062                        index: C2RustUnnamed_5 { pos: 0 },
56063                    },
56064                    find_keys_type: KSPEC_FK_INVALID,
56065                    fk: C2RustUnnamed_0 {
56066                        range: C2RustUnnamed_2 {
56067                            lastkey: 0,
56068                            keystep: 0,
56069                            limit: 0,
56070                        },
56071                    },
56072                },
56073                num_args: 0,
56074                num_history: 0,
56075                num_tips: 0,
56076                key_specs_num: 0,
56077                key_specs_max: 0,
56078                subcommands_dict: 0 as *const dict as *mut dict,
56079                parent: 0 as *const redisCommand as *mut redisCommand,
56080                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56081            };
56082            init
56083        },
56084        {
56085            let mut init = redisCommand {
56086                declared_name: b"replicaof\0" as *const u8 as *const libc::c_char,
56087                summary: b"Make the server a replica of another instance, or promote it as master.\0"
56088                    as *const u8 as *const libc::c_char,
56089                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
56090                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
56091                doc_flags: 0 as libc::c_int,
56092                replaced_by: 0 as *const libc::c_char,
56093                deprecated_since: 0 as *const libc::c_char,
56094                group: COMMAND_GROUP_SERVER,
56095                history: 0 as *const commandHistory as *mut commandHistory,
56096                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56097                proc_0: Some(
56098                    replicaofCommand as unsafe extern "C" fn(*mut client) -> (),
56099                ),
56100                arity: 3 as libc::c_int,
56101                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
56102                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
56103                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
56104                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
56105                acl_categories: 0 as libc::c_int as uint64_t,
56106                key_specs_static: [keySpec {
56107                    notes: 0 as *const libc::c_char,
56108                    flags: 0,
56109                    begin_search_type: KSPEC_BS_INVALID,
56110                    bs: C2RustUnnamed_3 {
56111                        index: C2RustUnnamed_5 { pos: 0 },
56112                    },
56113                    find_keys_type: KSPEC_FK_INVALID,
56114                    fk: C2RustUnnamed_0 {
56115                        range: C2RustUnnamed_2 {
56116                            lastkey: 0,
56117                            keystep: 0,
56118                            limit: 0,
56119                        },
56120                    },
56121                }; 4],
56122                getkeys_proc: None,
56123                subcommands: 0 as *const redisCommand as *mut redisCommand,
56124                args: REPLICAOF_Args.as_ptr() as *mut _,
56125                microseconds: 0,
56126                calls: 0,
56127                rejected_calls: 0,
56128                failed_calls: 0,
56129                id: 0,
56130                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56131                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56132                key_specs: 0 as *const keySpec as *mut keySpec,
56133                legacy_range_key_spec: keySpec {
56134                    notes: 0 as *const libc::c_char,
56135                    flags: 0,
56136                    begin_search_type: KSPEC_BS_INVALID,
56137                    bs: C2RustUnnamed_3 {
56138                        index: C2RustUnnamed_5 { pos: 0 },
56139                    },
56140                    find_keys_type: KSPEC_FK_INVALID,
56141                    fk: C2RustUnnamed_0 {
56142                        range: C2RustUnnamed_2 {
56143                            lastkey: 0,
56144                            keystep: 0,
56145                            limit: 0,
56146                        },
56147                    },
56148                },
56149                num_args: 0,
56150                num_history: 0,
56151                num_tips: 0,
56152                key_specs_num: 0,
56153                key_specs_max: 0,
56154                subcommands_dict: 0 as *const dict as *mut dict,
56155                parent: 0 as *const redisCommand as *mut redisCommand,
56156                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56157            };
56158            init
56159        },
56160        {
56161            let mut init = redisCommand {
56162                declared_name: b"restore-asking\0" as *const u8 as *const libc::c_char,
56163                summary: b"An internal command for migrating keys in a cluster\0"
56164                    as *const u8 as *const libc::c_char,
56165                complexity: b"O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).\0"
56166                    as *const u8 as *const libc::c_char,
56167                since: b"3.0.0\0" as *const u8 as *const libc::c_char,
56168                doc_flags: (1 as libc::c_int) << 1 as libc::c_int,
56169                replaced_by: 0 as *const libc::c_char,
56170                deprecated_since: 0 as *const libc::c_char,
56171                group: COMMAND_GROUP_SERVER,
56172                history: RESTORE_ASKING_History.as_ptr() as *mut _,
56173                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56174                proc_0: Some(restoreCommand as unsafe extern "C" fn(*mut client) -> ()),
56175                arity: -(4 as libc::c_int),
56176                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
56177                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
56178                    | (1 as libc::c_ulonglong) << 13 as libc::c_int) as uint64_t,
56179                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
56180                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
56181                key_specs_static: [
56182                    {
56183                        let mut init = keySpec {
56184                            notes: 0 as *const libc::c_char,
56185                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
56186                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
56187                            begin_search_type: KSPEC_BS_INDEX,
56188                            bs: C2RustUnnamed_3 {
56189                                index: {
56190                                    let mut init = C2RustUnnamed_5 {
56191                                        pos: 1 as libc::c_int,
56192                                    };
56193                                    init
56194                                },
56195                            },
56196                            find_keys_type: KSPEC_FK_RANGE,
56197                            fk: C2RustUnnamed_0 {
56198                                range: {
56199                                    let mut init = C2RustUnnamed_2 {
56200                                        lastkey: 0 as libc::c_int,
56201                                        keystep: 1 as libc::c_int,
56202                                        limit: 0 as libc::c_int,
56203                                    };
56204                                    init
56205                                },
56206                            },
56207                        };
56208                        init
56209                    },
56210                    keySpec {
56211                        notes: 0 as *const libc::c_char,
56212                        flags: 0,
56213                        begin_search_type: KSPEC_BS_INVALID,
56214                        bs: C2RustUnnamed_3 {
56215                            index: C2RustUnnamed_5 { pos: 0 },
56216                        },
56217                        find_keys_type: KSPEC_FK_INVALID,
56218                        fk: C2RustUnnamed_0 {
56219                            range: C2RustUnnamed_2 {
56220                                lastkey: 0,
56221                                keystep: 0,
56222                                limit: 0,
56223                            },
56224                        },
56225                    },
56226                    keySpec {
56227                        notes: 0 as *const libc::c_char,
56228                        flags: 0,
56229                        begin_search_type: KSPEC_BS_INVALID,
56230                        bs: C2RustUnnamed_3 {
56231                            index: C2RustUnnamed_5 { pos: 0 },
56232                        },
56233                        find_keys_type: KSPEC_FK_INVALID,
56234                        fk: C2RustUnnamed_0 {
56235                            range: C2RustUnnamed_2 {
56236                                lastkey: 0,
56237                                keystep: 0,
56238                                limit: 0,
56239                            },
56240                        },
56241                    },
56242                    keySpec {
56243                        notes: 0 as *const libc::c_char,
56244                        flags: 0,
56245                        begin_search_type: KSPEC_BS_INVALID,
56246                        bs: C2RustUnnamed_3 {
56247                            index: C2RustUnnamed_5 { pos: 0 },
56248                        },
56249                        find_keys_type: KSPEC_FK_INVALID,
56250                        fk: C2RustUnnamed_0 {
56251                            range: C2RustUnnamed_2 {
56252                                lastkey: 0,
56253                                keystep: 0,
56254                                limit: 0,
56255                            },
56256                        },
56257                    },
56258                ],
56259                getkeys_proc: None,
56260                subcommands: 0 as *const redisCommand as *mut redisCommand,
56261                args: RESTORE_ASKING_Args.as_ptr() as *mut _,
56262                microseconds: 0,
56263                calls: 0,
56264                rejected_calls: 0,
56265                failed_calls: 0,
56266                id: 0,
56267                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56268                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56269                key_specs: 0 as *const keySpec as *mut keySpec,
56270                legacy_range_key_spec: keySpec {
56271                    notes: 0 as *const libc::c_char,
56272                    flags: 0,
56273                    begin_search_type: KSPEC_BS_INVALID,
56274                    bs: C2RustUnnamed_3 {
56275                        index: C2RustUnnamed_5 { pos: 0 },
56276                    },
56277                    find_keys_type: KSPEC_FK_INVALID,
56278                    fk: C2RustUnnamed_0 {
56279                        range: C2RustUnnamed_2 {
56280                            lastkey: 0,
56281                            keystep: 0,
56282                            limit: 0,
56283                        },
56284                    },
56285                },
56286                num_args: 0,
56287                num_history: 0,
56288                num_tips: 0,
56289                key_specs_num: 0,
56290                key_specs_max: 0,
56291                subcommands_dict: 0 as *const dict as *mut dict,
56292                parent: 0 as *const redisCommand as *mut redisCommand,
56293                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56294            };
56295            init
56296        },
56297        {
56298            let mut init = redisCommand {
56299                declared_name: b"role\0" as *const u8 as *const libc::c_char,
56300                summary: b"Return the role of the instance in the context of replication\0"
56301                    as *const u8 as *const libc::c_char,
56302                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
56303                since: b"2.8.12\0" as *const u8 as *const libc::c_char,
56304                doc_flags: 0 as libc::c_int,
56305                replaced_by: 0 as *const libc::c_char,
56306                deprecated_since: 0 as *const libc::c_char,
56307                group: COMMAND_GROUP_SERVER,
56308                history: 0 as *const commandHistory as *mut commandHistory,
56309                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56310                proc_0: Some(roleCommand as unsafe extern "C" fn(*mut client) -> ()),
56311                arity: 1 as libc::c_int,
56312                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
56313                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
56314                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
56315                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
56316                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
56317                acl_categories: ((1 as libc::c_ulonglong) << 13 as libc::c_int
56318                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
56319                key_specs_static: [keySpec {
56320                    notes: 0 as *const libc::c_char,
56321                    flags: 0,
56322                    begin_search_type: KSPEC_BS_INVALID,
56323                    bs: C2RustUnnamed_3 {
56324                        index: C2RustUnnamed_5 { pos: 0 },
56325                    },
56326                    find_keys_type: KSPEC_FK_INVALID,
56327                    fk: C2RustUnnamed_0 {
56328                        range: C2RustUnnamed_2 {
56329                            lastkey: 0,
56330                            keystep: 0,
56331                            limit: 0,
56332                        },
56333                    },
56334                }; 4],
56335                getkeys_proc: None,
56336                subcommands: 0 as *const redisCommand as *mut redisCommand,
56337                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56338                microseconds: 0,
56339                calls: 0,
56340                rejected_calls: 0,
56341                failed_calls: 0,
56342                id: 0,
56343                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56344                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56345                key_specs: 0 as *const keySpec as *mut keySpec,
56346                legacy_range_key_spec: keySpec {
56347                    notes: 0 as *const libc::c_char,
56348                    flags: 0,
56349                    begin_search_type: KSPEC_BS_INVALID,
56350                    bs: C2RustUnnamed_3 {
56351                        index: C2RustUnnamed_5 { pos: 0 },
56352                    },
56353                    find_keys_type: KSPEC_FK_INVALID,
56354                    fk: C2RustUnnamed_0 {
56355                        range: C2RustUnnamed_2 {
56356                            lastkey: 0,
56357                            keystep: 0,
56358                            limit: 0,
56359                        },
56360                    },
56361                },
56362                num_args: 0,
56363                num_history: 0,
56364                num_tips: 0,
56365                key_specs_num: 0,
56366                key_specs_max: 0,
56367                subcommands_dict: 0 as *const dict as *mut dict,
56368                parent: 0 as *const redisCommand as *mut redisCommand,
56369                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56370            };
56371            init
56372        },
56373        {
56374            let mut init = redisCommand {
56375                declared_name: b"save\0" as *const u8 as *const libc::c_char,
56376                summary: b"Synchronously save the dataset to disk\0" as *const u8
56377                    as *const libc::c_char,
56378                complexity: b"O(N) where N is the total number of keys in all databases\0"
56379                    as *const u8 as *const libc::c_char,
56380                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
56381                doc_flags: 0 as libc::c_int,
56382                replaced_by: 0 as *const libc::c_char,
56383                deprecated_since: 0 as *const libc::c_char,
56384                group: COMMAND_GROUP_SERVER,
56385                history: 0 as *const commandHistory as *mut commandHistory,
56386                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56387                proc_0: Some(saveCommand as unsafe extern "C" fn(*mut client) -> ()),
56388                arity: 1 as libc::c_int,
56389                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
56390                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
56391                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
56392                    | (1 as libc::c_ulonglong) << 24 as libc::c_int) as uint64_t,
56393                acl_categories: 0 as libc::c_int as uint64_t,
56394                key_specs_static: [keySpec {
56395                    notes: 0 as *const libc::c_char,
56396                    flags: 0,
56397                    begin_search_type: KSPEC_BS_INVALID,
56398                    bs: C2RustUnnamed_3 {
56399                        index: C2RustUnnamed_5 { pos: 0 },
56400                    },
56401                    find_keys_type: KSPEC_FK_INVALID,
56402                    fk: C2RustUnnamed_0 {
56403                        range: C2RustUnnamed_2 {
56404                            lastkey: 0,
56405                            keystep: 0,
56406                            limit: 0,
56407                        },
56408                    },
56409                }; 4],
56410                getkeys_proc: None,
56411                subcommands: 0 as *const redisCommand as *mut redisCommand,
56412                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56413                microseconds: 0,
56414                calls: 0,
56415                rejected_calls: 0,
56416                failed_calls: 0,
56417                id: 0,
56418                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56419                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56420                key_specs: 0 as *const keySpec as *mut keySpec,
56421                legacy_range_key_spec: keySpec {
56422                    notes: 0 as *const libc::c_char,
56423                    flags: 0,
56424                    begin_search_type: KSPEC_BS_INVALID,
56425                    bs: C2RustUnnamed_3 {
56426                        index: C2RustUnnamed_5 { pos: 0 },
56427                    },
56428                    find_keys_type: KSPEC_FK_INVALID,
56429                    fk: C2RustUnnamed_0 {
56430                        range: C2RustUnnamed_2 {
56431                            lastkey: 0,
56432                            keystep: 0,
56433                            limit: 0,
56434                        },
56435                    },
56436                },
56437                num_args: 0,
56438                num_history: 0,
56439                num_tips: 0,
56440                key_specs_num: 0,
56441                key_specs_max: 0,
56442                subcommands_dict: 0 as *const dict as *mut dict,
56443                parent: 0 as *const redisCommand as *mut redisCommand,
56444                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56445            };
56446            init
56447        },
56448        {
56449            let mut init = redisCommand {
56450                declared_name: b"shutdown\0" as *const u8 as *const libc::c_char,
56451                summary: b"Synchronously save the dataset to disk and then shut down the server\0"
56452                    as *const u8 as *const libc::c_char,
56453                complexity: b"O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)\0"
56454                    as *const u8 as *const libc::c_char,
56455                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
56456                doc_flags: 0 as libc::c_int,
56457                replaced_by: 0 as *const libc::c_char,
56458                deprecated_since: 0 as *const libc::c_char,
56459                group: COMMAND_GROUP_SERVER,
56460                history: SHUTDOWN_History.as_ptr() as *mut _,
56461                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56462                proc_0: Some(shutdownCommand as unsafe extern "C" fn(*mut client) -> ()),
56463                arity: -(1 as libc::c_int),
56464                flags: ((1 as libc::c_ulonglong) << 4 as libc::c_int
56465                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
56466                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
56467                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
56468                    | (1 as libc::c_ulonglong) << 24 as libc::c_int
56469                    | (1 as libc::c_ulonglong) << 17 as libc::c_int
56470                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
56471                acl_categories: 0 as libc::c_int as uint64_t,
56472                key_specs_static: [keySpec {
56473                    notes: 0 as *const libc::c_char,
56474                    flags: 0,
56475                    begin_search_type: KSPEC_BS_INVALID,
56476                    bs: C2RustUnnamed_3 {
56477                        index: C2RustUnnamed_5 { pos: 0 },
56478                    },
56479                    find_keys_type: KSPEC_FK_INVALID,
56480                    fk: C2RustUnnamed_0 {
56481                        range: C2RustUnnamed_2 {
56482                            lastkey: 0,
56483                            keystep: 0,
56484                            limit: 0,
56485                        },
56486                    },
56487                }; 4],
56488                getkeys_proc: None,
56489                subcommands: 0 as *const redisCommand as *mut redisCommand,
56490                args: SHUTDOWN_Args.as_ptr() as *mut _,
56491                microseconds: 0,
56492                calls: 0,
56493                rejected_calls: 0,
56494                failed_calls: 0,
56495                id: 0,
56496                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56497                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56498                key_specs: 0 as *const keySpec as *mut keySpec,
56499                legacy_range_key_spec: keySpec {
56500                    notes: 0 as *const libc::c_char,
56501                    flags: 0,
56502                    begin_search_type: KSPEC_BS_INVALID,
56503                    bs: C2RustUnnamed_3 {
56504                        index: C2RustUnnamed_5 { pos: 0 },
56505                    },
56506                    find_keys_type: KSPEC_FK_INVALID,
56507                    fk: C2RustUnnamed_0 {
56508                        range: C2RustUnnamed_2 {
56509                            lastkey: 0,
56510                            keystep: 0,
56511                            limit: 0,
56512                        },
56513                    },
56514                },
56515                num_args: 0,
56516                num_history: 0,
56517                num_tips: 0,
56518                key_specs_num: 0,
56519                key_specs_max: 0,
56520                subcommands_dict: 0 as *const dict as *mut dict,
56521                parent: 0 as *const redisCommand as *mut redisCommand,
56522                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56523            };
56524            init
56525        },
56526        {
56527            let mut init = redisCommand {
56528                declared_name: b"slaveof\0" as *const u8 as *const libc::c_char,
56529                summary: b"Make the server a replica of another instance, or promote it as master.\0"
56530                    as *const u8 as *const libc::c_char,
56531                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
56532                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
56533                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
56534                replaced_by: b"`REPLICAOF`\0" as *const u8 as *const libc::c_char,
56535                deprecated_since: b"5.0.0\0" as *const u8 as *const libc::c_char,
56536                group: COMMAND_GROUP_SERVER,
56537                history: 0 as *const commandHistory as *mut commandHistory,
56538                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56539                proc_0: Some(
56540                    replicaofCommand as unsafe extern "C" fn(*mut client) -> (),
56541                ),
56542                arity: 3 as libc::c_int,
56543                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
56544                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
56545                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
56546                    | (1 as libc::c_ulonglong) << 10 as libc::c_int) as uint64_t,
56547                acl_categories: 0 as libc::c_int as uint64_t,
56548                key_specs_static: [keySpec {
56549                    notes: 0 as *const libc::c_char,
56550                    flags: 0,
56551                    begin_search_type: KSPEC_BS_INVALID,
56552                    bs: C2RustUnnamed_3 {
56553                        index: C2RustUnnamed_5 { pos: 0 },
56554                    },
56555                    find_keys_type: KSPEC_FK_INVALID,
56556                    fk: C2RustUnnamed_0 {
56557                        range: C2RustUnnamed_2 {
56558                            lastkey: 0,
56559                            keystep: 0,
56560                            limit: 0,
56561                        },
56562                    },
56563                }; 4],
56564                getkeys_proc: None,
56565                subcommands: 0 as *const redisCommand as *mut redisCommand,
56566                args: SLAVEOF_Args.as_ptr() as *mut _,
56567                microseconds: 0,
56568                calls: 0,
56569                rejected_calls: 0,
56570                failed_calls: 0,
56571                id: 0,
56572                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56573                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56574                key_specs: 0 as *const keySpec as *mut keySpec,
56575                legacy_range_key_spec: keySpec {
56576                    notes: 0 as *const libc::c_char,
56577                    flags: 0,
56578                    begin_search_type: KSPEC_BS_INVALID,
56579                    bs: C2RustUnnamed_3 {
56580                        index: C2RustUnnamed_5 { pos: 0 },
56581                    },
56582                    find_keys_type: KSPEC_FK_INVALID,
56583                    fk: C2RustUnnamed_0 {
56584                        range: C2RustUnnamed_2 {
56585                            lastkey: 0,
56586                            keystep: 0,
56587                            limit: 0,
56588                        },
56589                    },
56590                },
56591                num_args: 0,
56592                num_history: 0,
56593                num_tips: 0,
56594                key_specs_num: 0,
56595                key_specs_max: 0,
56596                subcommands_dict: 0 as *const dict as *mut dict,
56597                parent: 0 as *const redisCommand as *mut redisCommand,
56598                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56599            };
56600            init
56601        },
56602        {
56603            let mut init = redisCommand {
56604                declared_name: b"slowlog\0" as *const u8 as *const libc::c_char,
56605                summary: b"A container for slow log commands\0" as *const u8
56606                    as *const libc::c_char,
56607                complexity: b"Depends on subcommand.\0" as *const u8
56608                    as *const libc::c_char,
56609                since: b"2.2.12\0" as *const u8 as *const libc::c_char,
56610                doc_flags: 0 as libc::c_int,
56611                replaced_by: 0 as *const libc::c_char,
56612                deprecated_since: 0 as *const libc::c_char,
56613                group: COMMAND_GROUP_SERVER,
56614                history: 0 as *const commandHistory as *mut commandHistory,
56615                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56616                proc_0: None,
56617                arity: -(2 as libc::c_int),
56618                flags: 0 as libc::c_int as uint64_t,
56619                acl_categories: 0 as libc::c_int as uint64_t,
56620                key_specs_static: [keySpec {
56621                    notes: 0 as *const libc::c_char,
56622                    flags: 0,
56623                    begin_search_type: KSPEC_BS_INVALID,
56624                    bs: C2RustUnnamed_3 {
56625                        index: C2RustUnnamed_5 { pos: 0 },
56626                    },
56627                    find_keys_type: KSPEC_FK_INVALID,
56628                    fk: C2RustUnnamed_0 {
56629                        range: C2RustUnnamed_2 {
56630                            lastkey: 0,
56631                            keystep: 0,
56632                            limit: 0,
56633                        },
56634                    },
56635                }; 4],
56636                getkeys_proc: None,
56637                subcommands: SLOWLOG_Subcommands.as_ptr() as *mut _,
56638                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56639                microseconds: 0,
56640                calls: 0,
56641                rejected_calls: 0,
56642                failed_calls: 0,
56643                id: 0,
56644                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56645                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56646                key_specs: 0 as *const keySpec as *mut keySpec,
56647                legacy_range_key_spec: keySpec {
56648                    notes: 0 as *const libc::c_char,
56649                    flags: 0,
56650                    begin_search_type: KSPEC_BS_INVALID,
56651                    bs: C2RustUnnamed_3 {
56652                        index: C2RustUnnamed_5 { pos: 0 },
56653                    },
56654                    find_keys_type: KSPEC_FK_INVALID,
56655                    fk: C2RustUnnamed_0 {
56656                        range: C2RustUnnamed_2 {
56657                            lastkey: 0,
56658                            keystep: 0,
56659                            limit: 0,
56660                        },
56661                    },
56662                },
56663                num_args: 0,
56664                num_history: 0,
56665                num_tips: 0,
56666                key_specs_num: 0,
56667                key_specs_max: 0,
56668                subcommands_dict: 0 as *const dict as *mut dict,
56669                parent: 0 as *const redisCommand as *mut redisCommand,
56670                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56671            };
56672            init
56673        },
56674        {
56675            let mut init = redisCommand {
56676                declared_name: b"swapdb\0" as *const u8 as *const libc::c_char,
56677                summary: b"Swaps two Redis databases\0" as *const u8
56678                    as *const libc::c_char,
56679                complexity: b"O(N) where N is the count of clients watching or blocking on keys from both databases.\0"
56680                    as *const u8 as *const libc::c_char,
56681                since: b"4.0.0\0" as *const u8 as *const libc::c_char,
56682                doc_flags: 0 as libc::c_int,
56683                replaced_by: 0 as *const libc::c_char,
56684                deprecated_since: 0 as *const libc::c_char,
56685                group: COMMAND_GROUP_SERVER,
56686                history: 0 as *const commandHistory as *mut commandHistory,
56687                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56688                proc_0: Some(swapdbCommand as unsafe extern "C" fn(*mut client) -> ()),
56689                arity: 3 as libc::c_int,
56690                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
56691                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
56692                acl_categories: ((1 as libc::c_ulonglong) << 0 as libc::c_int
56693                    | (1 as libc::c_ulonglong) << 17 as libc::c_int) as uint64_t,
56694                key_specs_static: [keySpec {
56695                    notes: 0 as *const libc::c_char,
56696                    flags: 0,
56697                    begin_search_type: KSPEC_BS_INVALID,
56698                    bs: C2RustUnnamed_3 {
56699                        index: C2RustUnnamed_5 { pos: 0 },
56700                    },
56701                    find_keys_type: KSPEC_FK_INVALID,
56702                    fk: C2RustUnnamed_0 {
56703                        range: C2RustUnnamed_2 {
56704                            lastkey: 0,
56705                            keystep: 0,
56706                            limit: 0,
56707                        },
56708                    },
56709                }; 4],
56710                getkeys_proc: None,
56711                subcommands: 0 as *const redisCommand as *mut redisCommand,
56712                args: SWAPDB_Args.as_ptr() as *mut _,
56713                microseconds: 0,
56714                calls: 0,
56715                rejected_calls: 0,
56716                failed_calls: 0,
56717                id: 0,
56718                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56719                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56720                key_specs: 0 as *const keySpec as *mut keySpec,
56721                legacy_range_key_spec: keySpec {
56722                    notes: 0 as *const libc::c_char,
56723                    flags: 0,
56724                    begin_search_type: KSPEC_BS_INVALID,
56725                    bs: C2RustUnnamed_3 {
56726                        index: C2RustUnnamed_5 { pos: 0 },
56727                    },
56728                    find_keys_type: KSPEC_FK_INVALID,
56729                    fk: C2RustUnnamed_0 {
56730                        range: C2RustUnnamed_2 {
56731                            lastkey: 0,
56732                            keystep: 0,
56733                            limit: 0,
56734                        },
56735                    },
56736                },
56737                num_args: 0,
56738                num_history: 0,
56739                num_tips: 0,
56740                key_specs_num: 0,
56741                key_specs_max: 0,
56742                subcommands_dict: 0 as *const dict as *mut dict,
56743                parent: 0 as *const redisCommand as *mut redisCommand,
56744                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56745            };
56746            init
56747        },
56748        {
56749            let mut init = redisCommand {
56750                declared_name: b"sync\0" as *const u8 as *const libc::c_char,
56751                summary: b"Internal command used for replication\0" as *const u8
56752                    as *const libc::c_char,
56753                complexity: 0 as *const libc::c_char,
56754                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
56755                doc_flags: 0 as libc::c_int,
56756                replaced_by: 0 as *const libc::c_char,
56757                deprecated_since: 0 as *const libc::c_char,
56758                group: COMMAND_GROUP_SERVER,
56759                history: 0 as *const commandHistory as *mut commandHistory,
56760                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56761                proc_0: Some(syncCommand as unsafe extern "C" fn(*mut client) -> ()),
56762                arity: 1 as libc::c_int,
56763                flags: ((1 as libc::c_ulonglong) << 23 as libc::c_int
56764                    | (1 as libc::c_ulonglong) << 4 as libc::c_int
56765                    | (1 as libc::c_ulonglong) << 24 as libc::c_int
56766                    | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
56767                acl_categories: 0 as libc::c_int as uint64_t,
56768                key_specs_static: [keySpec {
56769                    notes: 0 as *const libc::c_char,
56770                    flags: 0,
56771                    begin_search_type: KSPEC_BS_INVALID,
56772                    bs: C2RustUnnamed_3 {
56773                        index: C2RustUnnamed_5 { pos: 0 },
56774                    },
56775                    find_keys_type: KSPEC_FK_INVALID,
56776                    fk: C2RustUnnamed_0 {
56777                        range: C2RustUnnamed_2 {
56778                            lastkey: 0,
56779                            keystep: 0,
56780                            limit: 0,
56781                        },
56782                    },
56783                }; 4],
56784                getkeys_proc: None,
56785                subcommands: 0 as *const redisCommand as *mut redisCommand,
56786                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56787                microseconds: 0,
56788                calls: 0,
56789                rejected_calls: 0,
56790                failed_calls: 0,
56791                id: 0,
56792                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56793                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56794                key_specs: 0 as *const keySpec as *mut keySpec,
56795                legacy_range_key_spec: keySpec {
56796                    notes: 0 as *const libc::c_char,
56797                    flags: 0,
56798                    begin_search_type: KSPEC_BS_INVALID,
56799                    bs: C2RustUnnamed_3 {
56800                        index: C2RustUnnamed_5 { pos: 0 },
56801                    },
56802                    find_keys_type: KSPEC_FK_INVALID,
56803                    fk: C2RustUnnamed_0 {
56804                        range: C2RustUnnamed_2 {
56805                            lastkey: 0,
56806                            keystep: 0,
56807                            limit: 0,
56808                        },
56809                    },
56810                },
56811                num_args: 0,
56812                num_history: 0,
56813                num_tips: 0,
56814                key_specs_num: 0,
56815                key_specs_max: 0,
56816                subcommands_dict: 0 as *const dict as *mut dict,
56817                parent: 0 as *const redisCommand as *mut redisCommand,
56818                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56819            };
56820            init
56821        },
56822        {
56823            let mut init = redisCommand {
56824                declared_name: b"time\0" as *const u8 as *const libc::c_char,
56825                summary: b"Return the current server time\0" as *const u8
56826                    as *const libc::c_char,
56827                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
56828                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
56829                doc_flags: 0 as libc::c_int,
56830                replaced_by: 0 as *const libc::c_char,
56831                deprecated_since: 0 as *const libc::c_char,
56832                group: COMMAND_GROUP_SERVER,
56833                history: 0 as *const commandHistory as *mut commandHistory,
56834                tips: TIME_tips.as_ptr() as *mut _,
56835                proc_0: Some(timeCommand as unsafe extern "C" fn(*mut client) -> ()),
56836                arity: 1 as libc::c_int,
56837                flags: ((1 as libc::c_ulonglong) << 9 as libc::c_int
56838                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
56839                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
56840                acl_categories: 0 as libc::c_int as uint64_t,
56841                key_specs_static: [keySpec {
56842                    notes: 0 as *const libc::c_char,
56843                    flags: 0,
56844                    begin_search_type: KSPEC_BS_INVALID,
56845                    bs: C2RustUnnamed_3 {
56846                        index: C2RustUnnamed_5 { pos: 0 },
56847                    },
56848                    find_keys_type: KSPEC_FK_INVALID,
56849                    fk: C2RustUnnamed_0 {
56850                        range: C2RustUnnamed_2 {
56851                            lastkey: 0,
56852                            keystep: 0,
56853                            limit: 0,
56854                        },
56855                    },
56856                }; 4],
56857                getkeys_proc: None,
56858                subcommands: 0 as *const redisCommand as *mut redisCommand,
56859                args: 0 as *const redisCommandArg as *mut redisCommandArg,
56860                microseconds: 0,
56861                calls: 0,
56862                rejected_calls: 0,
56863                failed_calls: 0,
56864                id: 0,
56865                fullname: 0 as *const libc::c_char as *mut libc::c_char,
56866                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
56867                key_specs: 0 as *const keySpec as *mut keySpec,
56868                legacy_range_key_spec: keySpec {
56869                    notes: 0 as *const libc::c_char,
56870                    flags: 0,
56871                    begin_search_type: KSPEC_BS_INVALID,
56872                    bs: C2RustUnnamed_3 {
56873                        index: C2RustUnnamed_5 { pos: 0 },
56874                    },
56875                    find_keys_type: KSPEC_FK_INVALID,
56876                    fk: C2RustUnnamed_0 {
56877                        range: C2RustUnnamed_2 {
56878                            lastkey: 0,
56879                            keystep: 0,
56880                            limit: 0,
56881                        },
56882                    },
56883                },
56884                num_args: 0,
56885                num_history: 0,
56886                num_tips: 0,
56887                key_specs_num: 0,
56888                key_specs_max: 0,
56889                subcommands_dict: 0 as *const dict as *mut dict,
56890                parent: 0 as *const redisCommand as *mut redisCommand,
56891                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
56892            };
56893            init
56894        },
56895        {
56896            let mut init = redisCommand {
56897                declared_name: b"sadd\0" as *const u8 as *const libc::c_char,
56898                summary: b"Add one or more members to a set\0" as *const u8
56899                    as *const libc::c_char,
56900                complexity: b"O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.\0"
56901                    as *const u8 as *const libc::c_char,
56902                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
56903                doc_flags: 0 as libc::c_int,
56904                replaced_by: 0 as *const libc::c_char,
56905                deprecated_since: 0 as *const libc::c_char,
56906                group: COMMAND_GROUP_SET,
56907                history: SADD_History.as_ptr() as *mut _,
56908                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
56909                proc_0: Some(saddCommand as unsafe extern "C" fn(*mut client) -> ()),
56910                arity: -(3 as libc::c_int),
56911                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
56912                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
56913                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
56914                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
56915                    as uint64_t,
56916                key_specs_static: [
56917                    {
56918                        let mut init = keySpec {
56919                            notes: 0 as *const libc::c_char,
56920                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
56921                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
56922                            begin_search_type: KSPEC_BS_INDEX,
56923                            bs: C2RustUnnamed_3 {
56924                                index: {
56925                                    let mut init = C2RustUnnamed_5 {
56926                                        pos: 1 as libc::c_int,
56927                                    };
56928                                    init
56929                                },
56930                            },
56931                            find_keys_type: KSPEC_FK_RANGE,
56932                            fk: C2RustUnnamed_0 {
56933                                range: {
56934                                    let mut init = C2RustUnnamed_2 {
56935                                        lastkey: 0 as libc::c_int,
56936                                        keystep: 1 as libc::c_int,
56937                                        limit: 0 as libc::c_int,
56938                                    };
56939                                    init
56940                                },
56941                            },
56942                        };
56943                        init
56944                    },
56945                    keySpec {
56946                        notes: 0 as *const libc::c_char,
56947                        flags: 0,
56948                        begin_search_type: KSPEC_BS_INVALID,
56949                        bs: C2RustUnnamed_3 {
56950                            index: C2RustUnnamed_5 { pos: 0 },
56951                        },
56952                        find_keys_type: KSPEC_FK_INVALID,
56953                        fk: C2RustUnnamed_0 {
56954                            range: C2RustUnnamed_2 {
56955                                lastkey: 0,
56956                                keystep: 0,
56957                                limit: 0,
56958                            },
56959                        },
56960                    },
56961                    keySpec {
56962                        notes: 0 as *const libc::c_char,
56963                        flags: 0,
56964                        begin_search_type: KSPEC_BS_INVALID,
56965                        bs: C2RustUnnamed_3 {
56966                            index: C2RustUnnamed_5 { pos: 0 },
56967                        },
56968                        find_keys_type: KSPEC_FK_INVALID,
56969                        fk: C2RustUnnamed_0 {
56970                            range: C2RustUnnamed_2 {
56971                                lastkey: 0,
56972                                keystep: 0,
56973                                limit: 0,
56974                            },
56975                        },
56976                    },
56977                    keySpec {
56978                        notes: 0 as *const libc::c_char,
56979                        flags: 0,
56980                        begin_search_type: KSPEC_BS_INVALID,
56981                        bs: C2RustUnnamed_3 {
56982                            index: C2RustUnnamed_5 { pos: 0 },
56983                        },
56984                        find_keys_type: KSPEC_FK_INVALID,
56985                        fk: C2RustUnnamed_0 {
56986                            range: C2RustUnnamed_2 {
56987                                lastkey: 0,
56988                                keystep: 0,
56989                                limit: 0,
56990                            },
56991                        },
56992                    },
56993                ],
56994                getkeys_proc: None,
56995                subcommands: 0 as *const redisCommand as *mut redisCommand,
56996                args: SADD_Args.as_ptr() as *mut _,
56997                microseconds: 0,
56998                calls: 0,
56999                rejected_calls: 0,
57000                failed_calls: 0,
57001                id: 0,
57002                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57003                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57004                key_specs: 0 as *const keySpec as *mut keySpec,
57005                legacy_range_key_spec: keySpec {
57006                    notes: 0 as *const libc::c_char,
57007                    flags: 0,
57008                    begin_search_type: KSPEC_BS_INVALID,
57009                    bs: C2RustUnnamed_3 {
57010                        index: C2RustUnnamed_5 { pos: 0 },
57011                    },
57012                    find_keys_type: KSPEC_FK_INVALID,
57013                    fk: C2RustUnnamed_0 {
57014                        range: C2RustUnnamed_2 {
57015                            lastkey: 0,
57016                            keystep: 0,
57017                            limit: 0,
57018                        },
57019                    },
57020                },
57021                num_args: 0,
57022                num_history: 0,
57023                num_tips: 0,
57024                key_specs_num: 0,
57025                key_specs_max: 0,
57026                subcommands_dict: 0 as *const dict as *mut dict,
57027                parent: 0 as *const redisCommand as *mut redisCommand,
57028                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57029            };
57030            init
57031        },
57032        {
57033            let mut init = redisCommand {
57034                declared_name: b"scard\0" as *const u8 as *const libc::c_char,
57035                summary: b"Get the number of members in a set\0" as *const u8
57036                    as *const libc::c_char,
57037                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
57038                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57039                doc_flags: 0 as libc::c_int,
57040                replaced_by: 0 as *const libc::c_char,
57041                deprecated_since: 0 as *const libc::c_char,
57042                group: COMMAND_GROUP_SET,
57043                history: 0 as *const commandHistory as *mut commandHistory,
57044                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
57045                proc_0: Some(scardCommand as unsafe extern "C" fn(*mut client) -> ()),
57046                arity: 2 as libc::c_int,
57047                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
57048                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
57049                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57050                    as uint64_t,
57051                key_specs_static: [
57052                    {
57053                        let mut init = keySpec {
57054                            notes: 0 as *const libc::c_char,
57055                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
57056                                as uint64_t,
57057                            begin_search_type: KSPEC_BS_INDEX,
57058                            bs: C2RustUnnamed_3 {
57059                                index: {
57060                                    let mut init = C2RustUnnamed_5 {
57061                                        pos: 1 as libc::c_int,
57062                                    };
57063                                    init
57064                                },
57065                            },
57066                            find_keys_type: KSPEC_FK_RANGE,
57067                            fk: C2RustUnnamed_0 {
57068                                range: {
57069                                    let mut init = C2RustUnnamed_2 {
57070                                        lastkey: 0 as libc::c_int,
57071                                        keystep: 1 as libc::c_int,
57072                                        limit: 0 as libc::c_int,
57073                                    };
57074                                    init
57075                                },
57076                            },
57077                        };
57078                        init
57079                    },
57080                    keySpec {
57081                        notes: 0 as *const libc::c_char,
57082                        flags: 0,
57083                        begin_search_type: KSPEC_BS_INVALID,
57084                        bs: C2RustUnnamed_3 {
57085                            index: C2RustUnnamed_5 { pos: 0 },
57086                        },
57087                        find_keys_type: KSPEC_FK_INVALID,
57088                        fk: C2RustUnnamed_0 {
57089                            range: C2RustUnnamed_2 {
57090                                lastkey: 0,
57091                                keystep: 0,
57092                                limit: 0,
57093                            },
57094                        },
57095                    },
57096                    keySpec {
57097                        notes: 0 as *const libc::c_char,
57098                        flags: 0,
57099                        begin_search_type: KSPEC_BS_INVALID,
57100                        bs: C2RustUnnamed_3 {
57101                            index: C2RustUnnamed_5 { pos: 0 },
57102                        },
57103                        find_keys_type: KSPEC_FK_INVALID,
57104                        fk: C2RustUnnamed_0 {
57105                            range: C2RustUnnamed_2 {
57106                                lastkey: 0,
57107                                keystep: 0,
57108                                limit: 0,
57109                            },
57110                        },
57111                    },
57112                    keySpec {
57113                        notes: 0 as *const libc::c_char,
57114                        flags: 0,
57115                        begin_search_type: KSPEC_BS_INVALID,
57116                        bs: C2RustUnnamed_3 {
57117                            index: C2RustUnnamed_5 { pos: 0 },
57118                        },
57119                        find_keys_type: KSPEC_FK_INVALID,
57120                        fk: C2RustUnnamed_0 {
57121                            range: C2RustUnnamed_2 {
57122                                lastkey: 0,
57123                                keystep: 0,
57124                                limit: 0,
57125                            },
57126                        },
57127                    },
57128                ],
57129                getkeys_proc: None,
57130                subcommands: 0 as *const redisCommand as *mut redisCommand,
57131                args: SCARD_Args.as_ptr() as *mut _,
57132                microseconds: 0,
57133                calls: 0,
57134                rejected_calls: 0,
57135                failed_calls: 0,
57136                id: 0,
57137                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57138                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57139                key_specs: 0 as *const keySpec as *mut keySpec,
57140                legacy_range_key_spec: keySpec {
57141                    notes: 0 as *const libc::c_char,
57142                    flags: 0,
57143                    begin_search_type: KSPEC_BS_INVALID,
57144                    bs: C2RustUnnamed_3 {
57145                        index: C2RustUnnamed_5 { pos: 0 },
57146                    },
57147                    find_keys_type: KSPEC_FK_INVALID,
57148                    fk: C2RustUnnamed_0 {
57149                        range: C2RustUnnamed_2 {
57150                            lastkey: 0,
57151                            keystep: 0,
57152                            limit: 0,
57153                        },
57154                    },
57155                },
57156                num_args: 0,
57157                num_history: 0,
57158                num_tips: 0,
57159                key_specs_num: 0,
57160                key_specs_max: 0,
57161                subcommands_dict: 0 as *const dict as *mut dict,
57162                parent: 0 as *const redisCommand as *mut redisCommand,
57163                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57164            };
57165            init
57166        },
57167        {
57168            let mut init = redisCommand {
57169                declared_name: b"sdiff\0" as *const u8 as *const libc::c_char,
57170                summary: b"Subtract multiple sets\0" as *const u8 as *const libc::c_char,
57171                complexity: b"O(N) where N is the total number of elements in all given sets.\0"
57172                    as *const u8 as *const libc::c_char,
57173                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57174                doc_flags: 0 as libc::c_int,
57175                replaced_by: 0 as *const libc::c_char,
57176                deprecated_since: 0 as *const libc::c_char,
57177                group: COMMAND_GROUP_SET,
57178                history: 0 as *const commandHistory as *mut commandHistory,
57179                tips: SDIFF_tips.as_ptr() as *mut _,
57180                proc_0: Some(sdiffCommand as unsafe extern "C" fn(*mut client) -> ()),
57181                arity: -(2 as libc::c_int),
57182                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
57183                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57184                    as uint64_t,
57185                key_specs_static: [
57186                    {
57187                        let mut init = keySpec {
57188                            notes: 0 as *const libc::c_char,
57189                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57190                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
57191                            begin_search_type: KSPEC_BS_INDEX,
57192                            bs: C2RustUnnamed_3 {
57193                                index: {
57194                                    let mut init = C2RustUnnamed_5 {
57195                                        pos: 1 as libc::c_int,
57196                                    };
57197                                    init
57198                                },
57199                            },
57200                            find_keys_type: KSPEC_FK_RANGE,
57201                            fk: C2RustUnnamed_0 {
57202                                range: {
57203                                    let mut init = C2RustUnnamed_2 {
57204                                        lastkey: -(1 as libc::c_int),
57205                                        keystep: 1 as libc::c_int,
57206                                        limit: 0 as libc::c_int,
57207                                    };
57208                                    init
57209                                },
57210                            },
57211                        };
57212                        init
57213                    },
57214                    keySpec {
57215                        notes: 0 as *const libc::c_char,
57216                        flags: 0,
57217                        begin_search_type: KSPEC_BS_INVALID,
57218                        bs: C2RustUnnamed_3 {
57219                            index: C2RustUnnamed_5 { pos: 0 },
57220                        },
57221                        find_keys_type: KSPEC_FK_INVALID,
57222                        fk: C2RustUnnamed_0 {
57223                            range: C2RustUnnamed_2 {
57224                                lastkey: 0,
57225                                keystep: 0,
57226                                limit: 0,
57227                            },
57228                        },
57229                    },
57230                    keySpec {
57231                        notes: 0 as *const libc::c_char,
57232                        flags: 0,
57233                        begin_search_type: KSPEC_BS_INVALID,
57234                        bs: C2RustUnnamed_3 {
57235                            index: C2RustUnnamed_5 { pos: 0 },
57236                        },
57237                        find_keys_type: KSPEC_FK_INVALID,
57238                        fk: C2RustUnnamed_0 {
57239                            range: C2RustUnnamed_2 {
57240                                lastkey: 0,
57241                                keystep: 0,
57242                                limit: 0,
57243                            },
57244                        },
57245                    },
57246                    keySpec {
57247                        notes: 0 as *const libc::c_char,
57248                        flags: 0,
57249                        begin_search_type: KSPEC_BS_INVALID,
57250                        bs: C2RustUnnamed_3 {
57251                            index: C2RustUnnamed_5 { pos: 0 },
57252                        },
57253                        find_keys_type: KSPEC_FK_INVALID,
57254                        fk: C2RustUnnamed_0 {
57255                            range: C2RustUnnamed_2 {
57256                                lastkey: 0,
57257                                keystep: 0,
57258                                limit: 0,
57259                            },
57260                        },
57261                    },
57262                ],
57263                getkeys_proc: None,
57264                subcommands: 0 as *const redisCommand as *mut redisCommand,
57265                args: SDIFF_Args.as_ptr() as *mut _,
57266                microseconds: 0,
57267                calls: 0,
57268                rejected_calls: 0,
57269                failed_calls: 0,
57270                id: 0,
57271                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57272                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57273                key_specs: 0 as *const keySpec as *mut keySpec,
57274                legacy_range_key_spec: keySpec {
57275                    notes: 0 as *const libc::c_char,
57276                    flags: 0,
57277                    begin_search_type: KSPEC_BS_INVALID,
57278                    bs: C2RustUnnamed_3 {
57279                        index: C2RustUnnamed_5 { pos: 0 },
57280                    },
57281                    find_keys_type: KSPEC_FK_INVALID,
57282                    fk: C2RustUnnamed_0 {
57283                        range: C2RustUnnamed_2 {
57284                            lastkey: 0,
57285                            keystep: 0,
57286                            limit: 0,
57287                        },
57288                    },
57289                },
57290                num_args: 0,
57291                num_history: 0,
57292                num_tips: 0,
57293                key_specs_num: 0,
57294                key_specs_max: 0,
57295                subcommands_dict: 0 as *const dict as *mut dict,
57296                parent: 0 as *const redisCommand as *mut redisCommand,
57297                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57298            };
57299            init
57300        },
57301        {
57302            let mut init = redisCommand {
57303                declared_name: b"sdiffstore\0" as *const u8 as *const libc::c_char,
57304                summary: b"Subtract multiple sets and store the resulting set in a key\0"
57305                    as *const u8 as *const libc::c_char,
57306                complexity: b"O(N) where N is the total number of elements in all given sets.\0"
57307                    as *const u8 as *const libc::c_char,
57308                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57309                doc_flags: 0 as libc::c_int,
57310                replaced_by: 0 as *const libc::c_char,
57311                deprecated_since: 0 as *const libc::c_char,
57312                group: COMMAND_GROUP_SET,
57313                history: 0 as *const commandHistory as *mut commandHistory,
57314                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
57315                proc_0: Some(
57316                    sdiffstoreCommand as unsafe extern "C" fn(*mut client) -> (),
57317                ),
57318                arity: -(3 as libc::c_int),
57319                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57320                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
57321                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57322                    as uint64_t,
57323                key_specs_static: [
57324                    {
57325                        let mut init = keySpec {
57326                            notes: 0 as *const libc::c_char,
57327                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
57328                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
57329                            begin_search_type: KSPEC_BS_INDEX,
57330                            bs: C2RustUnnamed_3 {
57331                                index: {
57332                                    let mut init = C2RustUnnamed_5 {
57333                                        pos: 1 as libc::c_int,
57334                                    };
57335                                    init
57336                                },
57337                            },
57338                            find_keys_type: KSPEC_FK_RANGE,
57339                            fk: C2RustUnnamed_0 {
57340                                range: {
57341                                    let mut init = C2RustUnnamed_2 {
57342                                        lastkey: 0 as libc::c_int,
57343                                        keystep: 1 as libc::c_int,
57344                                        limit: 0 as libc::c_int,
57345                                    };
57346                                    init
57347                                },
57348                            },
57349                        };
57350                        init
57351                    },
57352                    {
57353                        let mut init = keySpec {
57354                            notes: 0 as *const libc::c_char,
57355                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57356                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
57357                            begin_search_type: KSPEC_BS_INDEX,
57358                            bs: C2RustUnnamed_3 {
57359                                index: {
57360                                    let mut init = C2RustUnnamed_5 {
57361                                        pos: 2 as libc::c_int,
57362                                    };
57363                                    init
57364                                },
57365                            },
57366                            find_keys_type: KSPEC_FK_RANGE,
57367                            fk: C2RustUnnamed_0 {
57368                                range: {
57369                                    let mut init = C2RustUnnamed_2 {
57370                                        lastkey: -(1 as libc::c_int),
57371                                        keystep: 1 as libc::c_int,
57372                                        limit: 0 as libc::c_int,
57373                                    };
57374                                    init
57375                                },
57376                            },
57377                        };
57378                        init
57379                    },
57380                    keySpec {
57381                        notes: 0 as *const libc::c_char,
57382                        flags: 0,
57383                        begin_search_type: KSPEC_BS_INVALID,
57384                        bs: C2RustUnnamed_3 {
57385                            index: C2RustUnnamed_5 { pos: 0 },
57386                        },
57387                        find_keys_type: KSPEC_FK_INVALID,
57388                        fk: C2RustUnnamed_0 {
57389                            range: C2RustUnnamed_2 {
57390                                lastkey: 0,
57391                                keystep: 0,
57392                                limit: 0,
57393                            },
57394                        },
57395                    },
57396                    keySpec {
57397                        notes: 0 as *const libc::c_char,
57398                        flags: 0,
57399                        begin_search_type: KSPEC_BS_INVALID,
57400                        bs: C2RustUnnamed_3 {
57401                            index: C2RustUnnamed_5 { pos: 0 },
57402                        },
57403                        find_keys_type: KSPEC_FK_INVALID,
57404                        fk: C2RustUnnamed_0 {
57405                            range: C2RustUnnamed_2 {
57406                                lastkey: 0,
57407                                keystep: 0,
57408                                limit: 0,
57409                            },
57410                        },
57411                    },
57412                ],
57413                getkeys_proc: None,
57414                subcommands: 0 as *const redisCommand as *mut redisCommand,
57415                args: SDIFFSTORE_Args.as_ptr() as *mut _,
57416                microseconds: 0,
57417                calls: 0,
57418                rejected_calls: 0,
57419                failed_calls: 0,
57420                id: 0,
57421                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57422                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57423                key_specs: 0 as *const keySpec as *mut keySpec,
57424                legacy_range_key_spec: keySpec {
57425                    notes: 0 as *const libc::c_char,
57426                    flags: 0,
57427                    begin_search_type: KSPEC_BS_INVALID,
57428                    bs: C2RustUnnamed_3 {
57429                        index: C2RustUnnamed_5 { pos: 0 },
57430                    },
57431                    find_keys_type: KSPEC_FK_INVALID,
57432                    fk: C2RustUnnamed_0 {
57433                        range: C2RustUnnamed_2 {
57434                            lastkey: 0,
57435                            keystep: 0,
57436                            limit: 0,
57437                        },
57438                    },
57439                },
57440                num_args: 0,
57441                num_history: 0,
57442                num_tips: 0,
57443                key_specs_num: 0,
57444                key_specs_max: 0,
57445                subcommands_dict: 0 as *const dict as *mut dict,
57446                parent: 0 as *const redisCommand as *mut redisCommand,
57447                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57448            };
57449            init
57450        },
57451        {
57452            let mut init = redisCommand {
57453                declared_name: b"sinter\0" as *const u8 as *const libc::c_char,
57454                summary: b"Intersect multiple sets\0" as *const u8
57455                    as *const libc::c_char,
57456                complexity: b"O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.\0"
57457                    as *const u8 as *const libc::c_char,
57458                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57459                doc_flags: 0 as libc::c_int,
57460                replaced_by: 0 as *const libc::c_char,
57461                deprecated_since: 0 as *const libc::c_char,
57462                group: COMMAND_GROUP_SET,
57463                history: 0 as *const commandHistory as *mut commandHistory,
57464                tips: SINTER_tips.as_ptr() as *mut _,
57465                proc_0: Some(sinterCommand as unsafe extern "C" fn(*mut client) -> ()),
57466                arity: -(2 as libc::c_int),
57467                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
57468                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57469                    as uint64_t,
57470                key_specs_static: [
57471                    {
57472                        let mut init = keySpec {
57473                            notes: 0 as *const libc::c_char,
57474                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57475                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
57476                            begin_search_type: KSPEC_BS_INDEX,
57477                            bs: C2RustUnnamed_3 {
57478                                index: {
57479                                    let mut init = C2RustUnnamed_5 {
57480                                        pos: 1 as libc::c_int,
57481                                    };
57482                                    init
57483                                },
57484                            },
57485                            find_keys_type: KSPEC_FK_RANGE,
57486                            fk: C2RustUnnamed_0 {
57487                                range: {
57488                                    let mut init = C2RustUnnamed_2 {
57489                                        lastkey: -(1 as libc::c_int),
57490                                        keystep: 1 as libc::c_int,
57491                                        limit: 0 as libc::c_int,
57492                                    };
57493                                    init
57494                                },
57495                            },
57496                        };
57497                        init
57498                    },
57499                    keySpec {
57500                        notes: 0 as *const libc::c_char,
57501                        flags: 0,
57502                        begin_search_type: KSPEC_BS_INVALID,
57503                        bs: C2RustUnnamed_3 {
57504                            index: C2RustUnnamed_5 { pos: 0 },
57505                        },
57506                        find_keys_type: KSPEC_FK_INVALID,
57507                        fk: C2RustUnnamed_0 {
57508                            range: C2RustUnnamed_2 {
57509                                lastkey: 0,
57510                                keystep: 0,
57511                                limit: 0,
57512                            },
57513                        },
57514                    },
57515                    keySpec {
57516                        notes: 0 as *const libc::c_char,
57517                        flags: 0,
57518                        begin_search_type: KSPEC_BS_INVALID,
57519                        bs: C2RustUnnamed_3 {
57520                            index: C2RustUnnamed_5 { pos: 0 },
57521                        },
57522                        find_keys_type: KSPEC_FK_INVALID,
57523                        fk: C2RustUnnamed_0 {
57524                            range: C2RustUnnamed_2 {
57525                                lastkey: 0,
57526                                keystep: 0,
57527                                limit: 0,
57528                            },
57529                        },
57530                    },
57531                    keySpec {
57532                        notes: 0 as *const libc::c_char,
57533                        flags: 0,
57534                        begin_search_type: KSPEC_BS_INVALID,
57535                        bs: C2RustUnnamed_3 {
57536                            index: C2RustUnnamed_5 { pos: 0 },
57537                        },
57538                        find_keys_type: KSPEC_FK_INVALID,
57539                        fk: C2RustUnnamed_0 {
57540                            range: C2RustUnnamed_2 {
57541                                lastkey: 0,
57542                                keystep: 0,
57543                                limit: 0,
57544                            },
57545                        },
57546                    },
57547                ],
57548                getkeys_proc: None,
57549                subcommands: 0 as *const redisCommand as *mut redisCommand,
57550                args: SINTER_Args.as_ptr() as *mut _,
57551                microseconds: 0,
57552                calls: 0,
57553                rejected_calls: 0,
57554                failed_calls: 0,
57555                id: 0,
57556                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57557                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57558                key_specs: 0 as *const keySpec as *mut keySpec,
57559                legacy_range_key_spec: keySpec {
57560                    notes: 0 as *const libc::c_char,
57561                    flags: 0,
57562                    begin_search_type: KSPEC_BS_INVALID,
57563                    bs: C2RustUnnamed_3 {
57564                        index: C2RustUnnamed_5 { pos: 0 },
57565                    },
57566                    find_keys_type: KSPEC_FK_INVALID,
57567                    fk: C2RustUnnamed_0 {
57568                        range: C2RustUnnamed_2 {
57569                            lastkey: 0,
57570                            keystep: 0,
57571                            limit: 0,
57572                        },
57573                    },
57574                },
57575                num_args: 0,
57576                num_history: 0,
57577                num_tips: 0,
57578                key_specs_num: 0,
57579                key_specs_max: 0,
57580                subcommands_dict: 0 as *const dict as *mut dict,
57581                parent: 0 as *const redisCommand as *mut redisCommand,
57582                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57583            };
57584            init
57585        },
57586        {
57587            let mut init = redisCommand {
57588                declared_name: b"sintercard\0" as *const u8 as *const libc::c_char,
57589                summary: b"Intersect multiple sets and return the cardinality of the result\0"
57590                    as *const u8 as *const libc::c_char,
57591                complexity: b"O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.\0"
57592                    as *const u8 as *const libc::c_char,
57593                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
57594                doc_flags: 0 as libc::c_int,
57595                replaced_by: 0 as *const libc::c_char,
57596                deprecated_since: 0 as *const libc::c_char,
57597                group: COMMAND_GROUP_SET,
57598                history: 0 as *const commandHistory as *mut commandHistory,
57599                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
57600                proc_0: Some(
57601                    sinterCardCommand as unsafe extern "C" fn(*mut client) -> (),
57602                ),
57603                arity: -(3 as libc::c_int),
57604                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
57605                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57606                    as uint64_t,
57607                key_specs_static: [
57608                    {
57609                        let mut init = keySpec {
57610                            notes: 0 as *const libc::c_char,
57611                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57612                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
57613                            begin_search_type: KSPEC_BS_INDEX,
57614                            bs: C2RustUnnamed_3 {
57615                                index: {
57616                                    let mut init = C2RustUnnamed_5 {
57617                                        pos: 1 as libc::c_int,
57618                                    };
57619                                    init
57620                                },
57621                            },
57622                            find_keys_type: KSPEC_FK_KEYNUM,
57623                            fk: C2RustUnnamed_0 {
57624                                keynum: {
57625                                    let mut init = C2RustUnnamed_1 {
57626                                        keynumidx: 0 as libc::c_int,
57627                                        firstkey: 1 as libc::c_int,
57628                                        keystep: 1 as libc::c_int,
57629                                    };
57630                                    init
57631                                },
57632                            },
57633                        };
57634                        init
57635                    },
57636                    keySpec {
57637                        notes: 0 as *const libc::c_char,
57638                        flags: 0,
57639                        begin_search_type: KSPEC_BS_INVALID,
57640                        bs: C2RustUnnamed_3 {
57641                            index: C2RustUnnamed_5 { pos: 0 },
57642                        },
57643                        find_keys_type: KSPEC_FK_INVALID,
57644                        fk: C2RustUnnamed_0 {
57645                            range: C2RustUnnamed_2 {
57646                                lastkey: 0,
57647                                keystep: 0,
57648                                limit: 0,
57649                            },
57650                        },
57651                    },
57652                    keySpec {
57653                        notes: 0 as *const libc::c_char,
57654                        flags: 0,
57655                        begin_search_type: KSPEC_BS_INVALID,
57656                        bs: C2RustUnnamed_3 {
57657                            index: C2RustUnnamed_5 { pos: 0 },
57658                        },
57659                        find_keys_type: KSPEC_FK_INVALID,
57660                        fk: C2RustUnnamed_0 {
57661                            range: C2RustUnnamed_2 {
57662                                lastkey: 0,
57663                                keystep: 0,
57664                                limit: 0,
57665                            },
57666                        },
57667                    },
57668                    keySpec {
57669                        notes: 0 as *const libc::c_char,
57670                        flags: 0,
57671                        begin_search_type: KSPEC_BS_INVALID,
57672                        bs: C2RustUnnamed_3 {
57673                            index: C2RustUnnamed_5 { pos: 0 },
57674                        },
57675                        find_keys_type: KSPEC_FK_INVALID,
57676                        fk: C2RustUnnamed_0 {
57677                            range: C2RustUnnamed_2 {
57678                                lastkey: 0,
57679                                keystep: 0,
57680                                limit: 0,
57681                            },
57682                        },
57683                    },
57684                ],
57685                getkeys_proc: Some(
57686                    sintercardGetKeys
57687                        as unsafe extern "C" fn(
57688                            *mut redisCommand,
57689                            *mut *mut robj,
57690                            libc::c_int,
57691                            *mut getKeysResult,
57692                        ) -> libc::c_int,
57693                ),
57694                subcommands: 0 as *const redisCommand as *mut redisCommand,
57695                args: SINTERCARD_Args.as_ptr() as *mut _,
57696                microseconds: 0,
57697                calls: 0,
57698                rejected_calls: 0,
57699                failed_calls: 0,
57700                id: 0,
57701                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57702                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57703                key_specs: 0 as *const keySpec as *mut keySpec,
57704                legacy_range_key_spec: keySpec {
57705                    notes: 0 as *const libc::c_char,
57706                    flags: 0,
57707                    begin_search_type: KSPEC_BS_INVALID,
57708                    bs: C2RustUnnamed_3 {
57709                        index: C2RustUnnamed_5 { pos: 0 },
57710                    },
57711                    find_keys_type: KSPEC_FK_INVALID,
57712                    fk: C2RustUnnamed_0 {
57713                        range: C2RustUnnamed_2 {
57714                            lastkey: 0,
57715                            keystep: 0,
57716                            limit: 0,
57717                        },
57718                    },
57719                },
57720                num_args: 0,
57721                num_history: 0,
57722                num_tips: 0,
57723                key_specs_num: 0,
57724                key_specs_max: 0,
57725                subcommands_dict: 0 as *const dict as *mut dict,
57726                parent: 0 as *const redisCommand as *mut redisCommand,
57727                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57728            };
57729            init
57730        },
57731        {
57732            let mut init = redisCommand {
57733                declared_name: b"sinterstore\0" as *const u8 as *const libc::c_char,
57734                summary: b"Intersect multiple sets and store the resulting set in a key\0"
57735                    as *const u8 as *const libc::c_char,
57736                complexity: b"O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.\0"
57737                    as *const u8 as *const libc::c_char,
57738                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57739                doc_flags: 0 as libc::c_int,
57740                replaced_by: 0 as *const libc::c_char,
57741                deprecated_since: 0 as *const libc::c_char,
57742                group: COMMAND_GROUP_SET,
57743                history: 0 as *const commandHistory as *mut commandHistory,
57744                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
57745                proc_0: Some(
57746                    sinterstoreCommand as unsafe extern "C" fn(*mut client) -> (),
57747                ),
57748                arity: -(3 as libc::c_int),
57749                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57750                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
57751                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57752                    as uint64_t,
57753                key_specs_static: [
57754                    {
57755                        let mut init = keySpec {
57756                            notes: 0 as *const libc::c_char,
57757                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
57758                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
57759                            begin_search_type: KSPEC_BS_INDEX,
57760                            bs: C2RustUnnamed_3 {
57761                                index: {
57762                                    let mut init = C2RustUnnamed_5 {
57763                                        pos: 1 as libc::c_int,
57764                                    };
57765                                    init
57766                                },
57767                            },
57768                            find_keys_type: KSPEC_FK_RANGE,
57769                            fk: C2RustUnnamed_0 {
57770                                range: {
57771                                    let mut init = C2RustUnnamed_2 {
57772                                        lastkey: 0 as libc::c_int,
57773                                        keystep: 1 as libc::c_int,
57774                                        limit: 0 as libc::c_int,
57775                                    };
57776                                    init
57777                                },
57778                            },
57779                        };
57780                        init
57781                    },
57782                    {
57783                        let mut init = keySpec {
57784                            notes: 0 as *const libc::c_char,
57785                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
57786                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
57787                            begin_search_type: KSPEC_BS_INDEX,
57788                            bs: C2RustUnnamed_3 {
57789                                index: {
57790                                    let mut init = C2RustUnnamed_5 {
57791                                        pos: 2 as libc::c_int,
57792                                    };
57793                                    init
57794                                },
57795                            },
57796                            find_keys_type: KSPEC_FK_RANGE,
57797                            fk: C2RustUnnamed_0 {
57798                                range: {
57799                                    let mut init = C2RustUnnamed_2 {
57800                                        lastkey: -(1 as libc::c_int),
57801                                        keystep: 1 as libc::c_int,
57802                                        limit: 0 as libc::c_int,
57803                                    };
57804                                    init
57805                                },
57806                            },
57807                        };
57808                        init
57809                    },
57810                    keySpec {
57811                        notes: 0 as *const libc::c_char,
57812                        flags: 0,
57813                        begin_search_type: KSPEC_BS_INVALID,
57814                        bs: C2RustUnnamed_3 {
57815                            index: C2RustUnnamed_5 { pos: 0 },
57816                        },
57817                        find_keys_type: KSPEC_FK_INVALID,
57818                        fk: C2RustUnnamed_0 {
57819                            range: C2RustUnnamed_2 {
57820                                lastkey: 0,
57821                                keystep: 0,
57822                                limit: 0,
57823                            },
57824                        },
57825                    },
57826                    keySpec {
57827                        notes: 0 as *const libc::c_char,
57828                        flags: 0,
57829                        begin_search_type: KSPEC_BS_INVALID,
57830                        bs: C2RustUnnamed_3 {
57831                            index: C2RustUnnamed_5 { pos: 0 },
57832                        },
57833                        find_keys_type: KSPEC_FK_INVALID,
57834                        fk: C2RustUnnamed_0 {
57835                            range: C2RustUnnamed_2 {
57836                                lastkey: 0,
57837                                keystep: 0,
57838                                limit: 0,
57839                            },
57840                        },
57841                    },
57842                ],
57843                getkeys_proc: None,
57844                subcommands: 0 as *const redisCommand as *mut redisCommand,
57845                args: SINTERSTORE_Args.as_ptr() as *mut _,
57846                microseconds: 0,
57847                calls: 0,
57848                rejected_calls: 0,
57849                failed_calls: 0,
57850                id: 0,
57851                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57852                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57853                key_specs: 0 as *const keySpec as *mut keySpec,
57854                legacy_range_key_spec: keySpec {
57855                    notes: 0 as *const libc::c_char,
57856                    flags: 0,
57857                    begin_search_type: KSPEC_BS_INVALID,
57858                    bs: C2RustUnnamed_3 {
57859                        index: C2RustUnnamed_5 { pos: 0 },
57860                    },
57861                    find_keys_type: KSPEC_FK_INVALID,
57862                    fk: C2RustUnnamed_0 {
57863                        range: C2RustUnnamed_2 {
57864                            lastkey: 0,
57865                            keystep: 0,
57866                            limit: 0,
57867                        },
57868                    },
57869                },
57870                num_args: 0,
57871                num_history: 0,
57872                num_tips: 0,
57873                key_specs_num: 0,
57874                key_specs_max: 0,
57875                subcommands_dict: 0 as *const dict as *mut dict,
57876                parent: 0 as *const redisCommand as *mut redisCommand,
57877                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
57878            };
57879            init
57880        },
57881        {
57882            let mut init = redisCommand {
57883                declared_name: b"sismember\0" as *const u8 as *const libc::c_char,
57884                summary: b"Determine if a given value is a member of a set\0"
57885                    as *const u8 as *const libc::c_char,
57886                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
57887                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
57888                doc_flags: 0 as libc::c_int,
57889                replaced_by: 0 as *const libc::c_char,
57890                deprecated_since: 0 as *const libc::c_char,
57891                group: COMMAND_GROUP_SET,
57892                history: 0 as *const commandHistory as *mut commandHistory,
57893                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
57894                proc_0: Some(
57895                    sismemberCommand as unsafe extern "C" fn(*mut client) -> (),
57896                ),
57897                arity: 3 as libc::c_int,
57898                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
57899                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
57900                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
57901                    as uint64_t,
57902                key_specs_static: [
57903                    {
57904                        let mut init = keySpec {
57905                            notes: 0 as *const libc::c_char,
57906                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
57907                                as uint64_t,
57908                            begin_search_type: KSPEC_BS_INDEX,
57909                            bs: C2RustUnnamed_3 {
57910                                index: {
57911                                    let mut init = C2RustUnnamed_5 {
57912                                        pos: 1 as libc::c_int,
57913                                    };
57914                                    init
57915                                },
57916                            },
57917                            find_keys_type: KSPEC_FK_RANGE,
57918                            fk: C2RustUnnamed_0 {
57919                                range: {
57920                                    let mut init = C2RustUnnamed_2 {
57921                                        lastkey: 0 as libc::c_int,
57922                                        keystep: 1 as libc::c_int,
57923                                        limit: 0 as libc::c_int,
57924                                    };
57925                                    init
57926                                },
57927                            },
57928                        };
57929                        init
57930                    },
57931                    keySpec {
57932                        notes: 0 as *const libc::c_char,
57933                        flags: 0,
57934                        begin_search_type: KSPEC_BS_INVALID,
57935                        bs: C2RustUnnamed_3 {
57936                            index: C2RustUnnamed_5 { pos: 0 },
57937                        },
57938                        find_keys_type: KSPEC_FK_INVALID,
57939                        fk: C2RustUnnamed_0 {
57940                            range: C2RustUnnamed_2 {
57941                                lastkey: 0,
57942                                keystep: 0,
57943                                limit: 0,
57944                            },
57945                        },
57946                    },
57947                    keySpec {
57948                        notes: 0 as *const libc::c_char,
57949                        flags: 0,
57950                        begin_search_type: KSPEC_BS_INVALID,
57951                        bs: C2RustUnnamed_3 {
57952                            index: C2RustUnnamed_5 { pos: 0 },
57953                        },
57954                        find_keys_type: KSPEC_FK_INVALID,
57955                        fk: C2RustUnnamed_0 {
57956                            range: C2RustUnnamed_2 {
57957                                lastkey: 0,
57958                                keystep: 0,
57959                                limit: 0,
57960                            },
57961                        },
57962                    },
57963                    keySpec {
57964                        notes: 0 as *const libc::c_char,
57965                        flags: 0,
57966                        begin_search_type: KSPEC_BS_INVALID,
57967                        bs: C2RustUnnamed_3 {
57968                            index: C2RustUnnamed_5 { pos: 0 },
57969                        },
57970                        find_keys_type: KSPEC_FK_INVALID,
57971                        fk: C2RustUnnamed_0 {
57972                            range: C2RustUnnamed_2 {
57973                                lastkey: 0,
57974                                keystep: 0,
57975                                limit: 0,
57976                            },
57977                        },
57978                    },
57979                ],
57980                getkeys_proc: None,
57981                subcommands: 0 as *const redisCommand as *mut redisCommand,
57982                args: SISMEMBER_Args.as_ptr() as *mut _,
57983                microseconds: 0,
57984                calls: 0,
57985                rejected_calls: 0,
57986                failed_calls: 0,
57987                id: 0,
57988                fullname: 0 as *const libc::c_char as *mut libc::c_char,
57989                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
57990                key_specs: 0 as *const keySpec as *mut keySpec,
57991                legacy_range_key_spec: keySpec {
57992                    notes: 0 as *const libc::c_char,
57993                    flags: 0,
57994                    begin_search_type: KSPEC_BS_INVALID,
57995                    bs: C2RustUnnamed_3 {
57996                        index: C2RustUnnamed_5 { pos: 0 },
57997                    },
57998                    find_keys_type: KSPEC_FK_INVALID,
57999                    fk: C2RustUnnamed_0 {
58000                        range: C2RustUnnamed_2 {
58001                            lastkey: 0,
58002                            keystep: 0,
58003                            limit: 0,
58004                        },
58005                    },
58006                },
58007                num_args: 0,
58008                num_history: 0,
58009                num_tips: 0,
58010                key_specs_num: 0,
58011                key_specs_max: 0,
58012                subcommands_dict: 0 as *const dict as *mut dict,
58013                parent: 0 as *const redisCommand as *mut redisCommand,
58014                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58015            };
58016            init
58017        },
58018        {
58019            let mut init = redisCommand {
58020                declared_name: b"smembers\0" as *const u8 as *const libc::c_char,
58021                summary: b"Get all the members in a set\0" as *const u8
58022                    as *const libc::c_char,
58023                complexity: b"O(N) where N is the set cardinality.\0" as *const u8
58024                    as *const libc::c_char,
58025                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58026                doc_flags: 0 as libc::c_int,
58027                replaced_by: 0 as *const libc::c_char,
58028                deprecated_since: 0 as *const libc::c_char,
58029                group: COMMAND_GROUP_SET,
58030                history: 0 as *const commandHistory as *mut commandHistory,
58031                tips: SMEMBERS_tips.as_ptr() as *mut _,
58032                proc_0: Some(sinterCommand as unsafe extern "C" fn(*mut client) -> ()),
58033                arity: 2 as libc::c_int,
58034                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
58035                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58036                    as uint64_t,
58037                key_specs_static: [
58038                    {
58039                        let mut init = keySpec {
58040                            notes: 0 as *const libc::c_char,
58041                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58042                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
58043                            begin_search_type: KSPEC_BS_INDEX,
58044                            bs: C2RustUnnamed_3 {
58045                                index: {
58046                                    let mut init = C2RustUnnamed_5 {
58047                                        pos: 1 as libc::c_int,
58048                                    };
58049                                    init
58050                                },
58051                            },
58052                            find_keys_type: KSPEC_FK_RANGE,
58053                            fk: C2RustUnnamed_0 {
58054                                range: {
58055                                    let mut init = C2RustUnnamed_2 {
58056                                        lastkey: 0 as libc::c_int,
58057                                        keystep: 1 as libc::c_int,
58058                                        limit: 0 as libc::c_int,
58059                                    };
58060                                    init
58061                                },
58062                            },
58063                        };
58064                        init
58065                    },
58066                    keySpec {
58067                        notes: 0 as *const libc::c_char,
58068                        flags: 0,
58069                        begin_search_type: KSPEC_BS_INVALID,
58070                        bs: C2RustUnnamed_3 {
58071                            index: C2RustUnnamed_5 { pos: 0 },
58072                        },
58073                        find_keys_type: KSPEC_FK_INVALID,
58074                        fk: C2RustUnnamed_0 {
58075                            range: C2RustUnnamed_2 {
58076                                lastkey: 0,
58077                                keystep: 0,
58078                                limit: 0,
58079                            },
58080                        },
58081                    },
58082                    keySpec {
58083                        notes: 0 as *const libc::c_char,
58084                        flags: 0,
58085                        begin_search_type: KSPEC_BS_INVALID,
58086                        bs: C2RustUnnamed_3 {
58087                            index: C2RustUnnamed_5 { pos: 0 },
58088                        },
58089                        find_keys_type: KSPEC_FK_INVALID,
58090                        fk: C2RustUnnamed_0 {
58091                            range: C2RustUnnamed_2 {
58092                                lastkey: 0,
58093                                keystep: 0,
58094                                limit: 0,
58095                            },
58096                        },
58097                    },
58098                    keySpec {
58099                        notes: 0 as *const libc::c_char,
58100                        flags: 0,
58101                        begin_search_type: KSPEC_BS_INVALID,
58102                        bs: C2RustUnnamed_3 {
58103                            index: C2RustUnnamed_5 { pos: 0 },
58104                        },
58105                        find_keys_type: KSPEC_FK_INVALID,
58106                        fk: C2RustUnnamed_0 {
58107                            range: C2RustUnnamed_2 {
58108                                lastkey: 0,
58109                                keystep: 0,
58110                                limit: 0,
58111                            },
58112                        },
58113                    },
58114                ],
58115                getkeys_proc: None,
58116                subcommands: 0 as *const redisCommand as *mut redisCommand,
58117                args: SMEMBERS_Args.as_ptr() as *mut _,
58118                microseconds: 0,
58119                calls: 0,
58120                rejected_calls: 0,
58121                failed_calls: 0,
58122                id: 0,
58123                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58124                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58125                key_specs: 0 as *const keySpec as *mut keySpec,
58126                legacy_range_key_spec: keySpec {
58127                    notes: 0 as *const libc::c_char,
58128                    flags: 0,
58129                    begin_search_type: KSPEC_BS_INVALID,
58130                    bs: C2RustUnnamed_3 {
58131                        index: C2RustUnnamed_5 { pos: 0 },
58132                    },
58133                    find_keys_type: KSPEC_FK_INVALID,
58134                    fk: C2RustUnnamed_0 {
58135                        range: C2RustUnnamed_2 {
58136                            lastkey: 0,
58137                            keystep: 0,
58138                            limit: 0,
58139                        },
58140                    },
58141                },
58142                num_args: 0,
58143                num_history: 0,
58144                num_tips: 0,
58145                key_specs_num: 0,
58146                key_specs_max: 0,
58147                subcommands_dict: 0 as *const dict as *mut dict,
58148                parent: 0 as *const redisCommand as *mut redisCommand,
58149                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58150            };
58151            init
58152        },
58153        {
58154            let mut init = redisCommand {
58155                declared_name: b"smismember\0" as *const u8 as *const libc::c_char,
58156                summary: b"Returns the membership associated with the given elements for a set\0"
58157                    as *const u8 as *const libc::c_char,
58158                complexity: b"O(N) where N is the number of elements being checked for membership\0"
58159                    as *const u8 as *const libc::c_char,
58160                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
58161                doc_flags: 0 as libc::c_int,
58162                replaced_by: 0 as *const libc::c_char,
58163                deprecated_since: 0 as *const libc::c_char,
58164                group: COMMAND_GROUP_SET,
58165                history: 0 as *const commandHistory as *mut commandHistory,
58166                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
58167                proc_0: Some(
58168                    smismemberCommand as unsafe extern "C" fn(*mut client) -> (),
58169                ),
58170                arity: -(3 as libc::c_int),
58171                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
58172                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
58173                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58174                    as uint64_t,
58175                key_specs_static: [
58176                    {
58177                        let mut init = keySpec {
58178                            notes: 0 as *const libc::c_char,
58179                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58180                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
58181                            begin_search_type: KSPEC_BS_INDEX,
58182                            bs: C2RustUnnamed_3 {
58183                                index: {
58184                                    let mut init = C2RustUnnamed_5 {
58185                                        pos: 1 as libc::c_int,
58186                                    };
58187                                    init
58188                                },
58189                            },
58190                            find_keys_type: KSPEC_FK_RANGE,
58191                            fk: C2RustUnnamed_0 {
58192                                range: {
58193                                    let mut init = C2RustUnnamed_2 {
58194                                        lastkey: 0 as libc::c_int,
58195                                        keystep: 1 as libc::c_int,
58196                                        limit: 0 as libc::c_int,
58197                                    };
58198                                    init
58199                                },
58200                            },
58201                        };
58202                        init
58203                    },
58204                    keySpec {
58205                        notes: 0 as *const libc::c_char,
58206                        flags: 0,
58207                        begin_search_type: KSPEC_BS_INVALID,
58208                        bs: C2RustUnnamed_3 {
58209                            index: C2RustUnnamed_5 { pos: 0 },
58210                        },
58211                        find_keys_type: KSPEC_FK_INVALID,
58212                        fk: C2RustUnnamed_0 {
58213                            range: C2RustUnnamed_2 {
58214                                lastkey: 0,
58215                                keystep: 0,
58216                                limit: 0,
58217                            },
58218                        },
58219                    },
58220                    keySpec {
58221                        notes: 0 as *const libc::c_char,
58222                        flags: 0,
58223                        begin_search_type: KSPEC_BS_INVALID,
58224                        bs: C2RustUnnamed_3 {
58225                            index: C2RustUnnamed_5 { pos: 0 },
58226                        },
58227                        find_keys_type: KSPEC_FK_INVALID,
58228                        fk: C2RustUnnamed_0 {
58229                            range: C2RustUnnamed_2 {
58230                                lastkey: 0,
58231                                keystep: 0,
58232                                limit: 0,
58233                            },
58234                        },
58235                    },
58236                    keySpec {
58237                        notes: 0 as *const libc::c_char,
58238                        flags: 0,
58239                        begin_search_type: KSPEC_BS_INVALID,
58240                        bs: C2RustUnnamed_3 {
58241                            index: C2RustUnnamed_5 { pos: 0 },
58242                        },
58243                        find_keys_type: KSPEC_FK_INVALID,
58244                        fk: C2RustUnnamed_0 {
58245                            range: C2RustUnnamed_2 {
58246                                lastkey: 0,
58247                                keystep: 0,
58248                                limit: 0,
58249                            },
58250                        },
58251                    },
58252                ],
58253                getkeys_proc: None,
58254                subcommands: 0 as *const redisCommand as *mut redisCommand,
58255                args: SMISMEMBER_Args.as_ptr() as *mut _,
58256                microseconds: 0,
58257                calls: 0,
58258                rejected_calls: 0,
58259                failed_calls: 0,
58260                id: 0,
58261                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58262                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58263                key_specs: 0 as *const keySpec as *mut keySpec,
58264                legacy_range_key_spec: keySpec {
58265                    notes: 0 as *const libc::c_char,
58266                    flags: 0,
58267                    begin_search_type: KSPEC_BS_INVALID,
58268                    bs: C2RustUnnamed_3 {
58269                        index: C2RustUnnamed_5 { pos: 0 },
58270                    },
58271                    find_keys_type: KSPEC_FK_INVALID,
58272                    fk: C2RustUnnamed_0 {
58273                        range: C2RustUnnamed_2 {
58274                            lastkey: 0,
58275                            keystep: 0,
58276                            limit: 0,
58277                        },
58278                    },
58279                },
58280                num_args: 0,
58281                num_history: 0,
58282                num_tips: 0,
58283                key_specs_num: 0,
58284                key_specs_max: 0,
58285                subcommands_dict: 0 as *const dict as *mut dict,
58286                parent: 0 as *const redisCommand as *mut redisCommand,
58287                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58288            };
58289            init
58290        },
58291        {
58292            let mut init = redisCommand {
58293                declared_name: b"smove\0" as *const u8 as *const libc::c_char,
58294                summary: b"Move a member from one set to another\0" as *const u8
58295                    as *const libc::c_char,
58296                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
58297                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58298                doc_flags: 0 as libc::c_int,
58299                replaced_by: 0 as *const libc::c_char,
58300                deprecated_since: 0 as *const libc::c_char,
58301                group: COMMAND_GROUP_SET,
58302                history: 0 as *const commandHistory as *mut commandHistory,
58303                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
58304                proc_0: Some(smoveCommand as unsafe extern "C" fn(*mut client) -> ()),
58305                arity: 4 as libc::c_int,
58306                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58307                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
58308                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58309                    as uint64_t,
58310                key_specs_static: [
58311                    {
58312                        let mut init = keySpec {
58313                            notes: 0 as *const libc::c_char,
58314                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
58315                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
58316                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
58317                            begin_search_type: KSPEC_BS_INDEX,
58318                            bs: C2RustUnnamed_3 {
58319                                index: {
58320                                    let mut init = C2RustUnnamed_5 {
58321                                        pos: 1 as libc::c_int,
58322                                    };
58323                                    init
58324                                },
58325                            },
58326                            find_keys_type: KSPEC_FK_RANGE,
58327                            fk: C2RustUnnamed_0 {
58328                                range: {
58329                                    let mut init = C2RustUnnamed_2 {
58330                                        lastkey: 0 as libc::c_int,
58331                                        keystep: 1 as libc::c_int,
58332                                        limit: 0 as libc::c_int,
58333                                    };
58334                                    init
58335                                },
58336                            },
58337                        };
58338                        init
58339                    },
58340                    {
58341                        let mut init = keySpec {
58342                            notes: 0 as *const libc::c_char,
58343                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
58344                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
58345                            begin_search_type: KSPEC_BS_INDEX,
58346                            bs: C2RustUnnamed_3 {
58347                                index: {
58348                                    let mut init = C2RustUnnamed_5 {
58349                                        pos: 2 as libc::c_int,
58350                                    };
58351                                    init
58352                                },
58353                            },
58354                            find_keys_type: KSPEC_FK_RANGE,
58355                            fk: C2RustUnnamed_0 {
58356                                range: {
58357                                    let mut init = C2RustUnnamed_2 {
58358                                        lastkey: 0 as libc::c_int,
58359                                        keystep: 1 as libc::c_int,
58360                                        limit: 0 as libc::c_int,
58361                                    };
58362                                    init
58363                                },
58364                            },
58365                        };
58366                        init
58367                    },
58368                    keySpec {
58369                        notes: 0 as *const libc::c_char,
58370                        flags: 0,
58371                        begin_search_type: KSPEC_BS_INVALID,
58372                        bs: C2RustUnnamed_3 {
58373                            index: C2RustUnnamed_5 { pos: 0 },
58374                        },
58375                        find_keys_type: KSPEC_FK_INVALID,
58376                        fk: C2RustUnnamed_0 {
58377                            range: C2RustUnnamed_2 {
58378                                lastkey: 0,
58379                                keystep: 0,
58380                                limit: 0,
58381                            },
58382                        },
58383                    },
58384                    keySpec {
58385                        notes: 0 as *const libc::c_char,
58386                        flags: 0,
58387                        begin_search_type: KSPEC_BS_INVALID,
58388                        bs: C2RustUnnamed_3 {
58389                            index: C2RustUnnamed_5 { pos: 0 },
58390                        },
58391                        find_keys_type: KSPEC_FK_INVALID,
58392                        fk: C2RustUnnamed_0 {
58393                            range: C2RustUnnamed_2 {
58394                                lastkey: 0,
58395                                keystep: 0,
58396                                limit: 0,
58397                            },
58398                        },
58399                    },
58400                ],
58401                getkeys_proc: None,
58402                subcommands: 0 as *const redisCommand as *mut redisCommand,
58403                args: SMOVE_Args.as_ptr() as *mut _,
58404                microseconds: 0,
58405                calls: 0,
58406                rejected_calls: 0,
58407                failed_calls: 0,
58408                id: 0,
58409                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58410                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58411                key_specs: 0 as *const keySpec as *mut keySpec,
58412                legacy_range_key_spec: keySpec {
58413                    notes: 0 as *const libc::c_char,
58414                    flags: 0,
58415                    begin_search_type: KSPEC_BS_INVALID,
58416                    bs: C2RustUnnamed_3 {
58417                        index: C2RustUnnamed_5 { pos: 0 },
58418                    },
58419                    find_keys_type: KSPEC_FK_INVALID,
58420                    fk: C2RustUnnamed_0 {
58421                        range: C2RustUnnamed_2 {
58422                            lastkey: 0,
58423                            keystep: 0,
58424                            limit: 0,
58425                        },
58426                    },
58427                },
58428                num_args: 0,
58429                num_history: 0,
58430                num_tips: 0,
58431                key_specs_num: 0,
58432                key_specs_max: 0,
58433                subcommands_dict: 0 as *const dict as *mut dict,
58434                parent: 0 as *const redisCommand as *mut redisCommand,
58435                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58436            };
58437            init
58438        },
58439        {
58440            let mut init = redisCommand {
58441                declared_name: b"spop\0" as *const u8 as *const libc::c_char,
58442                summary: b"Remove and return one or multiple random members from a set\0"
58443                    as *const u8 as *const libc::c_char,
58444                complexity: b"Without the count argument O(1), otherwise O(N) where N is the value of the passed count.\0"
58445                    as *const u8 as *const libc::c_char,
58446                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58447                doc_flags: 0 as libc::c_int,
58448                replaced_by: 0 as *const libc::c_char,
58449                deprecated_since: 0 as *const libc::c_char,
58450                group: COMMAND_GROUP_SET,
58451                history: SPOP_History.as_ptr() as *mut _,
58452                tips: SPOP_tips.as_ptr() as *mut _,
58453                proc_0: Some(spopCommand as unsafe extern "C" fn(*mut client) -> ()),
58454                arity: -(2 as libc::c_int),
58455                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58456                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
58457                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58458                    as uint64_t,
58459                key_specs_static: [
58460                    {
58461                        let mut init = keySpec {
58462                            notes: 0 as *const libc::c_char,
58463                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
58464                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
58465                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
58466                            begin_search_type: KSPEC_BS_INDEX,
58467                            bs: C2RustUnnamed_3 {
58468                                index: {
58469                                    let mut init = C2RustUnnamed_5 {
58470                                        pos: 1 as libc::c_int,
58471                                    };
58472                                    init
58473                                },
58474                            },
58475                            find_keys_type: KSPEC_FK_RANGE,
58476                            fk: C2RustUnnamed_0 {
58477                                range: {
58478                                    let mut init = C2RustUnnamed_2 {
58479                                        lastkey: 0 as libc::c_int,
58480                                        keystep: 1 as libc::c_int,
58481                                        limit: 0 as libc::c_int,
58482                                    };
58483                                    init
58484                                },
58485                            },
58486                        };
58487                        init
58488                    },
58489                    keySpec {
58490                        notes: 0 as *const libc::c_char,
58491                        flags: 0,
58492                        begin_search_type: KSPEC_BS_INVALID,
58493                        bs: C2RustUnnamed_3 {
58494                            index: C2RustUnnamed_5 { pos: 0 },
58495                        },
58496                        find_keys_type: KSPEC_FK_INVALID,
58497                        fk: C2RustUnnamed_0 {
58498                            range: C2RustUnnamed_2 {
58499                                lastkey: 0,
58500                                keystep: 0,
58501                                limit: 0,
58502                            },
58503                        },
58504                    },
58505                    keySpec {
58506                        notes: 0 as *const libc::c_char,
58507                        flags: 0,
58508                        begin_search_type: KSPEC_BS_INVALID,
58509                        bs: C2RustUnnamed_3 {
58510                            index: C2RustUnnamed_5 { pos: 0 },
58511                        },
58512                        find_keys_type: KSPEC_FK_INVALID,
58513                        fk: C2RustUnnamed_0 {
58514                            range: C2RustUnnamed_2 {
58515                                lastkey: 0,
58516                                keystep: 0,
58517                                limit: 0,
58518                            },
58519                        },
58520                    },
58521                    keySpec {
58522                        notes: 0 as *const libc::c_char,
58523                        flags: 0,
58524                        begin_search_type: KSPEC_BS_INVALID,
58525                        bs: C2RustUnnamed_3 {
58526                            index: C2RustUnnamed_5 { pos: 0 },
58527                        },
58528                        find_keys_type: KSPEC_FK_INVALID,
58529                        fk: C2RustUnnamed_0 {
58530                            range: C2RustUnnamed_2 {
58531                                lastkey: 0,
58532                                keystep: 0,
58533                                limit: 0,
58534                            },
58535                        },
58536                    },
58537                ],
58538                getkeys_proc: None,
58539                subcommands: 0 as *const redisCommand as *mut redisCommand,
58540                args: SPOP_Args.as_ptr() as *mut _,
58541                microseconds: 0,
58542                calls: 0,
58543                rejected_calls: 0,
58544                failed_calls: 0,
58545                id: 0,
58546                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58547                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58548                key_specs: 0 as *const keySpec as *mut keySpec,
58549                legacy_range_key_spec: keySpec {
58550                    notes: 0 as *const libc::c_char,
58551                    flags: 0,
58552                    begin_search_type: KSPEC_BS_INVALID,
58553                    bs: C2RustUnnamed_3 {
58554                        index: C2RustUnnamed_5 { pos: 0 },
58555                    },
58556                    find_keys_type: KSPEC_FK_INVALID,
58557                    fk: C2RustUnnamed_0 {
58558                        range: C2RustUnnamed_2 {
58559                            lastkey: 0,
58560                            keystep: 0,
58561                            limit: 0,
58562                        },
58563                    },
58564                },
58565                num_args: 0,
58566                num_history: 0,
58567                num_tips: 0,
58568                key_specs_num: 0,
58569                key_specs_max: 0,
58570                subcommands_dict: 0 as *const dict as *mut dict,
58571                parent: 0 as *const redisCommand as *mut redisCommand,
58572                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58573            };
58574            init
58575        },
58576        {
58577            let mut init = redisCommand {
58578                declared_name: b"srandmember\0" as *const u8 as *const libc::c_char,
58579                summary: b"Get one or multiple random members from a set\0" as *const u8
58580                    as *const libc::c_char,
58581                complexity: b"Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.\0"
58582                    as *const u8 as *const libc::c_char,
58583                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58584                doc_flags: 0 as libc::c_int,
58585                replaced_by: 0 as *const libc::c_char,
58586                deprecated_since: 0 as *const libc::c_char,
58587                group: COMMAND_GROUP_SET,
58588                history: SRANDMEMBER_History.as_ptr() as *mut _,
58589                tips: SRANDMEMBER_tips.as_ptr() as *mut _,
58590                proc_0: Some(
58591                    srandmemberCommand as unsafe extern "C" fn(*mut client) -> (),
58592                ),
58593                arity: -(2 as libc::c_int),
58594                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
58595                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58596                    as uint64_t,
58597                key_specs_static: [
58598                    {
58599                        let mut init = keySpec {
58600                            notes: 0 as *const libc::c_char,
58601                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58602                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
58603                            begin_search_type: KSPEC_BS_INDEX,
58604                            bs: C2RustUnnamed_3 {
58605                                index: {
58606                                    let mut init = C2RustUnnamed_5 {
58607                                        pos: 1 as libc::c_int,
58608                                    };
58609                                    init
58610                                },
58611                            },
58612                            find_keys_type: KSPEC_FK_RANGE,
58613                            fk: C2RustUnnamed_0 {
58614                                range: {
58615                                    let mut init = C2RustUnnamed_2 {
58616                                        lastkey: 0 as libc::c_int,
58617                                        keystep: 1 as libc::c_int,
58618                                        limit: 0 as libc::c_int,
58619                                    };
58620                                    init
58621                                },
58622                            },
58623                        };
58624                        init
58625                    },
58626                    keySpec {
58627                        notes: 0 as *const libc::c_char,
58628                        flags: 0,
58629                        begin_search_type: KSPEC_BS_INVALID,
58630                        bs: C2RustUnnamed_3 {
58631                            index: C2RustUnnamed_5 { pos: 0 },
58632                        },
58633                        find_keys_type: KSPEC_FK_INVALID,
58634                        fk: C2RustUnnamed_0 {
58635                            range: C2RustUnnamed_2 {
58636                                lastkey: 0,
58637                                keystep: 0,
58638                                limit: 0,
58639                            },
58640                        },
58641                    },
58642                    keySpec {
58643                        notes: 0 as *const libc::c_char,
58644                        flags: 0,
58645                        begin_search_type: KSPEC_BS_INVALID,
58646                        bs: C2RustUnnamed_3 {
58647                            index: C2RustUnnamed_5 { pos: 0 },
58648                        },
58649                        find_keys_type: KSPEC_FK_INVALID,
58650                        fk: C2RustUnnamed_0 {
58651                            range: C2RustUnnamed_2 {
58652                                lastkey: 0,
58653                                keystep: 0,
58654                                limit: 0,
58655                            },
58656                        },
58657                    },
58658                    keySpec {
58659                        notes: 0 as *const libc::c_char,
58660                        flags: 0,
58661                        begin_search_type: KSPEC_BS_INVALID,
58662                        bs: C2RustUnnamed_3 {
58663                            index: C2RustUnnamed_5 { pos: 0 },
58664                        },
58665                        find_keys_type: KSPEC_FK_INVALID,
58666                        fk: C2RustUnnamed_0 {
58667                            range: C2RustUnnamed_2 {
58668                                lastkey: 0,
58669                                keystep: 0,
58670                                limit: 0,
58671                            },
58672                        },
58673                    },
58674                ],
58675                getkeys_proc: None,
58676                subcommands: 0 as *const redisCommand as *mut redisCommand,
58677                args: SRANDMEMBER_Args.as_ptr() as *mut _,
58678                microseconds: 0,
58679                calls: 0,
58680                rejected_calls: 0,
58681                failed_calls: 0,
58682                id: 0,
58683                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58684                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58685                key_specs: 0 as *const keySpec as *mut keySpec,
58686                legacy_range_key_spec: keySpec {
58687                    notes: 0 as *const libc::c_char,
58688                    flags: 0,
58689                    begin_search_type: KSPEC_BS_INVALID,
58690                    bs: C2RustUnnamed_3 {
58691                        index: C2RustUnnamed_5 { pos: 0 },
58692                    },
58693                    find_keys_type: KSPEC_FK_INVALID,
58694                    fk: C2RustUnnamed_0 {
58695                        range: C2RustUnnamed_2 {
58696                            lastkey: 0,
58697                            keystep: 0,
58698                            limit: 0,
58699                        },
58700                    },
58701                },
58702                num_args: 0,
58703                num_history: 0,
58704                num_tips: 0,
58705                key_specs_num: 0,
58706                key_specs_max: 0,
58707                subcommands_dict: 0 as *const dict as *mut dict,
58708                parent: 0 as *const redisCommand as *mut redisCommand,
58709                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58710            };
58711            init
58712        },
58713        {
58714            let mut init = redisCommand {
58715                declared_name: b"srem\0" as *const u8 as *const libc::c_char,
58716                summary: b"Remove one or more members from a set\0" as *const u8
58717                    as *const libc::c_char,
58718                complexity: b"O(N) where N is the number of members to be removed.\0"
58719                    as *const u8 as *const libc::c_char,
58720                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58721                doc_flags: 0 as libc::c_int,
58722                replaced_by: 0 as *const libc::c_char,
58723                deprecated_since: 0 as *const libc::c_char,
58724                group: COMMAND_GROUP_SET,
58725                history: SREM_History.as_ptr() as *mut _,
58726                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
58727                proc_0: Some(sremCommand as unsafe extern "C" fn(*mut client) -> ()),
58728                arity: -(3 as libc::c_int),
58729                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58730                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
58731                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58732                    as uint64_t,
58733                key_specs_static: [
58734                    {
58735                        let mut init = keySpec {
58736                            notes: 0 as *const libc::c_char,
58737                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
58738                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
58739                            begin_search_type: KSPEC_BS_INDEX,
58740                            bs: C2RustUnnamed_3 {
58741                                index: {
58742                                    let mut init = C2RustUnnamed_5 {
58743                                        pos: 1 as libc::c_int,
58744                                    };
58745                                    init
58746                                },
58747                            },
58748                            find_keys_type: KSPEC_FK_RANGE,
58749                            fk: C2RustUnnamed_0 {
58750                                range: {
58751                                    let mut init = C2RustUnnamed_2 {
58752                                        lastkey: 0 as libc::c_int,
58753                                        keystep: 1 as libc::c_int,
58754                                        limit: 0 as libc::c_int,
58755                                    };
58756                                    init
58757                                },
58758                            },
58759                        };
58760                        init
58761                    },
58762                    keySpec {
58763                        notes: 0 as *const libc::c_char,
58764                        flags: 0,
58765                        begin_search_type: KSPEC_BS_INVALID,
58766                        bs: C2RustUnnamed_3 {
58767                            index: C2RustUnnamed_5 { pos: 0 },
58768                        },
58769                        find_keys_type: KSPEC_FK_INVALID,
58770                        fk: C2RustUnnamed_0 {
58771                            range: C2RustUnnamed_2 {
58772                                lastkey: 0,
58773                                keystep: 0,
58774                                limit: 0,
58775                            },
58776                        },
58777                    },
58778                    keySpec {
58779                        notes: 0 as *const libc::c_char,
58780                        flags: 0,
58781                        begin_search_type: KSPEC_BS_INVALID,
58782                        bs: C2RustUnnamed_3 {
58783                            index: C2RustUnnamed_5 { pos: 0 },
58784                        },
58785                        find_keys_type: KSPEC_FK_INVALID,
58786                        fk: C2RustUnnamed_0 {
58787                            range: C2RustUnnamed_2 {
58788                                lastkey: 0,
58789                                keystep: 0,
58790                                limit: 0,
58791                            },
58792                        },
58793                    },
58794                    keySpec {
58795                        notes: 0 as *const libc::c_char,
58796                        flags: 0,
58797                        begin_search_type: KSPEC_BS_INVALID,
58798                        bs: C2RustUnnamed_3 {
58799                            index: C2RustUnnamed_5 { pos: 0 },
58800                        },
58801                        find_keys_type: KSPEC_FK_INVALID,
58802                        fk: C2RustUnnamed_0 {
58803                            range: C2RustUnnamed_2 {
58804                                lastkey: 0,
58805                                keystep: 0,
58806                                limit: 0,
58807                            },
58808                        },
58809                    },
58810                ],
58811                getkeys_proc: None,
58812                subcommands: 0 as *const redisCommand as *mut redisCommand,
58813                args: SREM_Args.as_ptr() as *mut _,
58814                microseconds: 0,
58815                calls: 0,
58816                rejected_calls: 0,
58817                failed_calls: 0,
58818                id: 0,
58819                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58820                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58821                key_specs: 0 as *const keySpec as *mut keySpec,
58822                legacy_range_key_spec: keySpec {
58823                    notes: 0 as *const libc::c_char,
58824                    flags: 0,
58825                    begin_search_type: KSPEC_BS_INVALID,
58826                    bs: C2RustUnnamed_3 {
58827                        index: C2RustUnnamed_5 { pos: 0 },
58828                    },
58829                    find_keys_type: KSPEC_FK_INVALID,
58830                    fk: C2RustUnnamed_0 {
58831                        range: C2RustUnnamed_2 {
58832                            lastkey: 0,
58833                            keystep: 0,
58834                            limit: 0,
58835                        },
58836                    },
58837                },
58838                num_args: 0,
58839                num_history: 0,
58840                num_tips: 0,
58841                key_specs_num: 0,
58842                key_specs_max: 0,
58843                subcommands_dict: 0 as *const dict as *mut dict,
58844                parent: 0 as *const redisCommand as *mut redisCommand,
58845                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58846            };
58847            init
58848        },
58849        {
58850            let mut init = redisCommand {
58851                declared_name: b"sscan\0" as *const u8 as *const libc::c_char,
58852                summary: b"Incrementally iterate Set elements\0" as *const u8
58853                    as *const libc::c_char,
58854                complexity: b"O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..\0"
58855                    as *const u8 as *const libc::c_char,
58856                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
58857                doc_flags: 0 as libc::c_int,
58858                replaced_by: 0 as *const libc::c_char,
58859                deprecated_since: 0 as *const libc::c_char,
58860                group: COMMAND_GROUP_SET,
58861                history: 0 as *const commandHistory as *mut commandHistory,
58862                tips: SSCAN_tips.as_ptr() as *mut _,
58863                proc_0: Some(sscanCommand as unsafe extern "C" fn(*mut client) -> ()),
58864                arity: -(3 as libc::c_int),
58865                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
58866                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
58867                    as uint64_t,
58868                key_specs_static: [
58869                    {
58870                        let mut init = keySpec {
58871                            notes: 0 as *const libc::c_char,
58872                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
58873                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
58874                            begin_search_type: KSPEC_BS_INDEX,
58875                            bs: C2RustUnnamed_3 {
58876                                index: {
58877                                    let mut init = C2RustUnnamed_5 {
58878                                        pos: 1 as libc::c_int,
58879                                    };
58880                                    init
58881                                },
58882                            },
58883                            find_keys_type: KSPEC_FK_RANGE,
58884                            fk: C2RustUnnamed_0 {
58885                                range: {
58886                                    let mut init = C2RustUnnamed_2 {
58887                                        lastkey: 0 as libc::c_int,
58888                                        keystep: 1 as libc::c_int,
58889                                        limit: 0 as libc::c_int,
58890                                    };
58891                                    init
58892                                },
58893                            },
58894                        };
58895                        init
58896                    },
58897                    keySpec {
58898                        notes: 0 as *const libc::c_char,
58899                        flags: 0,
58900                        begin_search_type: KSPEC_BS_INVALID,
58901                        bs: C2RustUnnamed_3 {
58902                            index: C2RustUnnamed_5 { pos: 0 },
58903                        },
58904                        find_keys_type: KSPEC_FK_INVALID,
58905                        fk: C2RustUnnamed_0 {
58906                            range: C2RustUnnamed_2 {
58907                                lastkey: 0,
58908                                keystep: 0,
58909                                limit: 0,
58910                            },
58911                        },
58912                    },
58913                    keySpec {
58914                        notes: 0 as *const libc::c_char,
58915                        flags: 0,
58916                        begin_search_type: KSPEC_BS_INVALID,
58917                        bs: C2RustUnnamed_3 {
58918                            index: C2RustUnnamed_5 { pos: 0 },
58919                        },
58920                        find_keys_type: KSPEC_FK_INVALID,
58921                        fk: C2RustUnnamed_0 {
58922                            range: C2RustUnnamed_2 {
58923                                lastkey: 0,
58924                                keystep: 0,
58925                                limit: 0,
58926                            },
58927                        },
58928                    },
58929                    keySpec {
58930                        notes: 0 as *const libc::c_char,
58931                        flags: 0,
58932                        begin_search_type: KSPEC_BS_INVALID,
58933                        bs: C2RustUnnamed_3 {
58934                            index: C2RustUnnamed_5 { pos: 0 },
58935                        },
58936                        find_keys_type: KSPEC_FK_INVALID,
58937                        fk: C2RustUnnamed_0 {
58938                            range: C2RustUnnamed_2 {
58939                                lastkey: 0,
58940                                keystep: 0,
58941                                limit: 0,
58942                            },
58943                        },
58944                    },
58945                ],
58946                getkeys_proc: None,
58947                subcommands: 0 as *const redisCommand as *mut redisCommand,
58948                args: SSCAN_Args.as_ptr() as *mut _,
58949                microseconds: 0,
58950                calls: 0,
58951                rejected_calls: 0,
58952                failed_calls: 0,
58953                id: 0,
58954                fullname: 0 as *const libc::c_char as *mut libc::c_char,
58955                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
58956                key_specs: 0 as *const keySpec as *mut keySpec,
58957                legacy_range_key_spec: keySpec {
58958                    notes: 0 as *const libc::c_char,
58959                    flags: 0,
58960                    begin_search_type: KSPEC_BS_INVALID,
58961                    bs: C2RustUnnamed_3 {
58962                        index: C2RustUnnamed_5 { pos: 0 },
58963                    },
58964                    find_keys_type: KSPEC_FK_INVALID,
58965                    fk: C2RustUnnamed_0 {
58966                        range: C2RustUnnamed_2 {
58967                            lastkey: 0,
58968                            keystep: 0,
58969                            limit: 0,
58970                        },
58971                    },
58972                },
58973                num_args: 0,
58974                num_history: 0,
58975                num_tips: 0,
58976                key_specs_num: 0,
58977                key_specs_max: 0,
58978                subcommands_dict: 0 as *const dict as *mut dict,
58979                parent: 0 as *const redisCommand as *mut redisCommand,
58980                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
58981            };
58982            init
58983        },
58984        {
58985            let mut init = redisCommand {
58986                declared_name: b"sunion\0" as *const u8 as *const libc::c_char,
58987                summary: b"Add multiple sets\0" as *const u8 as *const libc::c_char,
58988                complexity: b"O(N) where N is the total number of elements in all given sets.\0"
58989                    as *const u8 as *const libc::c_char,
58990                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
58991                doc_flags: 0 as libc::c_int,
58992                replaced_by: 0 as *const libc::c_char,
58993                deprecated_since: 0 as *const libc::c_char,
58994                group: COMMAND_GROUP_SET,
58995                history: 0 as *const commandHistory as *mut commandHistory,
58996                tips: SUNION_tips.as_ptr() as *mut _,
58997                proc_0: Some(sunionCommand as unsafe extern "C" fn(*mut client) -> ()),
58998                arity: -(2 as libc::c_int),
58999                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
59000                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
59001                    as uint64_t,
59002                key_specs_static: [
59003                    {
59004                        let mut init = keySpec {
59005                            notes: 0 as *const libc::c_char,
59006                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59007                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
59008                            begin_search_type: KSPEC_BS_INDEX,
59009                            bs: C2RustUnnamed_3 {
59010                                index: {
59011                                    let mut init = C2RustUnnamed_5 {
59012                                        pos: 1 as libc::c_int,
59013                                    };
59014                                    init
59015                                },
59016                            },
59017                            find_keys_type: KSPEC_FK_RANGE,
59018                            fk: C2RustUnnamed_0 {
59019                                range: {
59020                                    let mut init = C2RustUnnamed_2 {
59021                                        lastkey: -(1 as libc::c_int),
59022                                        keystep: 1 as libc::c_int,
59023                                        limit: 0 as libc::c_int,
59024                                    };
59025                                    init
59026                                },
59027                            },
59028                        };
59029                        init
59030                    },
59031                    keySpec {
59032                        notes: 0 as *const libc::c_char,
59033                        flags: 0,
59034                        begin_search_type: KSPEC_BS_INVALID,
59035                        bs: C2RustUnnamed_3 {
59036                            index: C2RustUnnamed_5 { pos: 0 },
59037                        },
59038                        find_keys_type: KSPEC_FK_INVALID,
59039                        fk: C2RustUnnamed_0 {
59040                            range: C2RustUnnamed_2 {
59041                                lastkey: 0,
59042                                keystep: 0,
59043                                limit: 0,
59044                            },
59045                        },
59046                    },
59047                    keySpec {
59048                        notes: 0 as *const libc::c_char,
59049                        flags: 0,
59050                        begin_search_type: KSPEC_BS_INVALID,
59051                        bs: C2RustUnnamed_3 {
59052                            index: C2RustUnnamed_5 { pos: 0 },
59053                        },
59054                        find_keys_type: KSPEC_FK_INVALID,
59055                        fk: C2RustUnnamed_0 {
59056                            range: C2RustUnnamed_2 {
59057                                lastkey: 0,
59058                                keystep: 0,
59059                                limit: 0,
59060                            },
59061                        },
59062                    },
59063                    keySpec {
59064                        notes: 0 as *const libc::c_char,
59065                        flags: 0,
59066                        begin_search_type: KSPEC_BS_INVALID,
59067                        bs: C2RustUnnamed_3 {
59068                            index: C2RustUnnamed_5 { pos: 0 },
59069                        },
59070                        find_keys_type: KSPEC_FK_INVALID,
59071                        fk: C2RustUnnamed_0 {
59072                            range: C2RustUnnamed_2 {
59073                                lastkey: 0,
59074                                keystep: 0,
59075                                limit: 0,
59076                            },
59077                        },
59078                    },
59079                ],
59080                getkeys_proc: None,
59081                subcommands: 0 as *const redisCommand as *mut redisCommand,
59082                args: SUNION_Args.as_ptr() as *mut _,
59083                microseconds: 0,
59084                calls: 0,
59085                rejected_calls: 0,
59086                failed_calls: 0,
59087                id: 0,
59088                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59089                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59090                key_specs: 0 as *const keySpec as *mut keySpec,
59091                legacy_range_key_spec: keySpec {
59092                    notes: 0 as *const libc::c_char,
59093                    flags: 0,
59094                    begin_search_type: KSPEC_BS_INVALID,
59095                    bs: C2RustUnnamed_3 {
59096                        index: C2RustUnnamed_5 { pos: 0 },
59097                    },
59098                    find_keys_type: KSPEC_FK_INVALID,
59099                    fk: C2RustUnnamed_0 {
59100                        range: C2RustUnnamed_2 {
59101                            lastkey: 0,
59102                            keystep: 0,
59103                            limit: 0,
59104                        },
59105                    },
59106                },
59107                num_args: 0,
59108                num_history: 0,
59109                num_tips: 0,
59110                key_specs_num: 0,
59111                key_specs_max: 0,
59112                subcommands_dict: 0 as *const dict as *mut dict,
59113                parent: 0 as *const redisCommand as *mut redisCommand,
59114                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59115            };
59116            init
59117        },
59118        {
59119            let mut init = redisCommand {
59120                declared_name: b"sunionstore\0" as *const u8 as *const libc::c_char,
59121                summary: b"Add multiple sets and store the resulting set in a key\0"
59122                    as *const u8 as *const libc::c_char,
59123                complexity: b"O(N) where N is the total number of elements in all given sets.\0"
59124                    as *const u8 as *const libc::c_char,
59125                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
59126                doc_flags: 0 as libc::c_int,
59127                replaced_by: 0 as *const libc::c_char,
59128                deprecated_since: 0 as *const libc::c_char,
59129                group: COMMAND_GROUP_SET,
59130                history: 0 as *const commandHistory as *mut commandHistory,
59131                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59132                proc_0: Some(
59133                    sunionstoreCommand as unsafe extern "C" fn(*mut client) -> (),
59134                ),
59135                arity: -(3 as libc::c_int),
59136                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59137                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
59138                acl_categories: ((1 as libc::c_ulonglong) << 3 as libc::c_int)
59139                    as uint64_t,
59140                key_specs_static: [
59141                    {
59142                        let mut init = keySpec {
59143                            notes: 0 as *const libc::c_char,
59144                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
59145                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
59146                            begin_search_type: KSPEC_BS_INDEX,
59147                            bs: C2RustUnnamed_3 {
59148                                index: {
59149                                    let mut init = C2RustUnnamed_5 {
59150                                        pos: 1 as libc::c_int,
59151                                    };
59152                                    init
59153                                },
59154                            },
59155                            find_keys_type: KSPEC_FK_RANGE,
59156                            fk: C2RustUnnamed_0 {
59157                                range: {
59158                                    let mut init = C2RustUnnamed_2 {
59159                                        lastkey: 0 as libc::c_int,
59160                                        keystep: 1 as libc::c_int,
59161                                        limit: 0 as libc::c_int,
59162                                    };
59163                                    init
59164                                },
59165                            },
59166                        };
59167                        init
59168                    },
59169                    {
59170                        let mut init = keySpec {
59171                            notes: 0 as *const libc::c_char,
59172                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59173                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
59174                            begin_search_type: KSPEC_BS_INDEX,
59175                            bs: C2RustUnnamed_3 {
59176                                index: {
59177                                    let mut init = C2RustUnnamed_5 {
59178                                        pos: 2 as libc::c_int,
59179                                    };
59180                                    init
59181                                },
59182                            },
59183                            find_keys_type: KSPEC_FK_RANGE,
59184                            fk: C2RustUnnamed_0 {
59185                                range: {
59186                                    let mut init = C2RustUnnamed_2 {
59187                                        lastkey: -(1 as libc::c_int),
59188                                        keystep: 1 as libc::c_int,
59189                                        limit: 0 as libc::c_int,
59190                                    };
59191                                    init
59192                                },
59193                            },
59194                        };
59195                        init
59196                    },
59197                    keySpec {
59198                        notes: 0 as *const libc::c_char,
59199                        flags: 0,
59200                        begin_search_type: KSPEC_BS_INVALID,
59201                        bs: C2RustUnnamed_3 {
59202                            index: C2RustUnnamed_5 { pos: 0 },
59203                        },
59204                        find_keys_type: KSPEC_FK_INVALID,
59205                        fk: C2RustUnnamed_0 {
59206                            range: C2RustUnnamed_2 {
59207                                lastkey: 0,
59208                                keystep: 0,
59209                                limit: 0,
59210                            },
59211                        },
59212                    },
59213                    keySpec {
59214                        notes: 0 as *const libc::c_char,
59215                        flags: 0,
59216                        begin_search_type: KSPEC_BS_INVALID,
59217                        bs: C2RustUnnamed_3 {
59218                            index: C2RustUnnamed_5 { pos: 0 },
59219                        },
59220                        find_keys_type: KSPEC_FK_INVALID,
59221                        fk: C2RustUnnamed_0 {
59222                            range: C2RustUnnamed_2 {
59223                                lastkey: 0,
59224                                keystep: 0,
59225                                limit: 0,
59226                            },
59227                        },
59228                    },
59229                ],
59230                getkeys_proc: None,
59231                subcommands: 0 as *const redisCommand as *mut redisCommand,
59232                args: SUNIONSTORE_Args.as_ptr() as *mut _,
59233                microseconds: 0,
59234                calls: 0,
59235                rejected_calls: 0,
59236                failed_calls: 0,
59237                id: 0,
59238                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59239                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59240                key_specs: 0 as *const keySpec as *mut keySpec,
59241                legacy_range_key_spec: keySpec {
59242                    notes: 0 as *const libc::c_char,
59243                    flags: 0,
59244                    begin_search_type: KSPEC_BS_INVALID,
59245                    bs: C2RustUnnamed_3 {
59246                        index: C2RustUnnamed_5 { pos: 0 },
59247                    },
59248                    find_keys_type: KSPEC_FK_INVALID,
59249                    fk: C2RustUnnamed_0 {
59250                        range: C2RustUnnamed_2 {
59251                            lastkey: 0,
59252                            keystep: 0,
59253                            limit: 0,
59254                        },
59255                    },
59256                },
59257                num_args: 0,
59258                num_history: 0,
59259                num_tips: 0,
59260                key_specs_num: 0,
59261                key_specs_max: 0,
59262                subcommands_dict: 0 as *const dict as *mut dict,
59263                parent: 0 as *const redisCommand as *mut redisCommand,
59264                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59265            };
59266            init
59267        },
59268        {
59269            let mut init = redisCommand {
59270                declared_name: b"bzmpop\0" as *const u8 as *const libc::c_char,
59271                summary: b"Remove and return members with scores in a sorted set or block until one is available\0"
59272                    as *const u8 as *const libc::c_char,
59273                complexity: b"O(K) + O(M*log(N)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.\0"
59274                    as *const u8 as *const libc::c_char,
59275                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
59276                doc_flags: 0 as libc::c_int,
59277                replaced_by: 0 as *const libc::c_char,
59278                deprecated_since: 0 as *const libc::c_char,
59279                group: COMMAND_GROUP_SORTED_SET,
59280                history: 0 as *const commandHistory as *mut commandHistory,
59281                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59282                proc_0: Some(bzmpopCommand as unsafe extern "C" fn(*mut client) -> ()),
59283                arity: -(5 as libc::c_int),
59284                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59285                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
59286                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59287                    as uint64_t,
59288                key_specs_static: [
59289                    {
59290                        let mut init = keySpec {
59291                            notes: 0 as *const libc::c_char,
59292                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59293                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
59294                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
59295                            begin_search_type: KSPEC_BS_INDEX,
59296                            bs: C2RustUnnamed_3 {
59297                                index: {
59298                                    let mut init = C2RustUnnamed_5 {
59299                                        pos: 2 as libc::c_int,
59300                                    };
59301                                    init
59302                                },
59303                            },
59304                            find_keys_type: KSPEC_FK_KEYNUM,
59305                            fk: C2RustUnnamed_0 {
59306                                keynum: {
59307                                    let mut init = C2RustUnnamed_1 {
59308                                        keynumidx: 0 as libc::c_int,
59309                                        firstkey: 1 as libc::c_int,
59310                                        keystep: 1 as libc::c_int,
59311                                    };
59312                                    init
59313                                },
59314                            },
59315                        };
59316                        init
59317                    },
59318                    keySpec {
59319                        notes: 0 as *const libc::c_char,
59320                        flags: 0,
59321                        begin_search_type: KSPEC_BS_INVALID,
59322                        bs: C2RustUnnamed_3 {
59323                            index: C2RustUnnamed_5 { pos: 0 },
59324                        },
59325                        find_keys_type: KSPEC_FK_INVALID,
59326                        fk: C2RustUnnamed_0 {
59327                            range: C2RustUnnamed_2 {
59328                                lastkey: 0,
59329                                keystep: 0,
59330                                limit: 0,
59331                            },
59332                        },
59333                    },
59334                    keySpec {
59335                        notes: 0 as *const libc::c_char,
59336                        flags: 0,
59337                        begin_search_type: KSPEC_BS_INVALID,
59338                        bs: C2RustUnnamed_3 {
59339                            index: C2RustUnnamed_5 { pos: 0 },
59340                        },
59341                        find_keys_type: KSPEC_FK_INVALID,
59342                        fk: C2RustUnnamed_0 {
59343                            range: C2RustUnnamed_2 {
59344                                lastkey: 0,
59345                                keystep: 0,
59346                                limit: 0,
59347                            },
59348                        },
59349                    },
59350                    keySpec {
59351                        notes: 0 as *const libc::c_char,
59352                        flags: 0,
59353                        begin_search_type: KSPEC_BS_INVALID,
59354                        bs: C2RustUnnamed_3 {
59355                            index: C2RustUnnamed_5 { pos: 0 },
59356                        },
59357                        find_keys_type: KSPEC_FK_INVALID,
59358                        fk: C2RustUnnamed_0 {
59359                            range: C2RustUnnamed_2 {
59360                                lastkey: 0,
59361                                keystep: 0,
59362                                limit: 0,
59363                            },
59364                        },
59365                    },
59366                ],
59367                getkeys_proc: Some(
59368                    blmpopGetKeys
59369                        as unsafe extern "C" fn(
59370                            *mut redisCommand,
59371                            *mut *mut robj,
59372                            libc::c_int,
59373                            *mut getKeysResult,
59374                        ) -> libc::c_int,
59375                ),
59376                subcommands: 0 as *const redisCommand as *mut redisCommand,
59377                args: BZMPOP_Args.as_ptr() as *mut _,
59378                microseconds: 0,
59379                calls: 0,
59380                rejected_calls: 0,
59381                failed_calls: 0,
59382                id: 0,
59383                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59384                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59385                key_specs: 0 as *const keySpec as *mut keySpec,
59386                legacy_range_key_spec: keySpec {
59387                    notes: 0 as *const libc::c_char,
59388                    flags: 0,
59389                    begin_search_type: KSPEC_BS_INVALID,
59390                    bs: C2RustUnnamed_3 {
59391                        index: C2RustUnnamed_5 { pos: 0 },
59392                    },
59393                    find_keys_type: KSPEC_FK_INVALID,
59394                    fk: C2RustUnnamed_0 {
59395                        range: C2RustUnnamed_2 {
59396                            lastkey: 0,
59397                            keystep: 0,
59398                            limit: 0,
59399                        },
59400                    },
59401                },
59402                num_args: 0,
59403                num_history: 0,
59404                num_tips: 0,
59405                key_specs_num: 0,
59406                key_specs_max: 0,
59407                subcommands_dict: 0 as *const dict as *mut dict,
59408                parent: 0 as *const redisCommand as *mut redisCommand,
59409                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59410            };
59411            init
59412        },
59413        {
59414            let mut init = redisCommand {
59415                declared_name: b"bzpopmax\0" as *const u8 as *const libc::c_char,
59416                summary: b"Remove and return the member with the highest score from one or more sorted sets, or block until one is available\0"
59417                    as *const u8 as *const libc::c_char,
59418                complexity: b"O(log(N)) with N being the number of elements in the sorted set.\0"
59419                    as *const u8 as *const libc::c_char,
59420                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
59421                doc_flags: 0 as libc::c_int,
59422                replaced_by: 0 as *const libc::c_char,
59423                deprecated_since: 0 as *const libc::c_char,
59424                group: COMMAND_GROUP_SORTED_SET,
59425                history: BZPOPMAX_History.as_ptr() as *mut _,
59426                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59427                proc_0: Some(bzpopmaxCommand as unsafe extern "C" fn(*mut client) -> ()),
59428                arity: -(3 as libc::c_int),
59429                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59430                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
59431                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
59432                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
59433                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59434                    as uint64_t,
59435                key_specs_static: [
59436                    {
59437                        let mut init = keySpec {
59438                            notes: 0 as *const libc::c_char,
59439                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59440                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
59441                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
59442                            begin_search_type: KSPEC_BS_INDEX,
59443                            bs: C2RustUnnamed_3 {
59444                                index: {
59445                                    let mut init = C2RustUnnamed_5 {
59446                                        pos: 1 as libc::c_int,
59447                                    };
59448                                    init
59449                                },
59450                            },
59451                            find_keys_type: KSPEC_FK_RANGE,
59452                            fk: C2RustUnnamed_0 {
59453                                range: {
59454                                    let mut init = C2RustUnnamed_2 {
59455                                        lastkey: -(2 as libc::c_int),
59456                                        keystep: 1 as libc::c_int,
59457                                        limit: 0 as libc::c_int,
59458                                    };
59459                                    init
59460                                },
59461                            },
59462                        };
59463                        init
59464                    },
59465                    keySpec {
59466                        notes: 0 as *const libc::c_char,
59467                        flags: 0,
59468                        begin_search_type: KSPEC_BS_INVALID,
59469                        bs: C2RustUnnamed_3 {
59470                            index: C2RustUnnamed_5 { pos: 0 },
59471                        },
59472                        find_keys_type: KSPEC_FK_INVALID,
59473                        fk: C2RustUnnamed_0 {
59474                            range: C2RustUnnamed_2 {
59475                                lastkey: 0,
59476                                keystep: 0,
59477                                limit: 0,
59478                            },
59479                        },
59480                    },
59481                    keySpec {
59482                        notes: 0 as *const libc::c_char,
59483                        flags: 0,
59484                        begin_search_type: KSPEC_BS_INVALID,
59485                        bs: C2RustUnnamed_3 {
59486                            index: C2RustUnnamed_5 { pos: 0 },
59487                        },
59488                        find_keys_type: KSPEC_FK_INVALID,
59489                        fk: C2RustUnnamed_0 {
59490                            range: C2RustUnnamed_2 {
59491                                lastkey: 0,
59492                                keystep: 0,
59493                                limit: 0,
59494                            },
59495                        },
59496                    },
59497                    keySpec {
59498                        notes: 0 as *const libc::c_char,
59499                        flags: 0,
59500                        begin_search_type: KSPEC_BS_INVALID,
59501                        bs: C2RustUnnamed_3 {
59502                            index: C2RustUnnamed_5 { pos: 0 },
59503                        },
59504                        find_keys_type: KSPEC_FK_INVALID,
59505                        fk: C2RustUnnamed_0 {
59506                            range: C2RustUnnamed_2 {
59507                                lastkey: 0,
59508                                keystep: 0,
59509                                limit: 0,
59510                            },
59511                        },
59512                    },
59513                ],
59514                getkeys_proc: None,
59515                subcommands: 0 as *const redisCommand as *mut redisCommand,
59516                args: BZPOPMAX_Args.as_ptr() as *mut _,
59517                microseconds: 0,
59518                calls: 0,
59519                rejected_calls: 0,
59520                failed_calls: 0,
59521                id: 0,
59522                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59523                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59524                key_specs: 0 as *const keySpec as *mut keySpec,
59525                legacy_range_key_spec: keySpec {
59526                    notes: 0 as *const libc::c_char,
59527                    flags: 0,
59528                    begin_search_type: KSPEC_BS_INVALID,
59529                    bs: C2RustUnnamed_3 {
59530                        index: C2RustUnnamed_5 { pos: 0 },
59531                    },
59532                    find_keys_type: KSPEC_FK_INVALID,
59533                    fk: C2RustUnnamed_0 {
59534                        range: C2RustUnnamed_2 {
59535                            lastkey: 0,
59536                            keystep: 0,
59537                            limit: 0,
59538                        },
59539                    },
59540                },
59541                num_args: 0,
59542                num_history: 0,
59543                num_tips: 0,
59544                key_specs_num: 0,
59545                key_specs_max: 0,
59546                subcommands_dict: 0 as *const dict as *mut dict,
59547                parent: 0 as *const redisCommand as *mut redisCommand,
59548                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59549            };
59550            init
59551        },
59552        {
59553            let mut init = redisCommand {
59554                declared_name: b"bzpopmin\0" as *const u8 as *const libc::c_char,
59555                summary: b"Remove and return the member with the lowest score from one or more sorted sets, or block until one is available\0"
59556                    as *const u8 as *const libc::c_char,
59557                complexity: b"O(log(N)) with N being the number of elements in the sorted set.\0"
59558                    as *const u8 as *const libc::c_char,
59559                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
59560                doc_flags: 0 as libc::c_int,
59561                replaced_by: 0 as *const libc::c_char,
59562                deprecated_since: 0 as *const libc::c_char,
59563                group: COMMAND_GROUP_SORTED_SET,
59564                history: BZPOPMIN_History.as_ptr() as *mut _,
59565                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59566                proc_0: Some(bzpopminCommand as unsafe extern "C" fn(*mut client) -> ()),
59567                arity: -(3 as libc::c_int),
59568                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59569                    | (1 as libc::c_ulonglong) << 6 as libc::c_int
59570                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
59571                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
59572                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59573                    as uint64_t,
59574                key_specs_static: [
59575                    {
59576                        let mut init = keySpec {
59577                            notes: 0 as *const libc::c_char,
59578                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59579                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
59580                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
59581                            begin_search_type: KSPEC_BS_INDEX,
59582                            bs: C2RustUnnamed_3 {
59583                                index: {
59584                                    let mut init = C2RustUnnamed_5 {
59585                                        pos: 1 as libc::c_int,
59586                                    };
59587                                    init
59588                                },
59589                            },
59590                            find_keys_type: KSPEC_FK_RANGE,
59591                            fk: C2RustUnnamed_0 {
59592                                range: {
59593                                    let mut init = C2RustUnnamed_2 {
59594                                        lastkey: -(2 as libc::c_int),
59595                                        keystep: 1 as libc::c_int,
59596                                        limit: 0 as libc::c_int,
59597                                    };
59598                                    init
59599                                },
59600                            },
59601                        };
59602                        init
59603                    },
59604                    keySpec {
59605                        notes: 0 as *const libc::c_char,
59606                        flags: 0,
59607                        begin_search_type: KSPEC_BS_INVALID,
59608                        bs: C2RustUnnamed_3 {
59609                            index: C2RustUnnamed_5 { pos: 0 },
59610                        },
59611                        find_keys_type: KSPEC_FK_INVALID,
59612                        fk: C2RustUnnamed_0 {
59613                            range: C2RustUnnamed_2 {
59614                                lastkey: 0,
59615                                keystep: 0,
59616                                limit: 0,
59617                            },
59618                        },
59619                    },
59620                    keySpec {
59621                        notes: 0 as *const libc::c_char,
59622                        flags: 0,
59623                        begin_search_type: KSPEC_BS_INVALID,
59624                        bs: C2RustUnnamed_3 {
59625                            index: C2RustUnnamed_5 { pos: 0 },
59626                        },
59627                        find_keys_type: KSPEC_FK_INVALID,
59628                        fk: C2RustUnnamed_0 {
59629                            range: C2RustUnnamed_2 {
59630                                lastkey: 0,
59631                                keystep: 0,
59632                                limit: 0,
59633                            },
59634                        },
59635                    },
59636                    keySpec {
59637                        notes: 0 as *const libc::c_char,
59638                        flags: 0,
59639                        begin_search_type: KSPEC_BS_INVALID,
59640                        bs: C2RustUnnamed_3 {
59641                            index: C2RustUnnamed_5 { pos: 0 },
59642                        },
59643                        find_keys_type: KSPEC_FK_INVALID,
59644                        fk: C2RustUnnamed_0 {
59645                            range: C2RustUnnamed_2 {
59646                                lastkey: 0,
59647                                keystep: 0,
59648                                limit: 0,
59649                            },
59650                        },
59651                    },
59652                ],
59653                getkeys_proc: None,
59654                subcommands: 0 as *const redisCommand as *mut redisCommand,
59655                args: BZPOPMIN_Args.as_ptr() as *mut _,
59656                microseconds: 0,
59657                calls: 0,
59658                rejected_calls: 0,
59659                failed_calls: 0,
59660                id: 0,
59661                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59662                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59663                key_specs: 0 as *const keySpec as *mut keySpec,
59664                legacy_range_key_spec: keySpec {
59665                    notes: 0 as *const libc::c_char,
59666                    flags: 0,
59667                    begin_search_type: KSPEC_BS_INVALID,
59668                    bs: C2RustUnnamed_3 {
59669                        index: C2RustUnnamed_5 { pos: 0 },
59670                    },
59671                    find_keys_type: KSPEC_FK_INVALID,
59672                    fk: C2RustUnnamed_0 {
59673                        range: C2RustUnnamed_2 {
59674                            lastkey: 0,
59675                            keystep: 0,
59676                            limit: 0,
59677                        },
59678                    },
59679                },
59680                num_args: 0,
59681                num_history: 0,
59682                num_tips: 0,
59683                key_specs_num: 0,
59684                key_specs_max: 0,
59685                subcommands_dict: 0 as *const dict as *mut dict,
59686                parent: 0 as *const redisCommand as *mut redisCommand,
59687                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59688            };
59689            init
59690        },
59691        {
59692            let mut init = redisCommand {
59693                declared_name: b"zadd\0" as *const u8 as *const libc::c_char,
59694                summary: b"Add one or more members to a sorted set, or update its score if it already exists\0"
59695                    as *const u8 as *const libc::c_char,
59696                complexity: b"O(log(N)) for each item added, where N is the number of elements in the sorted set.\0"
59697                    as *const u8 as *const libc::c_char,
59698                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
59699                doc_flags: 0 as libc::c_int,
59700                replaced_by: 0 as *const libc::c_char,
59701                deprecated_since: 0 as *const libc::c_char,
59702                group: COMMAND_GROUP_SORTED_SET,
59703                history: ZADD_History.as_ptr() as *mut _,
59704                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59705                proc_0: Some(zaddCommand as unsafe extern "C" fn(*mut client) -> ()),
59706                arity: -(4 as libc::c_int),
59707                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59708                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
59709                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
59710                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59711                    as uint64_t,
59712                key_specs_static: [
59713                    {
59714                        let mut init = keySpec {
59715                            notes: 0 as *const libc::c_char,
59716                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59717                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
59718                            begin_search_type: KSPEC_BS_INDEX,
59719                            bs: C2RustUnnamed_3 {
59720                                index: {
59721                                    let mut init = C2RustUnnamed_5 {
59722                                        pos: 1 as libc::c_int,
59723                                    };
59724                                    init
59725                                },
59726                            },
59727                            find_keys_type: KSPEC_FK_RANGE,
59728                            fk: C2RustUnnamed_0 {
59729                                range: {
59730                                    let mut init = C2RustUnnamed_2 {
59731                                        lastkey: 0 as libc::c_int,
59732                                        keystep: 1 as libc::c_int,
59733                                        limit: 0 as libc::c_int,
59734                                    };
59735                                    init
59736                                },
59737                            },
59738                        };
59739                        init
59740                    },
59741                    keySpec {
59742                        notes: 0 as *const libc::c_char,
59743                        flags: 0,
59744                        begin_search_type: KSPEC_BS_INVALID,
59745                        bs: C2RustUnnamed_3 {
59746                            index: C2RustUnnamed_5 { pos: 0 },
59747                        },
59748                        find_keys_type: KSPEC_FK_INVALID,
59749                        fk: C2RustUnnamed_0 {
59750                            range: C2RustUnnamed_2 {
59751                                lastkey: 0,
59752                                keystep: 0,
59753                                limit: 0,
59754                            },
59755                        },
59756                    },
59757                    keySpec {
59758                        notes: 0 as *const libc::c_char,
59759                        flags: 0,
59760                        begin_search_type: KSPEC_BS_INVALID,
59761                        bs: C2RustUnnamed_3 {
59762                            index: C2RustUnnamed_5 { pos: 0 },
59763                        },
59764                        find_keys_type: KSPEC_FK_INVALID,
59765                        fk: C2RustUnnamed_0 {
59766                            range: C2RustUnnamed_2 {
59767                                lastkey: 0,
59768                                keystep: 0,
59769                                limit: 0,
59770                            },
59771                        },
59772                    },
59773                    keySpec {
59774                        notes: 0 as *const libc::c_char,
59775                        flags: 0,
59776                        begin_search_type: KSPEC_BS_INVALID,
59777                        bs: C2RustUnnamed_3 {
59778                            index: C2RustUnnamed_5 { pos: 0 },
59779                        },
59780                        find_keys_type: KSPEC_FK_INVALID,
59781                        fk: C2RustUnnamed_0 {
59782                            range: C2RustUnnamed_2 {
59783                                lastkey: 0,
59784                                keystep: 0,
59785                                limit: 0,
59786                            },
59787                        },
59788                    },
59789                ],
59790                getkeys_proc: None,
59791                subcommands: 0 as *const redisCommand as *mut redisCommand,
59792                args: ZADD_Args.as_ptr() as *mut _,
59793                microseconds: 0,
59794                calls: 0,
59795                rejected_calls: 0,
59796                failed_calls: 0,
59797                id: 0,
59798                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59799                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59800                key_specs: 0 as *const keySpec as *mut keySpec,
59801                legacy_range_key_spec: keySpec {
59802                    notes: 0 as *const libc::c_char,
59803                    flags: 0,
59804                    begin_search_type: KSPEC_BS_INVALID,
59805                    bs: C2RustUnnamed_3 {
59806                        index: C2RustUnnamed_5 { pos: 0 },
59807                    },
59808                    find_keys_type: KSPEC_FK_INVALID,
59809                    fk: C2RustUnnamed_0 {
59810                        range: C2RustUnnamed_2 {
59811                            lastkey: 0,
59812                            keystep: 0,
59813                            limit: 0,
59814                        },
59815                    },
59816                },
59817                num_args: 0,
59818                num_history: 0,
59819                num_tips: 0,
59820                key_specs_num: 0,
59821                key_specs_max: 0,
59822                subcommands_dict: 0 as *const dict as *mut dict,
59823                parent: 0 as *const redisCommand as *mut redisCommand,
59824                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59825            };
59826            init
59827        },
59828        {
59829            let mut init = redisCommand {
59830                declared_name: b"zcard\0" as *const u8 as *const libc::c_char,
59831                summary: b"Get the number of members in a sorted set\0" as *const u8
59832                    as *const libc::c_char,
59833                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
59834                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
59835                doc_flags: 0 as libc::c_int,
59836                replaced_by: 0 as *const libc::c_char,
59837                deprecated_since: 0 as *const libc::c_char,
59838                group: COMMAND_GROUP_SORTED_SET,
59839                history: 0 as *const commandHistory as *mut commandHistory,
59840                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59841                proc_0: Some(zcardCommand as unsafe extern "C" fn(*mut client) -> ()),
59842                arity: 2 as libc::c_int,
59843                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59844                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
59845                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59846                    as uint64_t,
59847                key_specs_static: [
59848                    {
59849                        let mut init = keySpec {
59850                            notes: 0 as *const libc::c_char,
59851                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
59852                                as uint64_t,
59853                            begin_search_type: KSPEC_BS_INDEX,
59854                            bs: C2RustUnnamed_3 {
59855                                index: {
59856                                    let mut init = C2RustUnnamed_5 {
59857                                        pos: 1 as libc::c_int,
59858                                    };
59859                                    init
59860                                },
59861                            },
59862                            find_keys_type: KSPEC_FK_RANGE,
59863                            fk: C2RustUnnamed_0 {
59864                                range: {
59865                                    let mut init = C2RustUnnamed_2 {
59866                                        lastkey: 0 as libc::c_int,
59867                                        keystep: 1 as libc::c_int,
59868                                        limit: 0 as libc::c_int,
59869                                    };
59870                                    init
59871                                },
59872                            },
59873                        };
59874                        init
59875                    },
59876                    keySpec {
59877                        notes: 0 as *const libc::c_char,
59878                        flags: 0,
59879                        begin_search_type: KSPEC_BS_INVALID,
59880                        bs: C2RustUnnamed_3 {
59881                            index: C2RustUnnamed_5 { pos: 0 },
59882                        },
59883                        find_keys_type: KSPEC_FK_INVALID,
59884                        fk: C2RustUnnamed_0 {
59885                            range: C2RustUnnamed_2 {
59886                                lastkey: 0,
59887                                keystep: 0,
59888                                limit: 0,
59889                            },
59890                        },
59891                    },
59892                    keySpec {
59893                        notes: 0 as *const libc::c_char,
59894                        flags: 0,
59895                        begin_search_type: KSPEC_BS_INVALID,
59896                        bs: C2RustUnnamed_3 {
59897                            index: C2RustUnnamed_5 { pos: 0 },
59898                        },
59899                        find_keys_type: KSPEC_FK_INVALID,
59900                        fk: C2RustUnnamed_0 {
59901                            range: C2RustUnnamed_2 {
59902                                lastkey: 0,
59903                                keystep: 0,
59904                                limit: 0,
59905                            },
59906                        },
59907                    },
59908                    keySpec {
59909                        notes: 0 as *const libc::c_char,
59910                        flags: 0,
59911                        begin_search_type: KSPEC_BS_INVALID,
59912                        bs: C2RustUnnamed_3 {
59913                            index: C2RustUnnamed_5 { pos: 0 },
59914                        },
59915                        find_keys_type: KSPEC_FK_INVALID,
59916                        fk: C2RustUnnamed_0 {
59917                            range: C2RustUnnamed_2 {
59918                                lastkey: 0,
59919                                keystep: 0,
59920                                limit: 0,
59921                            },
59922                        },
59923                    },
59924                ],
59925                getkeys_proc: None,
59926                subcommands: 0 as *const redisCommand as *mut redisCommand,
59927                args: ZCARD_Args.as_ptr() as *mut _,
59928                microseconds: 0,
59929                calls: 0,
59930                rejected_calls: 0,
59931                failed_calls: 0,
59932                id: 0,
59933                fullname: 0 as *const libc::c_char as *mut libc::c_char,
59934                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
59935                key_specs: 0 as *const keySpec as *mut keySpec,
59936                legacy_range_key_spec: keySpec {
59937                    notes: 0 as *const libc::c_char,
59938                    flags: 0,
59939                    begin_search_type: KSPEC_BS_INVALID,
59940                    bs: C2RustUnnamed_3 {
59941                        index: C2RustUnnamed_5 { pos: 0 },
59942                    },
59943                    find_keys_type: KSPEC_FK_INVALID,
59944                    fk: C2RustUnnamed_0 {
59945                        range: C2RustUnnamed_2 {
59946                            lastkey: 0,
59947                            keystep: 0,
59948                            limit: 0,
59949                        },
59950                    },
59951                },
59952                num_args: 0,
59953                num_history: 0,
59954                num_tips: 0,
59955                key_specs_num: 0,
59956                key_specs_max: 0,
59957                subcommands_dict: 0 as *const dict as *mut dict,
59958                parent: 0 as *const redisCommand as *mut redisCommand,
59959                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
59960            };
59961            init
59962        },
59963        {
59964            let mut init = redisCommand {
59965                declared_name: b"zcount\0" as *const u8 as *const libc::c_char,
59966                summary: b"Count the members in a sorted set with scores within the given values\0"
59967                    as *const u8 as *const libc::c_char,
59968                complexity: b"O(log(N)) with N being the number of elements in the sorted set.\0"
59969                    as *const u8 as *const libc::c_char,
59970                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
59971                doc_flags: 0 as libc::c_int,
59972                replaced_by: 0 as *const libc::c_char,
59973                deprecated_since: 0 as *const libc::c_char,
59974                group: COMMAND_GROUP_SORTED_SET,
59975                history: 0 as *const commandHistory as *mut commandHistory,
59976                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
59977                proc_0: Some(zcountCommand as unsafe extern "C" fn(*mut client) -> ()),
59978                arity: 4 as libc::c_int,
59979                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
59980                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
59981                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
59982                    as uint64_t,
59983                key_specs_static: [
59984                    {
59985                        let mut init = keySpec {
59986                            notes: 0 as *const libc::c_char,
59987                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
59988                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
59989                            begin_search_type: KSPEC_BS_INDEX,
59990                            bs: C2RustUnnamed_3 {
59991                                index: {
59992                                    let mut init = C2RustUnnamed_5 {
59993                                        pos: 1 as libc::c_int,
59994                                    };
59995                                    init
59996                                },
59997                            },
59998                            find_keys_type: KSPEC_FK_RANGE,
59999                            fk: C2RustUnnamed_0 {
60000                                range: {
60001                                    let mut init = C2RustUnnamed_2 {
60002                                        lastkey: 0 as libc::c_int,
60003                                        keystep: 1 as libc::c_int,
60004                                        limit: 0 as libc::c_int,
60005                                    };
60006                                    init
60007                                },
60008                            },
60009                        };
60010                        init
60011                    },
60012                    keySpec {
60013                        notes: 0 as *const libc::c_char,
60014                        flags: 0,
60015                        begin_search_type: KSPEC_BS_INVALID,
60016                        bs: C2RustUnnamed_3 {
60017                            index: C2RustUnnamed_5 { pos: 0 },
60018                        },
60019                        find_keys_type: KSPEC_FK_INVALID,
60020                        fk: C2RustUnnamed_0 {
60021                            range: C2RustUnnamed_2 {
60022                                lastkey: 0,
60023                                keystep: 0,
60024                                limit: 0,
60025                            },
60026                        },
60027                    },
60028                    keySpec {
60029                        notes: 0 as *const libc::c_char,
60030                        flags: 0,
60031                        begin_search_type: KSPEC_BS_INVALID,
60032                        bs: C2RustUnnamed_3 {
60033                            index: C2RustUnnamed_5 { pos: 0 },
60034                        },
60035                        find_keys_type: KSPEC_FK_INVALID,
60036                        fk: C2RustUnnamed_0 {
60037                            range: C2RustUnnamed_2 {
60038                                lastkey: 0,
60039                                keystep: 0,
60040                                limit: 0,
60041                            },
60042                        },
60043                    },
60044                    keySpec {
60045                        notes: 0 as *const libc::c_char,
60046                        flags: 0,
60047                        begin_search_type: KSPEC_BS_INVALID,
60048                        bs: C2RustUnnamed_3 {
60049                            index: C2RustUnnamed_5 { pos: 0 },
60050                        },
60051                        find_keys_type: KSPEC_FK_INVALID,
60052                        fk: C2RustUnnamed_0 {
60053                            range: C2RustUnnamed_2 {
60054                                lastkey: 0,
60055                                keystep: 0,
60056                                limit: 0,
60057                            },
60058                        },
60059                    },
60060                ],
60061                getkeys_proc: None,
60062                subcommands: 0 as *const redisCommand as *mut redisCommand,
60063                args: ZCOUNT_Args.as_ptr() as *mut _,
60064                microseconds: 0,
60065                calls: 0,
60066                rejected_calls: 0,
60067                failed_calls: 0,
60068                id: 0,
60069                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60070                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60071                key_specs: 0 as *const keySpec as *mut keySpec,
60072                legacy_range_key_spec: keySpec {
60073                    notes: 0 as *const libc::c_char,
60074                    flags: 0,
60075                    begin_search_type: KSPEC_BS_INVALID,
60076                    bs: C2RustUnnamed_3 {
60077                        index: C2RustUnnamed_5 { pos: 0 },
60078                    },
60079                    find_keys_type: KSPEC_FK_INVALID,
60080                    fk: C2RustUnnamed_0 {
60081                        range: C2RustUnnamed_2 {
60082                            lastkey: 0,
60083                            keystep: 0,
60084                            limit: 0,
60085                        },
60086                    },
60087                },
60088                num_args: 0,
60089                num_history: 0,
60090                num_tips: 0,
60091                key_specs_num: 0,
60092                key_specs_max: 0,
60093                subcommands_dict: 0 as *const dict as *mut dict,
60094                parent: 0 as *const redisCommand as *mut redisCommand,
60095                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60096            };
60097            init
60098        },
60099        {
60100            let mut init = redisCommand {
60101                declared_name: b"zdiff\0" as *const u8 as *const libc::c_char,
60102                summary: b"Subtract multiple sorted sets\0" as *const u8
60103                    as *const libc::c_char,
60104                complexity: b"O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.\0"
60105                    as *const u8 as *const libc::c_char,
60106                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
60107                doc_flags: 0 as libc::c_int,
60108                replaced_by: 0 as *const libc::c_char,
60109                deprecated_since: 0 as *const libc::c_char,
60110                group: COMMAND_GROUP_SORTED_SET,
60111                history: 0 as *const commandHistory as *mut commandHistory,
60112                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60113                proc_0: Some(zdiffCommand as unsafe extern "C" fn(*mut client) -> ()),
60114                arity: -(3 as libc::c_int),
60115                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
60116                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60117                    as uint64_t,
60118                key_specs_static: [
60119                    {
60120                        let mut init = keySpec {
60121                            notes: 0 as *const libc::c_char,
60122                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60123                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
60124                            begin_search_type: KSPEC_BS_INDEX,
60125                            bs: C2RustUnnamed_3 {
60126                                index: {
60127                                    let mut init = C2RustUnnamed_5 {
60128                                        pos: 1 as libc::c_int,
60129                                    };
60130                                    init
60131                                },
60132                            },
60133                            find_keys_type: KSPEC_FK_KEYNUM,
60134                            fk: C2RustUnnamed_0 {
60135                                keynum: {
60136                                    let mut init = C2RustUnnamed_1 {
60137                                        keynumidx: 0 as libc::c_int,
60138                                        firstkey: 1 as libc::c_int,
60139                                        keystep: 1 as libc::c_int,
60140                                    };
60141                                    init
60142                                },
60143                            },
60144                        };
60145                        init
60146                    },
60147                    keySpec {
60148                        notes: 0 as *const libc::c_char,
60149                        flags: 0,
60150                        begin_search_type: KSPEC_BS_INVALID,
60151                        bs: C2RustUnnamed_3 {
60152                            index: C2RustUnnamed_5 { pos: 0 },
60153                        },
60154                        find_keys_type: KSPEC_FK_INVALID,
60155                        fk: C2RustUnnamed_0 {
60156                            range: C2RustUnnamed_2 {
60157                                lastkey: 0,
60158                                keystep: 0,
60159                                limit: 0,
60160                            },
60161                        },
60162                    },
60163                    keySpec {
60164                        notes: 0 as *const libc::c_char,
60165                        flags: 0,
60166                        begin_search_type: KSPEC_BS_INVALID,
60167                        bs: C2RustUnnamed_3 {
60168                            index: C2RustUnnamed_5 { pos: 0 },
60169                        },
60170                        find_keys_type: KSPEC_FK_INVALID,
60171                        fk: C2RustUnnamed_0 {
60172                            range: C2RustUnnamed_2 {
60173                                lastkey: 0,
60174                                keystep: 0,
60175                                limit: 0,
60176                            },
60177                        },
60178                    },
60179                    keySpec {
60180                        notes: 0 as *const libc::c_char,
60181                        flags: 0,
60182                        begin_search_type: KSPEC_BS_INVALID,
60183                        bs: C2RustUnnamed_3 {
60184                            index: C2RustUnnamed_5 { pos: 0 },
60185                        },
60186                        find_keys_type: KSPEC_FK_INVALID,
60187                        fk: C2RustUnnamed_0 {
60188                            range: C2RustUnnamed_2 {
60189                                lastkey: 0,
60190                                keystep: 0,
60191                                limit: 0,
60192                            },
60193                        },
60194                    },
60195                ],
60196                getkeys_proc: Some(
60197                    zunionInterDiffGetKeys
60198                        as unsafe extern "C" fn(
60199                            *mut redisCommand,
60200                            *mut *mut robj,
60201                            libc::c_int,
60202                            *mut getKeysResult,
60203                        ) -> libc::c_int,
60204                ),
60205                subcommands: 0 as *const redisCommand as *mut redisCommand,
60206                args: ZDIFF_Args.as_ptr() as *mut _,
60207                microseconds: 0,
60208                calls: 0,
60209                rejected_calls: 0,
60210                failed_calls: 0,
60211                id: 0,
60212                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60213                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60214                key_specs: 0 as *const keySpec as *mut keySpec,
60215                legacy_range_key_spec: keySpec {
60216                    notes: 0 as *const libc::c_char,
60217                    flags: 0,
60218                    begin_search_type: KSPEC_BS_INVALID,
60219                    bs: C2RustUnnamed_3 {
60220                        index: C2RustUnnamed_5 { pos: 0 },
60221                    },
60222                    find_keys_type: KSPEC_FK_INVALID,
60223                    fk: C2RustUnnamed_0 {
60224                        range: C2RustUnnamed_2 {
60225                            lastkey: 0,
60226                            keystep: 0,
60227                            limit: 0,
60228                        },
60229                    },
60230                },
60231                num_args: 0,
60232                num_history: 0,
60233                num_tips: 0,
60234                key_specs_num: 0,
60235                key_specs_max: 0,
60236                subcommands_dict: 0 as *const dict as *mut dict,
60237                parent: 0 as *const redisCommand as *mut redisCommand,
60238                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60239            };
60240            init
60241        },
60242        {
60243            let mut init = redisCommand {
60244                declared_name: b"zdiffstore\0" as *const u8 as *const libc::c_char,
60245                summary: b"Subtract multiple sorted sets and store the resulting sorted set in a new key\0"
60246                    as *const u8 as *const libc::c_char,
60247                complexity: b"O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.\0"
60248                    as *const u8 as *const libc::c_char,
60249                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
60250                doc_flags: 0 as libc::c_int,
60251                replaced_by: 0 as *const libc::c_char,
60252                deprecated_since: 0 as *const libc::c_char,
60253                group: COMMAND_GROUP_SORTED_SET,
60254                history: 0 as *const commandHistory as *mut commandHistory,
60255                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60256                proc_0: Some(
60257                    zdiffstoreCommand as unsafe extern "C" fn(*mut client) -> (),
60258                ),
60259                arity: -(4 as libc::c_int),
60260                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60261                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
60262                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60263                    as uint64_t,
60264                key_specs_static: [
60265                    {
60266                        let mut init = keySpec {
60267                            notes: 0 as *const libc::c_char,
60268                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
60269                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
60270                            begin_search_type: KSPEC_BS_INDEX,
60271                            bs: C2RustUnnamed_3 {
60272                                index: {
60273                                    let mut init = C2RustUnnamed_5 {
60274                                        pos: 1 as libc::c_int,
60275                                    };
60276                                    init
60277                                },
60278                            },
60279                            find_keys_type: KSPEC_FK_RANGE,
60280                            fk: C2RustUnnamed_0 {
60281                                range: {
60282                                    let mut init = C2RustUnnamed_2 {
60283                                        lastkey: 0 as libc::c_int,
60284                                        keystep: 1 as libc::c_int,
60285                                        limit: 0 as libc::c_int,
60286                                    };
60287                                    init
60288                                },
60289                            },
60290                        };
60291                        init
60292                    },
60293                    {
60294                        let mut init = keySpec {
60295                            notes: 0 as *const libc::c_char,
60296                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60297                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
60298                            begin_search_type: KSPEC_BS_INDEX,
60299                            bs: C2RustUnnamed_3 {
60300                                index: {
60301                                    let mut init = C2RustUnnamed_5 {
60302                                        pos: 2 as libc::c_int,
60303                                    };
60304                                    init
60305                                },
60306                            },
60307                            find_keys_type: KSPEC_FK_KEYNUM,
60308                            fk: C2RustUnnamed_0 {
60309                                keynum: {
60310                                    let mut init = C2RustUnnamed_1 {
60311                                        keynumidx: 0 as libc::c_int,
60312                                        firstkey: 1 as libc::c_int,
60313                                        keystep: 1 as libc::c_int,
60314                                    };
60315                                    init
60316                                },
60317                            },
60318                        };
60319                        init
60320                    },
60321                    keySpec {
60322                        notes: 0 as *const libc::c_char,
60323                        flags: 0,
60324                        begin_search_type: KSPEC_BS_INVALID,
60325                        bs: C2RustUnnamed_3 {
60326                            index: C2RustUnnamed_5 { pos: 0 },
60327                        },
60328                        find_keys_type: KSPEC_FK_INVALID,
60329                        fk: C2RustUnnamed_0 {
60330                            range: C2RustUnnamed_2 {
60331                                lastkey: 0,
60332                                keystep: 0,
60333                                limit: 0,
60334                            },
60335                        },
60336                    },
60337                    keySpec {
60338                        notes: 0 as *const libc::c_char,
60339                        flags: 0,
60340                        begin_search_type: KSPEC_BS_INVALID,
60341                        bs: C2RustUnnamed_3 {
60342                            index: C2RustUnnamed_5 { pos: 0 },
60343                        },
60344                        find_keys_type: KSPEC_FK_INVALID,
60345                        fk: C2RustUnnamed_0 {
60346                            range: C2RustUnnamed_2 {
60347                                lastkey: 0,
60348                                keystep: 0,
60349                                limit: 0,
60350                            },
60351                        },
60352                    },
60353                ],
60354                getkeys_proc: Some(
60355                    zunionInterDiffStoreGetKeys
60356                        as unsafe extern "C" fn(
60357                            *mut redisCommand,
60358                            *mut *mut robj,
60359                            libc::c_int,
60360                            *mut getKeysResult,
60361                        ) -> libc::c_int,
60362                ),
60363                subcommands: 0 as *const redisCommand as *mut redisCommand,
60364                args: ZDIFFSTORE_Args.as_ptr() as *mut _,
60365                microseconds: 0,
60366                calls: 0,
60367                rejected_calls: 0,
60368                failed_calls: 0,
60369                id: 0,
60370                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60371                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60372                key_specs: 0 as *const keySpec as *mut keySpec,
60373                legacy_range_key_spec: keySpec {
60374                    notes: 0 as *const libc::c_char,
60375                    flags: 0,
60376                    begin_search_type: KSPEC_BS_INVALID,
60377                    bs: C2RustUnnamed_3 {
60378                        index: C2RustUnnamed_5 { pos: 0 },
60379                    },
60380                    find_keys_type: KSPEC_FK_INVALID,
60381                    fk: C2RustUnnamed_0 {
60382                        range: C2RustUnnamed_2 {
60383                            lastkey: 0,
60384                            keystep: 0,
60385                            limit: 0,
60386                        },
60387                    },
60388                },
60389                num_args: 0,
60390                num_history: 0,
60391                num_tips: 0,
60392                key_specs_num: 0,
60393                key_specs_max: 0,
60394                subcommands_dict: 0 as *const dict as *mut dict,
60395                parent: 0 as *const redisCommand as *mut redisCommand,
60396                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60397            };
60398            init
60399        },
60400        {
60401            let mut init = redisCommand {
60402                declared_name: b"zincrby\0" as *const u8 as *const libc::c_char,
60403                summary: b"Increment the score of a member in a sorted set\0"
60404                    as *const u8 as *const libc::c_char,
60405                complexity: b"O(log(N)) where N is the number of elements in the sorted set.\0"
60406                    as *const u8 as *const libc::c_char,
60407                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
60408                doc_flags: 0 as libc::c_int,
60409                replaced_by: 0 as *const libc::c_char,
60410                deprecated_since: 0 as *const libc::c_char,
60411                group: COMMAND_GROUP_SORTED_SET,
60412                history: 0 as *const commandHistory as *mut commandHistory,
60413                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60414                proc_0: Some(zincrbyCommand as unsafe extern "C" fn(*mut client) -> ()),
60415                arity: 4 as libc::c_int,
60416                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60417                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
60418                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
60419                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60420                    as uint64_t,
60421                key_specs_static: [
60422                    {
60423                        let mut init = keySpec {
60424                            notes: 0 as *const libc::c_char,
60425                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
60426                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
60427                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
60428                            begin_search_type: KSPEC_BS_INDEX,
60429                            bs: C2RustUnnamed_3 {
60430                                index: {
60431                                    let mut init = C2RustUnnamed_5 {
60432                                        pos: 1 as libc::c_int,
60433                                    };
60434                                    init
60435                                },
60436                            },
60437                            find_keys_type: KSPEC_FK_RANGE,
60438                            fk: C2RustUnnamed_0 {
60439                                range: {
60440                                    let mut init = C2RustUnnamed_2 {
60441                                        lastkey: 0 as libc::c_int,
60442                                        keystep: 1 as libc::c_int,
60443                                        limit: 0 as libc::c_int,
60444                                    };
60445                                    init
60446                                },
60447                            },
60448                        };
60449                        init
60450                    },
60451                    keySpec {
60452                        notes: 0 as *const libc::c_char,
60453                        flags: 0,
60454                        begin_search_type: KSPEC_BS_INVALID,
60455                        bs: C2RustUnnamed_3 {
60456                            index: C2RustUnnamed_5 { pos: 0 },
60457                        },
60458                        find_keys_type: KSPEC_FK_INVALID,
60459                        fk: C2RustUnnamed_0 {
60460                            range: C2RustUnnamed_2 {
60461                                lastkey: 0,
60462                                keystep: 0,
60463                                limit: 0,
60464                            },
60465                        },
60466                    },
60467                    keySpec {
60468                        notes: 0 as *const libc::c_char,
60469                        flags: 0,
60470                        begin_search_type: KSPEC_BS_INVALID,
60471                        bs: C2RustUnnamed_3 {
60472                            index: C2RustUnnamed_5 { pos: 0 },
60473                        },
60474                        find_keys_type: KSPEC_FK_INVALID,
60475                        fk: C2RustUnnamed_0 {
60476                            range: C2RustUnnamed_2 {
60477                                lastkey: 0,
60478                                keystep: 0,
60479                                limit: 0,
60480                            },
60481                        },
60482                    },
60483                    keySpec {
60484                        notes: 0 as *const libc::c_char,
60485                        flags: 0,
60486                        begin_search_type: KSPEC_BS_INVALID,
60487                        bs: C2RustUnnamed_3 {
60488                            index: C2RustUnnamed_5 { pos: 0 },
60489                        },
60490                        find_keys_type: KSPEC_FK_INVALID,
60491                        fk: C2RustUnnamed_0 {
60492                            range: C2RustUnnamed_2 {
60493                                lastkey: 0,
60494                                keystep: 0,
60495                                limit: 0,
60496                            },
60497                        },
60498                    },
60499                ],
60500                getkeys_proc: None,
60501                subcommands: 0 as *const redisCommand as *mut redisCommand,
60502                args: ZINCRBY_Args.as_ptr() as *mut _,
60503                microseconds: 0,
60504                calls: 0,
60505                rejected_calls: 0,
60506                failed_calls: 0,
60507                id: 0,
60508                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60509                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60510                key_specs: 0 as *const keySpec as *mut keySpec,
60511                legacy_range_key_spec: keySpec {
60512                    notes: 0 as *const libc::c_char,
60513                    flags: 0,
60514                    begin_search_type: KSPEC_BS_INVALID,
60515                    bs: C2RustUnnamed_3 {
60516                        index: C2RustUnnamed_5 { pos: 0 },
60517                    },
60518                    find_keys_type: KSPEC_FK_INVALID,
60519                    fk: C2RustUnnamed_0 {
60520                        range: C2RustUnnamed_2 {
60521                            lastkey: 0,
60522                            keystep: 0,
60523                            limit: 0,
60524                        },
60525                    },
60526                },
60527                num_args: 0,
60528                num_history: 0,
60529                num_tips: 0,
60530                key_specs_num: 0,
60531                key_specs_max: 0,
60532                subcommands_dict: 0 as *const dict as *mut dict,
60533                parent: 0 as *const redisCommand as *mut redisCommand,
60534                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60535            };
60536            init
60537        },
60538        {
60539            let mut init = redisCommand {
60540                declared_name: b"zinter\0" as *const u8 as *const libc::c_char,
60541                summary: b"Intersect multiple sorted sets\0" as *const u8
60542                    as *const libc::c_char,
60543                complexity: b"O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.\0"
60544                    as *const u8 as *const libc::c_char,
60545                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
60546                doc_flags: 0 as libc::c_int,
60547                replaced_by: 0 as *const libc::c_char,
60548                deprecated_since: 0 as *const libc::c_char,
60549                group: COMMAND_GROUP_SORTED_SET,
60550                history: 0 as *const commandHistory as *mut commandHistory,
60551                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60552                proc_0: Some(zinterCommand as unsafe extern "C" fn(*mut client) -> ()),
60553                arity: -(3 as libc::c_int),
60554                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
60555                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60556                    as uint64_t,
60557                key_specs_static: [
60558                    {
60559                        let mut init = keySpec {
60560                            notes: 0 as *const libc::c_char,
60561                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60562                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
60563                            begin_search_type: KSPEC_BS_INDEX,
60564                            bs: C2RustUnnamed_3 {
60565                                index: {
60566                                    let mut init = C2RustUnnamed_5 {
60567                                        pos: 1 as libc::c_int,
60568                                    };
60569                                    init
60570                                },
60571                            },
60572                            find_keys_type: KSPEC_FK_KEYNUM,
60573                            fk: C2RustUnnamed_0 {
60574                                keynum: {
60575                                    let mut init = C2RustUnnamed_1 {
60576                                        keynumidx: 0 as libc::c_int,
60577                                        firstkey: 1 as libc::c_int,
60578                                        keystep: 1 as libc::c_int,
60579                                    };
60580                                    init
60581                                },
60582                            },
60583                        };
60584                        init
60585                    },
60586                    keySpec {
60587                        notes: 0 as *const libc::c_char,
60588                        flags: 0,
60589                        begin_search_type: KSPEC_BS_INVALID,
60590                        bs: C2RustUnnamed_3 {
60591                            index: C2RustUnnamed_5 { pos: 0 },
60592                        },
60593                        find_keys_type: KSPEC_FK_INVALID,
60594                        fk: C2RustUnnamed_0 {
60595                            range: C2RustUnnamed_2 {
60596                                lastkey: 0,
60597                                keystep: 0,
60598                                limit: 0,
60599                            },
60600                        },
60601                    },
60602                    keySpec {
60603                        notes: 0 as *const libc::c_char,
60604                        flags: 0,
60605                        begin_search_type: KSPEC_BS_INVALID,
60606                        bs: C2RustUnnamed_3 {
60607                            index: C2RustUnnamed_5 { pos: 0 },
60608                        },
60609                        find_keys_type: KSPEC_FK_INVALID,
60610                        fk: C2RustUnnamed_0 {
60611                            range: C2RustUnnamed_2 {
60612                                lastkey: 0,
60613                                keystep: 0,
60614                                limit: 0,
60615                            },
60616                        },
60617                    },
60618                    keySpec {
60619                        notes: 0 as *const libc::c_char,
60620                        flags: 0,
60621                        begin_search_type: KSPEC_BS_INVALID,
60622                        bs: C2RustUnnamed_3 {
60623                            index: C2RustUnnamed_5 { pos: 0 },
60624                        },
60625                        find_keys_type: KSPEC_FK_INVALID,
60626                        fk: C2RustUnnamed_0 {
60627                            range: C2RustUnnamed_2 {
60628                                lastkey: 0,
60629                                keystep: 0,
60630                                limit: 0,
60631                            },
60632                        },
60633                    },
60634                ],
60635                getkeys_proc: Some(
60636                    zunionInterDiffGetKeys
60637                        as unsafe extern "C" fn(
60638                            *mut redisCommand,
60639                            *mut *mut robj,
60640                            libc::c_int,
60641                            *mut getKeysResult,
60642                        ) -> libc::c_int,
60643                ),
60644                subcommands: 0 as *const redisCommand as *mut redisCommand,
60645                args: ZINTER_Args.as_ptr() as *mut _,
60646                microseconds: 0,
60647                calls: 0,
60648                rejected_calls: 0,
60649                failed_calls: 0,
60650                id: 0,
60651                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60652                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60653                key_specs: 0 as *const keySpec as *mut keySpec,
60654                legacy_range_key_spec: keySpec {
60655                    notes: 0 as *const libc::c_char,
60656                    flags: 0,
60657                    begin_search_type: KSPEC_BS_INVALID,
60658                    bs: C2RustUnnamed_3 {
60659                        index: C2RustUnnamed_5 { pos: 0 },
60660                    },
60661                    find_keys_type: KSPEC_FK_INVALID,
60662                    fk: C2RustUnnamed_0 {
60663                        range: C2RustUnnamed_2 {
60664                            lastkey: 0,
60665                            keystep: 0,
60666                            limit: 0,
60667                        },
60668                    },
60669                },
60670                num_args: 0,
60671                num_history: 0,
60672                num_tips: 0,
60673                key_specs_num: 0,
60674                key_specs_max: 0,
60675                subcommands_dict: 0 as *const dict as *mut dict,
60676                parent: 0 as *const redisCommand as *mut redisCommand,
60677                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60678            };
60679            init
60680        },
60681        {
60682            let mut init = redisCommand {
60683                declared_name: b"zintercard\0" as *const u8 as *const libc::c_char,
60684                summary: b"Intersect multiple sorted sets and return the cardinality of the result\0"
60685                    as *const u8 as *const libc::c_char,
60686                complexity: b"O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.\0"
60687                    as *const u8 as *const libc::c_char,
60688                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
60689                doc_flags: 0 as libc::c_int,
60690                replaced_by: 0 as *const libc::c_char,
60691                deprecated_since: 0 as *const libc::c_char,
60692                group: COMMAND_GROUP_SORTED_SET,
60693                history: 0 as *const commandHistory as *mut commandHistory,
60694                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60695                proc_0: Some(
60696                    zinterCardCommand as unsafe extern "C" fn(*mut client) -> (),
60697                ),
60698                arity: -(3 as libc::c_int),
60699                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
60700                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60701                    as uint64_t,
60702                key_specs_static: [
60703                    {
60704                        let mut init = keySpec {
60705                            notes: 0 as *const libc::c_char,
60706                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60707                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
60708                            begin_search_type: KSPEC_BS_INDEX,
60709                            bs: C2RustUnnamed_3 {
60710                                index: {
60711                                    let mut init = C2RustUnnamed_5 {
60712                                        pos: 1 as libc::c_int,
60713                                    };
60714                                    init
60715                                },
60716                            },
60717                            find_keys_type: KSPEC_FK_KEYNUM,
60718                            fk: C2RustUnnamed_0 {
60719                                keynum: {
60720                                    let mut init = C2RustUnnamed_1 {
60721                                        keynumidx: 0 as libc::c_int,
60722                                        firstkey: 1 as libc::c_int,
60723                                        keystep: 1 as libc::c_int,
60724                                    };
60725                                    init
60726                                },
60727                            },
60728                        };
60729                        init
60730                    },
60731                    keySpec {
60732                        notes: 0 as *const libc::c_char,
60733                        flags: 0,
60734                        begin_search_type: KSPEC_BS_INVALID,
60735                        bs: C2RustUnnamed_3 {
60736                            index: C2RustUnnamed_5 { pos: 0 },
60737                        },
60738                        find_keys_type: KSPEC_FK_INVALID,
60739                        fk: C2RustUnnamed_0 {
60740                            range: C2RustUnnamed_2 {
60741                                lastkey: 0,
60742                                keystep: 0,
60743                                limit: 0,
60744                            },
60745                        },
60746                    },
60747                    keySpec {
60748                        notes: 0 as *const libc::c_char,
60749                        flags: 0,
60750                        begin_search_type: KSPEC_BS_INVALID,
60751                        bs: C2RustUnnamed_3 {
60752                            index: C2RustUnnamed_5 { pos: 0 },
60753                        },
60754                        find_keys_type: KSPEC_FK_INVALID,
60755                        fk: C2RustUnnamed_0 {
60756                            range: C2RustUnnamed_2 {
60757                                lastkey: 0,
60758                                keystep: 0,
60759                                limit: 0,
60760                            },
60761                        },
60762                    },
60763                    keySpec {
60764                        notes: 0 as *const libc::c_char,
60765                        flags: 0,
60766                        begin_search_type: KSPEC_BS_INVALID,
60767                        bs: C2RustUnnamed_3 {
60768                            index: C2RustUnnamed_5 { pos: 0 },
60769                        },
60770                        find_keys_type: KSPEC_FK_INVALID,
60771                        fk: C2RustUnnamed_0 {
60772                            range: C2RustUnnamed_2 {
60773                                lastkey: 0,
60774                                keystep: 0,
60775                                limit: 0,
60776                            },
60777                        },
60778                    },
60779                ],
60780                getkeys_proc: Some(
60781                    zunionInterDiffGetKeys
60782                        as unsafe extern "C" fn(
60783                            *mut redisCommand,
60784                            *mut *mut robj,
60785                            libc::c_int,
60786                            *mut getKeysResult,
60787                        ) -> libc::c_int,
60788                ),
60789                subcommands: 0 as *const redisCommand as *mut redisCommand,
60790                args: ZINTERCARD_Args.as_ptr() as *mut _,
60791                microseconds: 0,
60792                calls: 0,
60793                rejected_calls: 0,
60794                failed_calls: 0,
60795                id: 0,
60796                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60797                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60798                key_specs: 0 as *const keySpec as *mut keySpec,
60799                legacy_range_key_spec: keySpec {
60800                    notes: 0 as *const libc::c_char,
60801                    flags: 0,
60802                    begin_search_type: KSPEC_BS_INVALID,
60803                    bs: C2RustUnnamed_3 {
60804                        index: C2RustUnnamed_5 { pos: 0 },
60805                    },
60806                    find_keys_type: KSPEC_FK_INVALID,
60807                    fk: C2RustUnnamed_0 {
60808                        range: C2RustUnnamed_2 {
60809                            lastkey: 0,
60810                            keystep: 0,
60811                            limit: 0,
60812                        },
60813                    },
60814                },
60815                num_args: 0,
60816                num_history: 0,
60817                num_tips: 0,
60818                key_specs_num: 0,
60819                key_specs_max: 0,
60820                subcommands_dict: 0 as *const dict as *mut dict,
60821                parent: 0 as *const redisCommand as *mut redisCommand,
60822                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60823            };
60824            init
60825        },
60826        {
60827            let mut init = redisCommand {
60828                declared_name: b"zinterstore\0" as *const u8 as *const libc::c_char,
60829                summary: b"Intersect multiple sorted sets and store the resulting sorted set in a new key\0"
60830                    as *const u8 as *const libc::c_char,
60831                complexity: b"O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.\0"
60832                    as *const u8 as *const libc::c_char,
60833                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
60834                doc_flags: 0 as libc::c_int,
60835                replaced_by: 0 as *const libc::c_char,
60836                deprecated_since: 0 as *const libc::c_char,
60837                group: COMMAND_GROUP_SORTED_SET,
60838                history: 0 as *const commandHistory as *mut commandHistory,
60839                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60840                proc_0: Some(
60841                    zinterstoreCommand as unsafe extern "C" fn(*mut client) -> (),
60842                ),
60843                arity: -(4 as libc::c_int),
60844                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60845                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
60846                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
60847                    as uint64_t,
60848                key_specs_static: [
60849                    {
60850                        let mut init = keySpec {
60851                            notes: 0 as *const libc::c_char,
60852                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
60853                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
60854                            begin_search_type: KSPEC_BS_INDEX,
60855                            bs: C2RustUnnamed_3 {
60856                                index: {
60857                                    let mut init = C2RustUnnamed_5 {
60858                                        pos: 1 as libc::c_int,
60859                                    };
60860                                    init
60861                                },
60862                            },
60863                            find_keys_type: KSPEC_FK_RANGE,
60864                            fk: C2RustUnnamed_0 {
60865                                range: {
60866                                    let mut init = C2RustUnnamed_2 {
60867                                        lastkey: 0 as libc::c_int,
60868                                        keystep: 1 as libc::c_int,
60869                                        limit: 0 as libc::c_int,
60870                                    };
60871                                    init
60872                                },
60873                            },
60874                        };
60875                        init
60876                    },
60877                    {
60878                        let mut init = keySpec {
60879                            notes: 0 as *const libc::c_char,
60880                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
60881                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
60882                            begin_search_type: KSPEC_BS_INDEX,
60883                            bs: C2RustUnnamed_3 {
60884                                index: {
60885                                    let mut init = C2RustUnnamed_5 {
60886                                        pos: 2 as libc::c_int,
60887                                    };
60888                                    init
60889                                },
60890                            },
60891                            find_keys_type: KSPEC_FK_KEYNUM,
60892                            fk: C2RustUnnamed_0 {
60893                                keynum: {
60894                                    let mut init = C2RustUnnamed_1 {
60895                                        keynumidx: 0 as libc::c_int,
60896                                        firstkey: 1 as libc::c_int,
60897                                        keystep: 1 as libc::c_int,
60898                                    };
60899                                    init
60900                                },
60901                            },
60902                        };
60903                        init
60904                    },
60905                    keySpec {
60906                        notes: 0 as *const libc::c_char,
60907                        flags: 0,
60908                        begin_search_type: KSPEC_BS_INVALID,
60909                        bs: C2RustUnnamed_3 {
60910                            index: C2RustUnnamed_5 { pos: 0 },
60911                        },
60912                        find_keys_type: KSPEC_FK_INVALID,
60913                        fk: C2RustUnnamed_0 {
60914                            range: C2RustUnnamed_2 {
60915                                lastkey: 0,
60916                                keystep: 0,
60917                                limit: 0,
60918                            },
60919                        },
60920                    },
60921                    keySpec {
60922                        notes: 0 as *const libc::c_char,
60923                        flags: 0,
60924                        begin_search_type: KSPEC_BS_INVALID,
60925                        bs: C2RustUnnamed_3 {
60926                            index: C2RustUnnamed_5 { pos: 0 },
60927                        },
60928                        find_keys_type: KSPEC_FK_INVALID,
60929                        fk: C2RustUnnamed_0 {
60930                            range: C2RustUnnamed_2 {
60931                                lastkey: 0,
60932                                keystep: 0,
60933                                limit: 0,
60934                            },
60935                        },
60936                    },
60937                ],
60938                getkeys_proc: Some(
60939                    zunionInterDiffStoreGetKeys
60940                        as unsafe extern "C" fn(
60941                            *mut redisCommand,
60942                            *mut *mut robj,
60943                            libc::c_int,
60944                            *mut getKeysResult,
60945                        ) -> libc::c_int,
60946                ),
60947                subcommands: 0 as *const redisCommand as *mut redisCommand,
60948                args: ZINTERSTORE_Args.as_ptr() as *mut _,
60949                microseconds: 0,
60950                calls: 0,
60951                rejected_calls: 0,
60952                failed_calls: 0,
60953                id: 0,
60954                fullname: 0 as *const libc::c_char as *mut libc::c_char,
60955                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
60956                key_specs: 0 as *const keySpec as *mut keySpec,
60957                legacy_range_key_spec: keySpec {
60958                    notes: 0 as *const libc::c_char,
60959                    flags: 0,
60960                    begin_search_type: KSPEC_BS_INVALID,
60961                    bs: C2RustUnnamed_3 {
60962                        index: C2RustUnnamed_5 { pos: 0 },
60963                    },
60964                    find_keys_type: KSPEC_FK_INVALID,
60965                    fk: C2RustUnnamed_0 {
60966                        range: C2RustUnnamed_2 {
60967                            lastkey: 0,
60968                            keystep: 0,
60969                            limit: 0,
60970                        },
60971                    },
60972                },
60973                num_args: 0,
60974                num_history: 0,
60975                num_tips: 0,
60976                key_specs_num: 0,
60977                key_specs_max: 0,
60978                subcommands_dict: 0 as *const dict as *mut dict,
60979                parent: 0 as *const redisCommand as *mut redisCommand,
60980                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
60981            };
60982            init
60983        },
60984        {
60985            let mut init = redisCommand {
60986                declared_name: b"zlexcount\0" as *const u8 as *const libc::c_char,
60987                summary: b"Count the number of members in a sorted set between a given lexicographical range\0"
60988                    as *const u8 as *const libc::c_char,
60989                complexity: b"O(log(N)) with N being the number of elements in the sorted set.\0"
60990                    as *const u8 as *const libc::c_char,
60991                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
60992                doc_flags: 0 as libc::c_int,
60993                replaced_by: 0 as *const libc::c_char,
60994                deprecated_since: 0 as *const libc::c_char,
60995                group: COMMAND_GROUP_SORTED_SET,
60996                history: 0 as *const commandHistory as *mut commandHistory,
60997                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
60998                proc_0: Some(
60999                    zlexcountCommand as unsafe extern "C" fn(*mut client) -> (),
61000                ),
61001                arity: 4 as libc::c_int,
61002                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
61003                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
61004                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61005                    as uint64_t,
61006                key_specs_static: [
61007                    {
61008                        let mut init = keySpec {
61009                            notes: 0 as *const libc::c_char,
61010                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61011                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
61012                            begin_search_type: KSPEC_BS_INDEX,
61013                            bs: C2RustUnnamed_3 {
61014                                index: {
61015                                    let mut init = C2RustUnnamed_5 {
61016                                        pos: 1 as libc::c_int,
61017                                    };
61018                                    init
61019                                },
61020                            },
61021                            find_keys_type: KSPEC_FK_RANGE,
61022                            fk: C2RustUnnamed_0 {
61023                                range: {
61024                                    let mut init = C2RustUnnamed_2 {
61025                                        lastkey: 0 as libc::c_int,
61026                                        keystep: 1 as libc::c_int,
61027                                        limit: 0 as libc::c_int,
61028                                    };
61029                                    init
61030                                },
61031                            },
61032                        };
61033                        init
61034                    },
61035                    keySpec {
61036                        notes: 0 as *const libc::c_char,
61037                        flags: 0,
61038                        begin_search_type: KSPEC_BS_INVALID,
61039                        bs: C2RustUnnamed_3 {
61040                            index: C2RustUnnamed_5 { pos: 0 },
61041                        },
61042                        find_keys_type: KSPEC_FK_INVALID,
61043                        fk: C2RustUnnamed_0 {
61044                            range: C2RustUnnamed_2 {
61045                                lastkey: 0,
61046                                keystep: 0,
61047                                limit: 0,
61048                            },
61049                        },
61050                    },
61051                    keySpec {
61052                        notes: 0 as *const libc::c_char,
61053                        flags: 0,
61054                        begin_search_type: KSPEC_BS_INVALID,
61055                        bs: C2RustUnnamed_3 {
61056                            index: C2RustUnnamed_5 { pos: 0 },
61057                        },
61058                        find_keys_type: KSPEC_FK_INVALID,
61059                        fk: C2RustUnnamed_0 {
61060                            range: C2RustUnnamed_2 {
61061                                lastkey: 0,
61062                                keystep: 0,
61063                                limit: 0,
61064                            },
61065                        },
61066                    },
61067                    keySpec {
61068                        notes: 0 as *const libc::c_char,
61069                        flags: 0,
61070                        begin_search_type: KSPEC_BS_INVALID,
61071                        bs: C2RustUnnamed_3 {
61072                            index: C2RustUnnamed_5 { pos: 0 },
61073                        },
61074                        find_keys_type: KSPEC_FK_INVALID,
61075                        fk: C2RustUnnamed_0 {
61076                            range: C2RustUnnamed_2 {
61077                                lastkey: 0,
61078                                keystep: 0,
61079                                limit: 0,
61080                            },
61081                        },
61082                    },
61083                ],
61084                getkeys_proc: None,
61085                subcommands: 0 as *const redisCommand as *mut redisCommand,
61086                args: ZLEXCOUNT_Args.as_ptr() as *mut _,
61087                microseconds: 0,
61088                calls: 0,
61089                rejected_calls: 0,
61090                failed_calls: 0,
61091                id: 0,
61092                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61093                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61094                key_specs: 0 as *const keySpec as *mut keySpec,
61095                legacy_range_key_spec: keySpec {
61096                    notes: 0 as *const libc::c_char,
61097                    flags: 0,
61098                    begin_search_type: KSPEC_BS_INVALID,
61099                    bs: C2RustUnnamed_3 {
61100                        index: C2RustUnnamed_5 { pos: 0 },
61101                    },
61102                    find_keys_type: KSPEC_FK_INVALID,
61103                    fk: C2RustUnnamed_0 {
61104                        range: C2RustUnnamed_2 {
61105                            lastkey: 0,
61106                            keystep: 0,
61107                            limit: 0,
61108                        },
61109                    },
61110                },
61111                num_args: 0,
61112                num_history: 0,
61113                num_tips: 0,
61114                key_specs_num: 0,
61115                key_specs_max: 0,
61116                subcommands_dict: 0 as *const dict as *mut dict,
61117                parent: 0 as *const redisCommand as *mut redisCommand,
61118                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61119            };
61120            init
61121        },
61122        {
61123            let mut init = redisCommand {
61124                declared_name: b"zmpop\0" as *const u8 as *const libc::c_char,
61125                summary: b"Remove and return members with scores in a sorted set\0"
61126                    as *const u8 as *const libc::c_char,
61127                complexity: b"O(K) + O(M*log(N)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.\0"
61128                    as *const u8 as *const libc::c_char,
61129                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
61130                doc_flags: 0 as libc::c_int,
61131                replaced_by: 0 as *const libc::c_char,
61132                deprecated_since: 0 as *const libc::c_char,
61133                group: COMMAND_GROUP_SORTED_SET,
61134                history: 0 as *const commandHistory as *mut commandHistory,
61135                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61136                proc_0: Some(zmpopCommand as unsafe extern "C" fn(*mut client) -> ()),
61137                arity: -(4 as libc::c_int),
61138                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
61139                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61140                    as uint64_t,
61141                key_specs_static: [
61142                    {
61143                        let mut init = keySpec {
61144                            notes: 0 as *const libc::c_char,
61145                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
61146                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
61147                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
61148                            begin_search_type: KSPEC_BS_INDEX,
61149                            bs: C2RustUnnamed_3 {
61150                                index: {
61151                                    let mut init = C2RustUnnamed_5 {
61152                                        pos: 1 as libc::c_int,
61153                                    };
61154                                    init
61155                                },
61156                            },
61157                            find_keys_type: KSPEC_FK_KEYNUM,
61158                            fk: C2RustUnnamed_0 {
61159                                keynum: {
61160                                    let mut init = C2RustUnnamed_1 {
61161                                        keynumidx: 0 as libc::c_int,
61162                                        firstkey: 1 as libc::c_int,
61163                                        keystep: 1 as libc::c_int,
61164                                    };
61165                                    init
61166                                },
61167                            },
61168                        };
61169                        init
61170                    },
61171                    keySpec {
61172                        notes: 0 as *const libc::c_char,
61173                        flags: 0,
61174                        begin_search_type: KSPEC_BS_INVALID,
61175                        bs: C2RustUnnamed_3 {
61176                            index: C2RustUnnamed_5 { pos: 0 },
61177                        },
61178                        find_keys_type: KSPEC_FK_INVALID,
61179                        fk: C2RustUnnamed_0 {
61180                            range: C2RustUnnamed_2 {
61181                                lastkey: 0,
61182                                keystep: 0,
61183                                limit: 0,
61184                            },
61185                        },
61186                    },
61187                    keySpec {
61188                        notes: 0 as *const libc::c_char,
61189                        flags: 0,
61190                        begin_search_type: KSPEC_BS_INVALID,
61191                        bs: C2RustUnnamed_3 {
61192                            index: C2RustUnnamed_5 { pos: 0 },
61193                        },
61194                        find_keys_type: KSPEC_FK_INVALID,
61195                        fk: C2RustUnnamed_0 {
61196                            range: C2RustUnnamed_2 {
61197                                lastkey: 0,
61198                                keystep: 0,
61199                                limit: 0,
61200                            },
61201                        },
61202                    },
61203                    keySpec {
61204                        notes: 0 as *const libc::c_char,
61205                        flags: 0,
61206                        begin_search_type: KSPEC_BS_INVALID,
61207                        bs: C2RustUnnamed_3 {
61208                            index: C2RustUnnamed_5 { pos: 0 },
61209                        },
61210                        find_keys_type: KSPEC_FK_INVALID,
61211                        fk: C2RustUnnamed_0 {
61212                            range: C2RustUnnamed_2 {
61213                                lastkey: 0,
61214                                keystep: 0,
61215                                limit: 0,
61216                            },
61217                        },
61218                    },
61219                ],
61220                getkeys_proc: Some(
61221                    zmpopGetKeys
61222                        as unsafe extern "C" fn(
61223                            *mut redisCommand,
61224                            *mut *mut robj,
61225                            libc::c_int,
61226                            *mut getKeysResult,
61227                        ) -> libc::c_int,
61228                ),
61229                subcommands: 0 as *const redisCommand as *mut redisCommand,
61230                args: ZMPOP_Args.as_ptr() as *mut _,
61231                microseconds: 0,
61232                calls: 0,
61233                rejected_calls: 0,
61234                failed_calls: 0,
61235                id: 0,
61236                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61237                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61238                key_specs: 0 as *const keySpec as *mut keySpec,
61239                legacy_range_key_spec: keySpec {
61240                    notes: 0 as *const libc::c_char,
61241                    flags: 0,
61242                    begin_search_type: KSPEC_BS_INVALID,
61243                    bs: C2RustUnnamed_3 {
61244                        index: C2RustUnnamed_5 { pos: 0 },
61245                    },
61246                    find_keys_type: KSPEC_FK_INVALID,
61247                    fk: C2RustUnnamed_0 {
61248                        range: C2RustUnnamed_2 {
61249                            lastkey: 0,
61250                            keystep: 0,
61251                            limit: 0,
61252                        },
61253                    },
61254                },
61255                num_args: 0,
61256                num_history: 0,
61257                num_tips: 0,
61258                key_specs_num: 0,
61259                key_specs_max: 0,
61260                subcommands_dict: 0 as *const dict as *mut dict,
61261                parent: 0 as *const redisCommand as *mut redisCommand,
61262                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61263            };
61264            init
61265        },
61266        {
61267            let mut init = redisCommand {
61268                declared_name: b"zmscore\0" as *const u8 as *const libc::c_char,
61269                summary: b"Get the score associated with the given members in a sorted set\0"
61270                    as *const u8 as *const libc::c_char,
61271                complexity: b"O(N) where N is the number of members being requested.\0"
61272                    as *const u8 as *const libc::c_char,
61273                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
61274                doc_flags: 0 as libc::c_int,
61275                replaced_by: 0 as *const libc::c_char,
61276                deprecated_since: 0 as *const libc::c_char,
61277                group: COMMAND_GROUP_SORTED_SET,
61278                history: 0 as *const commandHistory as *mut commandHistory,
61279                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61280                proc_0: Some(zmscoreCommand as unsafe extern "C" fn(*mut client) -> ()),
61281                arity: -(3 as libc::c_int),
61282                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
61283                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
61284                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61285                    as uint64_t,
61286                key_specs_static: [
61287                    {
61288                        let mut init = keySpec {
61289                            notes: 0 as *const libc::c_char,
61290                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61291                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
61292                            begin_search_type: KSPEC_BS_INDEX,
61293                            bs: C2RustUnnamed_3 {
61294                                index: {
61295                                    let mut init = C2RustUnnamed_5 {
61296                                        pos: 1 as libc::c_int,
61297                                    };
61298                                    init
61299                                },
61300                            },
61301                            find_keys_type: KSPEC_FK_RANGE,
61302                            fk: C2RustUnnamed_0 {
61303                                range: {
61304                                    let mut init = C2RustUnnamed_2 {
61305                                        lastkey: 0 as libc::c_int,
61306                                        keystep: 1 as libc::c_int,
61307                                        limit: 0 as libc::c_int,
61308                                    };
61309                                    init
61310                                },
61311                            },
61312                        };
61313                        init
61314                    },
61315                    keySpec {
61316                        notes: 0 as *const libc::c_char,
61317                        flags: 0,
61318                        begin_search_type: KSPEC_BS_INVALID,
61319                        bs: C2RustUnnamed_3 {
61320                            index: C2RustUnnamed_5 { pos: 0 },
61321                        },
61322                        find_keys_type: KSPEC_FK_INVALID,
61323                        fk: C2RustUnnamed_0 {
61324                            range: C2RustUnnamed_2 {
61325                                lastkey: 0,
61326                                keystep: 0,
61327                                limit: 0,
61328                            },
61329                        },
61330                    },
61331                    keySpec {
61332                        notes: 0 as *const libc::c_char,
61333                        flags: 0,
61334                        begin_search_type: KSPEC_BS_INVALID,
61335                        bs: C2RustUnnamed_3 {
61336                            index: C2RustUnnamed_5 { pos: 0 },
61337                        },
61338                        find_keys_type: KSPEC_FK_INVALID,
61339                        fk: C2RustUnnamed_0 {
61340                            range: C2RustUnnamed_2 {
61341                                lastkey: 0,
61342                                keystep: 0,
61343                                limit: 0,
61344                            },
61345                        },
61346                    },
61347                    keySpec {
61348                        notes: 0 as *const libc::c_char,
61349                        flags: 0,
61350                        begin_search_type: KSPEC_BS_INVALID,
61351                        bs: C2RustUnnamed_3 {
61352                            index: C2RustUnnamed_5 { pos: 0 },
61353                        },
61354                        find_keys_type: KSPEC_FK_INVALID,
61355                        fk: C2RustUnnamed_0 {
61356                            range: C2RustUnnamed_2 {
61357                                lastkey: 0,
61358                                keystep: 0,
61359                                limit: 0,
61360                            },
61361                        },
61362                    },
61363                ],
61364                getkeys_proc: None,
61365                subcommands: 0 as *const redisCommand as *mut redisCommand,
61366                args: ZMSCORE_Args.as_ptr() as *mut _,
61367                microseconds: 0,
61368                calls: 0,
61369                rejected_calls: 0,
61370                failed_calls: 0,
61371                id: 0,
61372                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61373                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61374                key_specs: 0 as *const keySpec as *mut keySpec,
61375                legacy_range_key_spec: keySpec {
61376                    notes: 0 as *const libc::c_char,
61377                    flags: 0,
61378                    begin_search_type: KSPEC_BS_INVALID,
61379                    bs: C2RustUnnamed_3 {
61380                        index: C2RustUnnamed_5 { pos: 0 },
61381                    },
61382                    find_keys_type: KSPEC_FK_INVALID,
61383                    fk: C2RustUnnamed_0 {
61384                        range: C2RustUnnamed_2 {
61385                            lastkey: 0,
61386                            keystep: 0,
61387                            limit: 0,
61388                        },
61389                    },
61390                },
61391                num_args: 0,
61392                num_history: 0,
61393                num_tips: 0,
61394                key_specs_num: 0,
61395                key_specs_max: 0,
61396                subcommands_dict: 0 as *const dict as *mut dict,
61397                parent: 0 as *const redisCommand as *mut redisCommand,
61398                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61399            };
61400            init
61401        },
61402        {
61403            let mut init = redisCommand {
61404                declared_name: b"zpopmax\0" as *const u8 as *const libc::c_char,
61405                summary: b"Remove and return members with the highest scores in a sorted set\0"
61406                    as *const u8 as *const libc::c_char,
61407                complexity: b"O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.\0"
61408                    as *const u8 as *const libc::c_char,
61409                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
61410                doc_flags: 0 as libc::c_int,
61411                replaced_by: 0 as *const libc::c_char,
61412                deprecated_since: 0 as *const libc::c_char,
61413                group: COMMAND_GROUP_SORTED_SET,
61414                history: 0 as *const commandHistory as *mut commandHistory,
61415                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61416                proc_0: Some(zpopmaxCommand as unsafe extern "C" fn(*mut client) -> ()),
61417                arity: -(2 as libc::c_int),
61418                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61419                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
61420                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61421                    as uint64_t,
61422                key_specs_static: [
61423                    {
61424                        let mut init = keySpec {
61425                            notes: 0 as *const libc::c_char,
61426                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
61427                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
61428                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
61429                            begin_search_type: KSPEC_BS_INDEX,
61430                            bs: C2RustUnnamed_3 {
61431                                index: {
61432                                    let mut init = C2RustUnnamed_5 {
61433                                        pos: 1 as libc::c_int,
61434                                    };
61435                                    init
61436                                },
61437                            },
61438                            find_keys_type: KSPEC_FK_RANGE,
61439                            fk: C2RustUnnamed_0 {
61440                                range: {
61441                                    let mut init = C2RustUnnamed_2 {
61442                                        lastkey: 0 as libc::c_int,
61443                                        keystep: 1 as libc::c_int,
61444                                        limit: 0 as libc::c_int,
61445                                    };
61446                                    init
61447                                },
61448                            },
61449                        };
61450                        init
61451                    },
61452                    keySpec {
61453                        notes: 0 as *const libc::c_char,
61454                        flags: 0,
61455                        begin_search_type: KSPEC_BS_INVALID,
61456                        bs: C2RustUnnamed_3 {
61457                            index: C2RustUnnamed_5 { pos: 0 },
61458                        },
61459                        find_keys_type: KSPEC_FK_INVALID,
61460                        fk: C2RustUnnamed_0 {
61461                            range: C2RustUnnamed_2 {
61462                                lastkey: 0,
61463                                keystep: 0,
61464                                limit: 0,
61465                            },
61466                        },
61467                    },
61468                    keySpec {
61469                        notes: 0 as *const libc::c_char,
61470                        flags: 0,
61471                        begin_search_type: KSPEC_BS_INVALID,
61472                        bs: C2RustUnnamed_3 {
61473                            index: C2RustUnnamed_5 { pos: 0 },
61474                        },
61475                        find_keys_type: KSPEC_FK_INVALID,
61476                        fk: C2RustUnnamed_0 {
61477                            range: C2RustUnnamed_2 {
61478                                lastkey: 0,
61479                                keystep: 0,
61480                                limit: 0,
61481                            },
61482                        },
61483                    },
61484                    keySpec {
61485                        notes: 0 as *const libc::c_char,
61486                        flags: 0,
61487                        begin_search_type: KSPEC_BS_INVALID,
61488                        bs: C2RustUnnamed_3 {
61489                            index: C2RustUnnamed_5 { pos: 0 },
61490                        },
61491                        find_keys_type: KSPEC_FK_INVALID,
61492                        fk: C2RustUnnamed_0 {
61493                            range: C2RustUnnamed_2 {
61494                                lastkey: 0,
61495                                keystep: 0,
61496                                limit: 0,
61497                            },
61498                        },
61499                    },
61500                ],
61501                getkeys_proc: None,
61502                subcommands: 0 as *const redisCommand as *mut redisCommand,
61503                args: ZPOPMAX_Args.as_ptr() as *mut _,
61504                microseconds: 0,
61505                calls: 0,
61506                rejected_calls: 0,
61507                failed_calls: 0,
61508                id: 0,
61509                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61510                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61511                key_specs: 0 as *const keySpec as *mut keySpec,
61512                legacy_range_key_spec: keySpec {
61513                    notes: 0 as *const libc::c_char,
61514                    flags: 0,
61515                    begin_search_type: KSPEC_BS_INVALID,
61516                    bs: C2RustUnnamed_3 {
61517                        index: C2RustUnnamed_5 { pos: 0 },
61518                    },
61519                    find_keys_type: KSPEC_FK_INVALID,
61520                    fk: C2RustUnnamed_0 {
61521                        range: C2RustUnnamed_2 {
61522                            lastkey: 0,
61523                            keystep: 0,
61524                            limit: 0,
61525                        },
61526                    },
61527                },
61528                num_args: 0,
61529                num_history: 0,
61530                num_tips: 0,
61531                key_specs_num: 0,
61532                key_specs_max: 0,
61533                subcommands_dict: 0 as *const dict as *mut dict,
61534                parent: 0 as *const redisCommand as *mut redisCommand,
61535                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61536            };
61537            init
61538        },
61539        {
61540            let mut init = redisCommand {
61541                declared_name: b"zpopmin\0" as *const u8 as *const libc::c_char,
61542                summary: b"Remove and return members with the lowest scores in a sorted set\0"
61543                    as *const u8 as *const libc::c_char,
61544                complexity: b"O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.\0"
61545                    as *const u8 as *const libc::c_char,
61546                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
61547                doc_flags: 0 as libc::c_int,
61548                replaced_by: 0 as *const libc::c_char,
61549                deprecated_since: 0 as *const libc::c_char,
61550                group: COMMAND_GROUP_SORTED_SET,
61551                history: 0 as *const commandHistory as *mut commandHistory,
61552                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61553                proc_0: Some(zpopminCommand as unsafe extern "C" fn(*mut client) -> ()),
61554                arity: -(2 as libc::c_int),
61555                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61556                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
61557                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61558                    as uint64_t,
61559                key_specs_static: [
61560                    {
61561                        let mut init = keySpec {
61562                            notes: 0 as *const libc::c_char,
61563                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
61564                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
61565                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
61566                            begin_search_type: KSPEC_BS_INDEX,
61567                            bs: C2RustUnnamed_3 {
61568                                index: {
61569                                    let mut init = C2RustUnnamed_5 {
61570                                        pos: 1 as libc::c_int,
61571                                    };
61572                                    init
61573                                },
61574                            },
61575                            find_keys_type: KSPEC_FK_RANGE,
61576                            fk: C2RustUnnamed_0 {
61577                                range: {
61578                                    let mut init = C2RustUnnamed_2 {
61579                                        lastkey: 0 as libc::c_int,
61580                                        keystep: 1 as libc::c_int,
61581                                        limit: 0 as libc::c_int,
61582                                    };
61583                                    init
61584                                },
61585                            },
61586                        };
61587                        init
61588                    },
61589                    keySpec {
61590                        notes: 0 as *const libc::c_char,
61591                        flags: 0,
61592                        begin_search_type: KSPEC_BS_INVALID,
61593                        bs: C2RustUnnamed_3 {
61594                            index: C2RustUnnamed_5 { pos: 0 },
61595                        },
61596                        find_keys_type: KSPEC_FK_INVALID,
61597                        fk: C2RustUnnamed_0 {
61598                            range: C2RustUnnamed_2 {
61599                                lastkey: 0,
61600                                keystep: 0,
61601                                limit: 0,
61602                            },
61603                        },
61604                    },
61605                    keySpec {
61606                        notes: 0 as *const libc::c_char,
61607                        flags: 0,
61608                        begin_search_type: KSPEC_BS_INVALID,
61609                        bs: C2RustUnnamed_3 {
61610                            index: C2RustUnnamed_5 { pos: 0 },
61611                        },
61612                        find_keys_type: KSPEC_FK_INVALID,
61613                        fk: C2RustUnnamed_0 {
61614                            range: C2RustUnnamed_2 {
61615                                lastkey: 0,
61616                                keystep: 0,
61617                                limit: 0,
61618                            },
61619                        },
61620                    },
61621                    keySpec {
61622                        notes: 0 as *const libc::c_char,
61623                        flags: 0,
61624                        begin_search_type: KSPEC_BS_INVALID,
61625                        bs: C2RustUnnamed_3 {
61626                            index: C2RustUnnamed_5 { pos: 0 },
61627                        },
61628                        find_keys_type: KSPEC_FK_INVALID,
61629                        fk: C2RustUnnamed_0 {
61630                            range: C2RustUnnamed_2 {
61631                                lastkey: 0,
61632                                keystep: 0,
61633                                limit: 0,
61634                            },
61635                        },
61636                    },
61637                ],
61638                getkeys_proc: None,
61639                subcommands: 0 as *const redisCommand as *mut redisCommand,
61640                args: ZPOPMIN_Args.as_ptr() as *mut _,
61641                microseconds: 0,
61642                calls: 0,
61643                rejected_calls: 0,
61644                failed_calls: 0,
61645                id: 0,
61646                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61647                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61648                key_specs: 0 as *const keySpec as *mut keySpec,
61649                legacy_range_key_spec: keySpec {
61650                    notes: 0 as *const libc::c_char,
61651                    flags: 0,
61652                    begin_search_type: KSPEC_BS_INVALID,
61653                    bs: C2RustUnnamed_3 {
61654                        index: C2RustUnnamed_5 { pos: 0 },
61655                    },
61656                    find_keys_type: KSPEC_FK_INVALID,
61657                    fk: C2RustUnnamed_0 {
61658                        range: C2RustUnnamed_2 {
61659                            lastkey: 0,
61660                            keystep: 0,
61661                            limit: 0,
61662                        },
61663                    },
61664                },
61665                num_args: 0,
61666                num_history: 0,
61667                num_tips: 0,
61668                key_specs_num: 0,
61669                key_specs_max: 0,
61670                subcommands_dict: 0 as *const dict as *mut dict,
61671                parent: 0 as *const redisCommand as *mut redisCommand,
61672                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61673            };
61674            init
61675        },
61676        {
61677            let mut init = redisCommand {
61678                declared_name: b"zrandmember\0" as *const u8 as *const libc::c_char,
61679                summary: b"Get one or multiple random elements from a sorted set\0"
61680                    as *const u8 as *const libc::c_char,
61681                complexity: b"O(N) where N is the number of elements returned\0"
61682                    as *const u8 as *const libc::c_char,
61683                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
61684                doc_flags: 0 as libc::c_int,
61685                replaced_by: 0 as *const libc::c_char,
61686                deprecated_since: 0 as *const libc::c_char,
61687                group: COMMAND_GROUP_SORTED_SET,
61688                history: 0 as *const commandHistory as *mut commandHistory,
61689                tips: ZRANDMEMBER_tips.as_ptr() as *mut _,
61690                proc_0: Some(
61691                    zrandmemberCommand as unsafe extern "C" fn(*mut client) -> (),
61692                ),
61693                arity: -(2 as libc::c_int),
61694                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
61695                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61696                    as uint64_t,
61697                key_specs_static: [
61698                    {
61699                        let mut init = keySpec {
61700                            notes: 0 as *const libc::c_char,
61701                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61702                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
61703                            begin_search_type: KSPEC_BS_INDEX,
61704                            bs: C2RustUnnamed_3 {
61705                                index: {
61706                                    let mut init = C2RustUnnamed_5 {
61707                                        pos: 1 as libc::c_int,
61708                                    };
61709                                    init
61710                                },
61711                            },
61712                            find_keys_type: KSPEC_FK_RANGE,
61713                            fk: C2RustUnnamed_0 {
61714                                range: {
61715                                    let mut init = C2RustUnnamed_2 {
61716                                        lastkey: 0 as libc::c_int,
61717                                        keystep: 1 as libc::c_int,
61718                                        limit: 0 as libc::c_int,
61719                                    };
61720                                    init
61721                                },
61722                            },
61723                        };
61724                        init
61725                    },
61726                    keySpec {
61727                        notes: 0 as *const libc::c_char,
61728                        flags: 0,
61729                        begin_search_type: KSPEC_BS_INVALID,
61730                        bs: C2RustUnnamed_3 {
61731                            index: C2RustUnnamed_5 { pos: 0 },
61732                        },
61733                        find_keys_type: KSPEC_FK_INVALID,
61734                        fk: C2RustUnnamed_0 {
61735                            range: C2RustUnnamed_2 {
61736                                lastkey: 0,
61737                                keystep: 0,
61738                                limit: 0,
61739                            },
61740                        },
61741                    },
61742                    keySpec {
61743                        notes: 0 as *const libc::c_char,
61744                        flags: 0,
61745                        begin_search_type: KSPEC_BS_INVALID,
61746                        bs: C2RustUnnamed_3 {
61747                            index: C2RustUnnamed_5 { pos: 0 },
61748                        },
61749                        find_keys_type: KSPEC_FK_INVALID,
61750                        fk: C2RustUnnamed_0 {
61751                            range: C2RustUnnamed_2 {
61752                                lastkey: 0,
61753                                keystep: 0,
61754                                limit: 0,
61755                            },
61756                        },
61757                    },
61758                    keySpec {
61759                        notes: 0 as *const libc::c_char,
61760                        flags: 0,
61761                        begin_search_type: KSPEC_BS_INVALID,
61762                        bs: C2RustUnnamed_3 {
61763                            index: C2RustUnnamed_5 { pos: 0 },
61764                        },
61765                        find_keys_type: KSPEC_FK_INVALID,
61766                        fk: C2RustUnnamed_0 {
61767                            range: C2RustUnnamed_2 {
61768                                lastkey: 0,
61769                                keystep: 0,
61770                                limit: 0,
61771                            },
61772                        },
61773                    },
61774                ],
61775                getkeys_proc: None,
61776                subcommands: 0 as *const redisCommand as *mut redisCommand,
61777                args: ZRANDMEMBER_Args.as_ptr() as *mut _,
61778                microseconds: 0,
61779                calls: 0,
61780                rejected_calls: 0,
61781                failed_calls: 0,
61782                id: 0,
61783                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61784                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61785                key_specs: 0 as *const keySpec as *mut keySpec,
61786                legacy_range_key_spec: keySpec {
61787                    notes: 0 as *const libc::c_char,
61788                    flags: 0,
61789                    begin_search_type: KSPEC_BS_INVALID,
61790                    bs: C2RustUnnamed_3 {
61791                        index: C2RustUnnamed_5 { pos: 0 },
61792                    },
61793                    find_keys_type: KSPEC_FK_INVALID,
61794                    fk: C2RustUnnamed_0 {
61795                        range: C2RustUnnamed_2 {
61796                            lastkey: 0,
61797                            keystep: 0,
61798                            limit: 0,
61799                        },
61800                    },
61801                },
61802                num_args: 0,
61803                num_history: 0,
61804                num_tips: 0,
61805                key_specs_num: 0,
61806                key_specs_max: 0,
61807                subcommands_dict: 0 as *const dict as *mut dict,
61808                parent: 0 as *const redisCommand as *mut redisCommand,
61809                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61810            };
61811            init
61812        },
61813        {
61814            let mut init = redisCommand {
61815                declared_name: b"zrange\0" as *const u8 as *const libc::c_char,
61816                summary: b"Return a range of members in a sorted set\0" as *const u8
61817                    as *const libc::c_char,
61818                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.\0"
61819                    as *const u8 as *const libc::c_char,
61820                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
61821                doc_flags: 0 as libc::c_int,
61822                replaced_by: 0 as *const libc::c_char,
61823                deprecated_since: 0 as *const libc::c_char,
61824                group: COMMAND_GROUP_SORTED_SET,
61825                history: ZRANGE_History.as_ptr() as *mut _,
61826                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61827                proc_0: Some(zrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
61828                arity: -(4 as libc::c_int),
61829                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
61830                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61831                    as uint64_t,
61832                key_specs_static: [
61833                    {
61834                        let mut init = keySpec {
61835                            notes: 0 as *const libc::c_char,
61836                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61837                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
61838                            begin_search_type: KSPEC_BS_INDEX,
61839                            bs: C2RustUnnamed_3 {
61840                                index: {
61841                                    let mut init = C2RustUnnamed_5 {
61842                                        pos: 1 as libc::c_int,
61843                                    };
61844                                    init
61845                                },
61846                            },
61847                            find_keys_type: KSPEC_FK_RANGE,
61848                            fk: C2RustUnnamed_0 {
61849                                range: {
61850                                    let mut init = C2RustUnnamed_2 {
61851                                        lastkey: 0 as libc::c_int,
61852                                        keystep: 1 as libc::c_int,
61853                                        limit: 0 as libc::c_int,
61854                                    };
61855                                    init
61856                                },
61857                            },
61858                        };
61859                        init
61860                    },
61861                    keySpec {
61862                        notes: 0 as *const libc::c_char,
61863                        flags: 0,
61864                        begin_search_type: KSPEC_BS_INVALID,
61865                        bs: C2RustUnnamed_3 {
61866                            index: C2RustUnnamed_5 { pos: 0 },
61867                        },
61868                        find_keys_type: KSPEC_FK_INVALID,
61869                        fk: C2RustUnnamed_0 {
61870                            range: C2RustUnnamed_2 {
61871                                lastkey: 0,
61872                                keystep: 0,
61873                                limit: 0,
61874                            },
61875                        },
61876                    },
61877                    keySpec {
61878                        notes: 0 as *const libc::c_char,
61879                        flags: 0,
61880                        begin_search_type: KSPEC_BS_INVALID,
61881                        bs: C2RustUnnamed_3 {
61882                            index: C2RustUnnamed_5 { pos: 0 },
61883                        },
61884                        find_keys_type: KSPEC_FK_INVALID,
61885                        fk: C2RustUnnamed_0 {
61886                            range: C2RustUnnamed_2 {
61887                                lastkey: 0,
61888                                keystep: 0,
61889                                limit: 0,
61890                            },
61891                        },
61892                    },
61893                    keySpec {
61894                        notes: 0 as *const libc::c_char,
61895                        flags: 0,
61896                        begin_search_type: KSPEC_BS_INVALID,
61897                        bs: C2RustUnnamed_3 {
61898                            index: C2RustUnnamed_5 { pos: 0 },
61899                        },
61900                        find_keys_type: KSPEC_FK_INVALID,
61901                        fk: C2RustUnnamed_0 {
61902                            range: C2RustUnnamed_2 {
61903                                lastkey: 0,
61904                                keystep: 0,
61905                                limit: 0,
61906                            },
61907                        },
61908                    },
61909                ],
61910                getkeys_proc: None,
61911                subcommands: 0 as *const redisCommand as *mut redisCommand,
61912                args: ZRANGE_Args.as_ptr() as *mut _,
61913                microseconds: 0,
61914                calls: 0,
61915                rejected_calls: 0,
61916                failed_calls: 0,
61917                id: 0,
61918                fullname: 0 as *const libc::c_char as *mut libc::c_char,
61919                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
61920                key_specs: 0 as *const keySpec as *mut keySpec,
61921                legacy_range_key_spec: keySpec {
61922                    notes: 0 as *const libc::c_char,
61923                    flags: 0,
61924                    begin_search_type: KSPEC_BS_INVALID,
61925                    bs: C2RustUnnamed_3 {
61926                        index: C2RustUnnamed_5 { pos: 0 },
61927                    },
61928                    find_keys_type: KSPEC_FK_INVALID,
61929                    fk: C2RustUnnamed_0 {
61930                        range: C2RustUnnamed_2 {
61931                            lastkey: 0,
61932                            keystep: 0,
61933                            limit: 0,
61934                        },
61935                    },
61936                },
61937                num_args: 0,
61938                num_history: 0,
61939                num_tips: 0,
61940                key_specs_num: 0,
61941                key_specs_max: 0,
61942                subcommands_dict: 0 as *const dict as *mut dict,
61943                parent: 0 as *const redisCommand as *mut redisCommand,
61944                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
61945            };
61946            init
61947        },
61948        {
61949            let mut init = redisCommand {
61950                declared_name: b"zrangebylex\0" as *const u8 as *const libc::c_char,
61951                summary: b"Return a range of members in a sorted set, by lexicographical range\0"
61952                    as *const u8 as *const libc::c_char,
61953                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).\0"
61954                    as *const u8 as *const libc::c_char,
61955                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
61956                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
61957                replaced_by: b"`ZRANGE` with the `BYLEX` argument\0" as *const u8
61958                    as *const libc::c_char,
61959                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
61960                group: COMMAND_GROUP_SORTED_SET,
61961                history: 0 as *const commandHistory as *mut commandHistory,
61962                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
61963                proc_0: Some(
61964                    zrangebylexCommand as unsafe extern "C" fn(*mut client) -> (),
61965                ),
61966                arity: -(4 as libc::c_int),
61967                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
61968                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
61969                    as uint64_t,
61970                key_specs_static: [
61971                    {
61972                        let mut init = keySpec {
61973                            notes: 0 as *const libc::c_char,
61974                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
61975                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
61976                            begin_search_type: KSPEC_BS_INDEX,
61977                            bs: C2RustUnnamed_3 {
61978                                index: {
61979                                    let mut init = C2RustUnnamed_5 {
61980                                        pos: 1 as libc::c_int,
61981                                    };
61982                                    init
61983                                },
61984                            },
61985                            find_keys_type: KSPEC_FK_RANGE,
61986                            fk: C2RustUnnamed_0 {
61987                                range: {
61988                                    let mut init = C2RustUnnamed_2 {
61989                                        lastkey: 0 as libc::c_int,
61990                                        keystep: 1 as libc::c_int,
61991                                        limit: 0 as libc::c_int,
61992                                    };
61993                                    init
61994                                },
61995                            },
61996                        };
61997                        init
61998                    },
61999                    keySpec {
62000                        notes: 0 as *const libc::c_char,
62001                        flags: 0,
62002                        begin_search_type: KSPEC_BS_INVALID,
62003                        bs: C2RustUnnamed_3 {
62004                            index: C2RustUnnamed_5 { pos: 0 },
62005                        },
62006                        find_keys_type: KSPEC_FK_INVALID,
62007                        fk: C2RustUnnamed_0 {
62008                            range: C2RustUnnamed_2 {
62009                                lastkey: 0,
62010                                keystep: 0,
62011                                limit: 0,
62012                            },
62013                        },
62014                    },
62015                    keySpec {
62016                        notes: 0 as *const libc::c_char,
62017                        flags: 0,
62018                        begin_search_type: KSPEC_BS_INVALID,
62019                        bs: C2RustUnnamed_3 {
62020                            index: C2RustUnnamed_5 { pos: 0 },
62021                        },
62022                        find_keys_type: KSPEC_FK_INVALID,
62023                        fk: C2RustUnnamed_0 {
62024                            range: C2RustUnnamed_2 {
62025                                lastkey: 0,
62026                                keystep: 0,
62027                                limit: 0,
62028                            },
62029                        },
62030                    },
62031                    keySpec {
62032                        notes: 0 as *const libc::c_char,
62033                        flags: 0,
62034                        begin_search_type: KSPEC_BS_INVALID,
62035                        bs: C2RustUnnamed_3 {
62036                            index: C2RustUnnamed_5 { pos: 0 },
62037                        },
62038                        find_keys_type: KSPEC_FK_INVALID,
62039                        fk: C2RustUnnamed_0 {
62040                            range: C2RustUnnamed_2 {
62041                                lastkey: 0,
62042                                keystep: 0,
62043                                limit: 0,
62044                            },
62045                        },
62046                    },
62047                ],
62048                getkeys_proc: None,
62049                subcommands: 0 as *const redisCommand as *mut redisCommand,
62050                args: ZRANGEBYLEX_Args.as_ptr() as *mut _,
62051                microseconds: 0,
62052                calls: 0,
62053                rejected_calls: 0,
62054                failed_calls: 0,
62055                id: 0,
62056                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62057                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62058                key_specs: 0 as *const keySpec as *mut keySpec,
62059                legacy_range_key_spec: keySpec {
62060                    notes: 0 as *const libc::c_char,
62061                    flags: 0,
62062                    begin_search_type: KSPEC_BS_INVALID,
62063                    bs: C2RustUnnamed_3 {
62064                        index: C2RustUnnamed_5 { pos: 0 },
62065                    },
62066                    find_keys_type: KSPEC_FK_INVALID,
62067                    fk: C2RustUnnamed_0 {
62068                        range: C2RustUnnamed_2 {
62069                            lastkey: 0,
62070                            keystep: 0,
62071                            limit: 0,
62072                        },
62073                    },
62074                },
62075                num_args: 0,
62076                num_history: 0,
62077                num_tips: 0,
62078                key_specs_num: 0,
62079                key_specs_max: 0,
62080                subcommands_dict: 0 as *const dict as *mut dict,
62081                parent: 0 as *const redisCommand as *mut redisCommand,
62082                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62083            };
62084            init
62085        },
62086        {
62087            let mut init = redisCommand {
62088                declared_name: b"zrangebyscore\0" as *const u8 as *const libc::c_char,
62089                summary: b"Return a range of members in a sorted set, by score\0"
62090                    as *const u8 as *const libc::c_char,
62091                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).\0"
62092                    as *const u8 as *const libc::c_char,
62093                since: b"1.0.5\0" as *const u8 as *const libc::c_char,
62094                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
62095                replaced_by: b"`ZRANGE` with the `BYSCORE` argument\0" as *const u8
62096                    as *const libc::c_char,
62097                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
62098                group: COMMAND_GROUP_SORTED_SET,
62099                history: ZRANGEBYSCORE_History.as_ptr() as *mut _,
62100                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62101                proc_0: Some(
62102                    zrangebyscoreCommand as unsafe extern "C" fn(*mut client) -> (),
62103                ),
62104                arity: -(4 as libc::c_int),
62105                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
62106                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62107                    as uint64_t,
62108                key_specs_static: [
62109                    {
62110                        let mut init = keySpec {
62111                            notes: 0 as *const libc::c_char,
62112                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
62113                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
62114                            begin_search_type: KSPEC_BS_INDEX,
62115                            bs: C2RustUnnamed_3 {
62116                                index: {
62117                                    let mut init = C2RustUnnamed_5 {
62118                                        pos: 1 as libc::c_int,
62119                                    };
62120                                    init
62121                                },
62122                            },
62123                            find_keys_type: KSPEC_FK_RANGE,
62124                            fk: C2RustUnnamed_0 {
62125                                range: {
62126                                    let mut init = C2RustUnnamed_2 {
62127                                        lastkey: 0 as libc::c_int,
62128                                        keystep: 1 as libc::c_int,
62129                                        limit: 0 as libc::c_int,
62130                                    };
62131                                    init
62132                                },
62133                            },
62134                        };
62135                        init
62136                    },
62137                    keySpec {
62138                        notes: 0 as *const libc::c_char,
62139                        flags: 0,
62140                        begin_search_type: KSPEC_BS_INVALID,
62141                        bs: C2RustUnnamed_3 {
62142                            index: C2RustUnnamed_5 { pos: 0 },
62143                        },
62144                        find_keys_type: KSPEC_FK_INVALID,
62145                        fk: C2RustUnnamed_0 {
62146                            range: C2RustUnnamed_2 {
62147                                lastkey: 0,
62148                                keystep: 0,
62149                                limit: 0,
62150                            },
62151                        },
62152                    },
62153                    keySpec {
62154                        notes: 0 as *const libc::c_char,
62155                        flags: 0,
62156                        begin_search_type: KSPEC_BS_INVALID,
62157                        bs: C2RustUnnamed_3 {
62158                            index: C2RustUnnamed_5 { pos: 0 },
62159                        },
62160                        find_keys_type: KSPEC_FK_INVALID,
62161                        fk: C2RustUnnamed_0 {
62162                            range: C2RustUnnamed_2 {
62163                                lastkey: 0,
62164                                keystep: 0,
62165                                limit: 0,
62166                            },
62167                        },
62168                    },
62169                    keySpec {
62170                        notes: 0 as *const libc::c_char,
62171                        flags: 0,
62172                        begin_search_type: KSPEC_BS_INVALID,
62173                        bs: C2RustUnnamed_3 {
62174                            index: C2RustUnnamed_5 { pos: 0 },
62175                        },
62176                        find_keys_type: KSPEC_FK_INVALID,
62177                        fk: C2RustUnnamed_0 {
62178                            range: C2RustUnnamed_2 {
62179                                lastkey: 0,
62180                                keystep: 0,
62181                                limit: 0,
62182                            },
62183                        },
62184                    },
62185                ],
62186                getkeys_proc: None,
62187                subcommands: 0 as *const redisCommand as *mut redisCommand,
62188                args: ZRANGEBYSCORE_Args.as_ptr() as *mut _,
62189                microseconds: 0,
62190                calls: 0,
62191                rejected_calls: 0,
62192                failed_calls: 0,
62193                id: 0,
62194                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62195                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62196                key_specs: 0 as *const keySpec as *mut keySpec,
62197                legacy_range_key_spec: keySpec {
62198                    notes: 0 as *const libc::c_char,
62199                    flags: 0,
62200                    begin_search_type: KSPEC_BS_INVALID,
62201                    bs: C2RustUnnamed_3 {
62202                        index: C2RustUnnamed_5 { pos: 0 },
62203                    },
62204                    find_keys_type: KSPEC_FK_INVALID,
62205                    fk: C2RustUnnamed_0 {
62206                        range: C2RustUnnamed_2 {
62207                            lastkey: 0,
62208                            keystep: 0,
62209                            limit: 0,
62210                        },
62211                    },
62212                },
62213                num_args: 0,
62214                num_history: 0,
62215                num_tips: 0,
62216                key_specs_num: 0,
62217                key_specs_max: 0,
62218                subcommands_dict: 0 as *const dict as *mut dict,
62219                parent: 0 as *const redisCommand as *mut redisCommand,
62220                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62221            };
62222            init
62223        },
62224        {
62225            let mut init = redisCommand {
62226                declared_name: b"zrangestore\0" as *const u8 as *const libc::c_char,
62227                summary: b"Store a range of members from sorted set into another key\0"
62228                    as *const u8 as *const libc::c_char,
62229                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.\0"
62230                    as *const u8 as *const libc::c_char,
62231                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
62232                doc_flags: 0 as libc::c_int,
62233                replaced_by: 0 as *const libc::c_char,
62234                deprecated_since: 0 as *const libc::c_char,
62235                group: COMMAND_GROUP_SORTED_SET,
62236                history: 0 as *const commandHistory as *mut commandHistory,
62237                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62238                proc_0: Some(
62239                    zrangestoreCommand as unsafe extern "C" fn(*mut client) -> (),
62240                ),
62241                arity: -(5 as libc::c_int),
62242                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
62243                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
62244                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62245                    as uint64_t,
62246                key_specs_static: [
62247                    {
62248                        let mut init = keySpec {
62249                            notes: 0 as *const libc::c_char,
62250                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
62251                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
62252                            begin_search_type: KSPEC_BS_INDEX,
62253                            bs: C2RustUnnamed_3 {
62254                                index: {
62255                                    let mut init = C2RustUnnamed_5 {
62256                                        pos: 1 as libc::c_int,
62257                                    };
62258                                    init
62259                                },
62260                            },
62261                            find_keys_type: KSPEC_FK_RANGE,
62262                            fk: C2RustUnnamed_0 {
62263                                range: {
62264                                    let mut init = C2RustUnnamed_2 {
62265                                        lastkey: 0 as libc::c_int,
62266                                        keystep: 1 as libc::c_int,
62267                                        limit: 0 as libc::c_int,
62268                                    };
62269                                    init
62270                                },
62271                            },
62272                        };
62273                        init
62274                    },
62275                    {
62276                        let mut init = keySpec {
62277                            notes: 0 as *const libc::c_char,
62278                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
62279                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
62280                            begin_search_type: KSPEC_BS_INDEX,
62281                            bs: C2RustUnnamed_3 {
62282                                index: {
62283                                    let mut init = C2RustUnnamed_5 {
62284                                        pos: 2 as libc::c_int,
62285                                    };
62286                                    init
62287                                },
62288                            },
62289                            find_keys_type: KSPEC_FK_RANGE,
62290                            fk: C2RustUnnamed_0 {
62291                                range: {
62292                                    let mut init = C2RustUnnamed_2 {
62293                                        lastkey: 0 as libc::c_int,
62294                                        keystep: 1 as libc::c_int,
62295                                        limit: 0 as libc::c_int,
62296                                    };
62297                                    init
62298                                },
62299                            },
62300                        };
62301                        init
62302                    },
62303                    keySpec {
62304                        notes: 0 as *const libc::c_char,
62305                        flags: 0,
62306                        begin_search_type: KSPEC_BS_INVALID,
62307                        bs: C2RustUnnamed_3 {
62308                            index: C2RustUnnamed_5 { pos: 0 },
62309                        },
62310                        find_keys_type: KSPEC_FK_INVALID,
62311                        fk: C2RustUnnamed_0 {
62312                            range: C2RustUnnamed_2 {
62313                                lastkey: 0,
62314                                keystep: 0,
62315                                limit: 0,
62316                            },
62317                        },
62318                    },
62319                    keySpec {
62320                        notes: 0 as *const libc::c_char,
62321                        flags: 0,
62322                        begin_search_type: KSPEC_BS_INVALID,
62323                        bs: C2RustUnnamed_3 {
62324                            index: C2RustUnnamed_5 { pos: 0 },
62325                        },
62326                        find_keys_type: KSPEC_FK_INVALID,
62327                        fk: C2RustUnnamed_0 {
62328                            range: C2RustUnnamed_2 {
62329                                lastkey: 0,
62330                                keystep: 0,
62331                                limit: 0,
62332                            },
62333                        },
62334                    },
62335                ],
62336                getkeys_proc: None,
62337                subcommands: 0 as *const redisCommand as *mut redisCommand,
62338                args: ZRANGESTORE_Args.as_ptr() as *mut _,
62339                microseconds: 0,
62340                calls: 0,
62341                rejected_calls: 0,
62342                failed_calls: 0,
62343                id: 0,
62344                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62345                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62346                key_specs: 0 as *const keySpec as *mut keySpec,
62347                legacy_range_key_spec: keySpec {
62348                    notes: 0 as *const libc::c_char,
62349                    flags: 0,
62350                    begin_search_type: KSPEC_BS_INVALID,
62351                    bs: C2RustUnnamed_3 {
62352                        index: C2RustUnnamed_5 { pos: 0 },
62353                    },
62354                    find_keys_type: KSPEC_FK_INVALID,
62355                    fk: C2RustUnnamed_0 {
62356                        range: C2RustUnnamed_2 {
62357                            lastkey: 0,
62358                            keystep: 0,
62359                            limit: 0,
62360                        },
62361                    },
62362                },
62363                num_args: 0,
62364                num_history: 0,
62365                num_tips: 0,
62366                key_specs_num: 0,
62367                key_specs_max: 0,
62368                subcommands_dict: 0 as *const dict as *mut dict,
62369                parent: 0 as *const redisCommand as *mut redisCommand,
62370                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62371            };
62372            init
62373        },
62374        {
62375            let mut init = redisCommand {
62376                declared_name: b"zrank\0" as *const u8 as *const libc::c_char,
62377                summary: b"Determine the index of a member in a sorted set\0"
62378                    as *const u8 as *const libc::c_char,
62379                complexity: b"O(log(N))\0" as *const u8 as *const libc::c_char,
62380                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
62381                doc_flags: 0 as libc::c_int,
62382                replaced_by: 0 as *const libc::c_char,
62383                deprecated_since: 0 as *const libc::c_char,
62384                group: COMMAND_GROUP_SORTED_SET,
62385                history: 0 as *const commandHistory as *mut commandHistory,
62386                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62387                proc_0: Some(zrankCommand as unsafe extern "C" fn(*mut client) -> ()),
62388                arity: 3 as libc::c_int,
62389                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
62390                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
62391                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62392                    as uint64_t,
62393                key_specs_static: [
62394                    {
62395                        let mut init = keySpec {
62396                            notes: 0 as *const libc::c_char,
62397                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
62398                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
62399                            begin_search_type: KSPEC_BS_INDEX,
62400                            bs: C2RustUnnamed_3 {
62401                                index: {
62402                                    let mut init = C2RustUnnamed_5 {
62403                                        pos: 1 as libc::c_int,
62404                                    };
62405                                    init
62406                                },
62407                            },
62408                            find_keys_type: KSPEC_FK_RANGE,
62409                            fk: C2RustUnnamed_0 {
62410                                range: {
62411                                    let mut init = C2RustUnnamed_2 {
62412                                        lastkey: 0 as libc::c_int,
62413                                        keystep: 1 as libc::c_int,
62414                                        limit: 0 as libc::c_int,
62415                                    };
62416                                    init
62417                                },
62418                            },
62419                        };
62420                        init
62421                    },
62422                    keySpec {
62423                        notes: 0 as *const libc::c_char,
62424                        flags: 0,
62425                        begin_search_type: KSPEC_BS_INVALID,
62426                        bs: C2RustUnnamed_3 {
62427                            index: C2RustUnnamed_5 { pos: 0 },
62428                        },
62429                        find_keys_type: KSPEC_FK_INVALID,
62430                        fk: C2RustUnnamed_0 {
62431                            range: C2RustUnnamed_2 {
62432                                lastkey: 0,
62433                                keystep: 0,
62434                                limit: 0,
62435                            },
62436                        },
62437                    },
62438                    keySpec {
62439                        notes: 0 as *const libc::c_char,
62440                        flags: 0,
62441                        begin_search_type: KSPEC_BS_INVALID,
62442                        bs: C2RustUnnamed_3 {
62443                            index: C2RustUnnamed_5 { pos: 0 },
62444                        },
62445                        find_keys_type: KSPEC_FK_INVALID,
62446                        fk: C2RustUnnamed_0 {
62447                            range: C2RustUnnamed_2 {
62448                                lastkey: 0,
62449                                keystep: 0,
62450                                limit: 0,
62451                            },
62452                        },
62453                    },
62454                    keySpec {
62455                        notes: 0 as *const libc::c_char,
62456                        flags: 0,
62457                        begin_search_type: KSPEC_BS_INVALID,
62458                        bs: C2RustUnnamed_3 {
62459                            index: C2RustUnnamed_5 { pos: 0 },
62460                        },
62461                        find_keys_type: KSPEC_FK_INVALID,
62462                        fk: C2RustUnnamed_0 {
62463                            range: C2RustUnnamed_2 {
62464                                lastkey: 0,
62465                                keystep: 0,
62466                                limit: 0,
62467                            },
62468                        },
62469                    },
62470                ],
62471                getkeys_proc: None,
62472                subcommands: 0 as *const redisCommand as *mut redisCommand,
62473                args: ZRANK_Args.as_ptr() as *mut _,
62474                microseconds: 0,
62475                calls: 0,
62476                rejected_calls: 0,
62477                failed_calls: 0,
62478                id: 0,
62479                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62480                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62481                key_specs: 0 as *const keySpec as *mut keySpec,
62482                legacy_range_key_spec: keySpec {
62483                    notes: 0 as *const libc::c_char,
62484                    flags: 0,
62485                    begin_search_type: KSPEC_BS_INVALID,
62486                    bs: C2RustUnnamed_3 {
62487                        index: C2RustUnnamed_5 { pos: 0 },
62488                    },
62489                    find_keys_type: KSPEC_FK_INVALID,
62490                    fk: C2RustUnnamed_0 {
62491                        range: C2RustUnnamed_2 {
62492                            lastkey: 0,
62493                            keystep: 0,
62494                            limit: 0,
62495                        },
62496                    },
62497                },
62498                num_args: 0,
62499                num_history: 0,
62500                num_tips: 0,
62501                key_specs_num: 0,
62502                key_specs_max: 0,
62503                subcommands_dict: 0 as *const dict as *mut dict,
62504                parent: 0 as *const redisCommand as *mut redisCommand,
62505                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62506            };
62507            init
62508        },
62509        {
62510            let mut init = redisCommand {
62511                declared_name: b"zrem\0" as *const u8 as *const libc::c_char,
62512                summary: b"Remove one or more members from a sorted set\0" as *const u8
62513                    as *const libc::c_char,
62514                complexity: b"O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.\0"
62515                    as *const u8 as *const libc::c_char,
62516                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
62517                doc_flags: 0 as libc::c_int,
62518                replaced_by: 0 as *const libc::c_char,
62519                deprecated_since: 0 as *const libc::c_char,
62520                group: COMMAND_GROUP_SORTED_SET,
62521                history: ZREM_History.as_ptr() as *mut _,
62522                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62523                proc_0: Some(zremCommand as unsafe extern "C" fn(*mut client) -> ()),
62524                arity: -(3 as libc::c_int),
62525                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
62526                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
62527                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62528                    as uint64_t,
62529                key_specs_static: [
62530                    {
62531                        let mut init = keySpec {
62532                            notes: 0 as *const libc::c_char,
62533                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
62534                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
62535                            begin_search_type: KSPEC_BS_INDEX,
62536                            bs: C2RustUnnamed_3 {
62537                                index: {
62538                                    let mut init = C2RustUnnamed_5 {
62539                                        pos: 1 as libc::c_int,
62540                                    };
62541                                    init
62542                                },
62543                            },
62544                            find_keys_type: KSPEC_FK_RANGE,
62545                            fk: C2RustUnnamed_0 {
62546                                range: {
62547                                    let mut init = C2RustUnnamed_2 {
62548                                        lastkey: 0 as libc::c_int,
62549                                        keystep: 1 as libc::c_int,
62550                                        limit: 0 as libc::c_int,
62551                                    };
62552                                    init
62553                                },
62554                            },
62555                        };
62556                        init
62557                    },
62558                    keySpec {
62559                        notes: 0 as *const libc::c_char,
62560                        flags: 0,
62561                        begin_search_type: KSPEC_BS_INVALID,
62562                        bs: C2RustUnnamed_3 {
62563                            index: C2RustUnnamed_5 { pos: 0 },
62564                        },
62565                        find_keys_type: KSPEC_FK_INVALID,
62566                        fk: C2RustUnnamed_0 {
62567                            range: C2RustUnnamed_2 {
62568                                lastkey: 0,
62569                                keystep: 0,
62570                                limit: 0,
62571                            },
62572                        },
62573                    },
62574                    keySpec {
62575                        notes: 0 as *const libc::c_char,
62576                        flags: 0,
62577                        begin_search_type: KSPEC_BS_INVALID,
62578                        bs: C2RustUnnamed_3 {
62579                            index: C2RustUnnamed_5 { pos: 0 },
62580                        },
62581                        find_keys_type: KSPEC_FK_INVALID,
62582                        fk: C2RustUnnamed_0 {
62583                            range: C2RustUnnamed_2 {
62584                                lastkey: 0,
62585                                keystep: 0,
62586                                limit: 0,
62587                            },
62588                        },
62589                    },
62590                    keySpec {
62591                        notes: 0 as *const libc::c_char,
62592                        flags: 0,
62593                        begin_search_type: KSPEC_BS_INVALID,
62594                        bs: C2RustUnnamed_3 {
62595                            index: C2RustUnnamed_5 { pos: 0 },
62596                        },
62597                        find_keys_type: KSPEC_FK_INVALID,
62598                        fk: C2RustUnnamed_0 {
62599                            range: C2RustUnnamed_2 {
62600                                lastkey: 0,
62601                                keystep: 0,
62602                                limit: 0,
62603                            },
62604                        },
62605                    },
62606                ],
62607                getkeys_proc: None,
62608                subcommands: 0 as *const redisCommand as *mut redisCommand,
62609                args: ZREM_Args.as_ptr() as *mut _,
62610                microseconds: 0,
62611                calls: 0,
62612                rejected_calls: 0,
62613                failed_calls: 0,
62614                id: 0,
62615                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62616                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62617                key_specs: 0 as *const keySpec as *mut keySpec,
62618                legacy_range_key_spec: keySpec {
62619                    notes: 0 as *const libc::c_char,
62620                    flags: 0,
62621                    begin_search_type: KSPEC_BS_INVALID,
62622                    bs: C2RustUnnamed_3 {
62623                        index: C2RustUnnamed_5 { pos: 0 },
62624                    },
62625                    find_keys_type: KSPEC_FK_INVALID,
62626                    fk: C2RustUnnamed_0 {
62627                        range: C2RustUnnamed_2 {
62628                            lastkey: 0,
62629                            keystep: 0,
62630                            limit: 0,
62631                        },
62632                    },
62633                },
62634                num_args: 0,
62635                num_history: 0,
62636                num_tips: 0,
62637                key_specs_num: 0,
62638                key_specs_max: 0,
62639                subcommands_dict: 0 as *const dict as *mut dict,
62640                parent: 0 as *const redisCommand as *mut redisCommand,
62641                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62642            };
62643            init
62644        },
62645        {
62646            let mut init = redisCommand {
62647                declared_name: b"zremrangebylex\0" as *const u8 as *const libc::c_char,
62648                summary: b"Remove all members in a sorted set between the given lexicographical range\0"
62649                    as *const u8 as *const libc::c_char,
62650                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.\0"
62651                    as *const u8 as *const libc::c_char,
62652                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
62653                doc_flags: 0 as libc::c_int,
62654                replaced_by: 0 as *const libc::c_char,
62655                deprecated_since: 0 as *const libc::c_char,
62656                group: COMMAND_GROUP_SORTED_SET,
62657                history: 0 as *const commandHistory as *mut commandHistory,
62658                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62659                proc_0: Some(
62660                    zremrangebylexCommand as unsafe extern "C" fn(*mut client) -> (),
62661                ),
62662                arity: 4 as libc::c_int,
62663                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
62664                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62665                    as uint64_t,
62666                key_specs_static: [
62667                    {
62668                        let mut init = keySpec {
62669                            notes: 0 as *const libc::c_char,
62670                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
62671                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
62672                            begin_search_type: KSPEC_BS_INDEX,
62673                            bs: C2RustUnnamed_3 {
62674                                index: {
62675                                    let mut init = C2RustUnnamed_5 {
62676                                        pos: 1 as libc::c_int,
62677                                    };
62678                                    init
62679                                },
62680                            },
62681                            find_keys_type: KSPEC_FK_RANGE,
62682                            fk: C2RustUnnamed_0 {
62683                                range: {
62684                                    let mut init = C2RustUnnamed_2 {
62685                                        lastkey: 0 as libc::c_int,
62686                                        keystep: 1 as libc::c_int,
62687                                        limit: 0 as libc::c_int,
62688                                    };
62689                                    init
62690                                },
62691                            },
62692                        };
62693                        init
62694                    },
62695                    keySpec {
62696                        notes: 0 as *const libc::c_char,
62697                        flags: 0,
62698                        begin_search_type: KSPEC_BS_INVALID,
62699                        bs: C2RustUnnamed_3 {
62700                            index: C2RustUnnamed_5 { pos: 0 },
62701                        },
62702                        find_keys_type: KSPEC_FK_INVALID,
62703                        fk: C2RustUnnamed_0 {
62704                            range: C2RustUnnamed_2 {
62705                                lastkey: 0,
62706                                keystep: 0,
62707                                limit: 0,
62708                            },
62709                        },
62710                    },
62711                    keySpec {
62712                        notes: 0 as *const libc::c_char,
62713                        flags: 0,
62714                        begin_search_type: KSPEC_BS_INVALID,
62715                        bs: C2RustUnnamed_3 {
62716                            index: C2RustUnnamed_5 { pos: 0 },
62717                        },
62718                        find_keys_type: KSPEC_FK_INVALID,
62719                        fk: C2RustUnnamed_0 {
62720                            range: C2RustUnnamed_2 {
62721                                lastkey: 0,
62722                                keystep: 0,
62723                                limit: 0,
62724                            },
62725                        },
62726                    },
62727                    keySpec {
62728                        notes: 0 as *const libc::c_char,
62729                        flags: 0,
62730                        begin_search_type: KSPEC_BS_INVALID,
62731                        bs: C2RustUnnamed_3 {
62732                            index: C2RustUnnamed_5 { pos: 0 },
62733                        },
62734                        find_keys_type: KSPEC_FK_INVALID,
62735                        fk: C2RustUnnamed_0 {
62736                            range: C2RustUnnamed_2 {
62737                                lastkey: 0,
62738                                keystep: 0,
62739                                limit: 0,
62740                            },
62741                        },
62742                    },
62743                ],
62744                getkeys_proc: None,
62745                subcommands: 0 as *const redisCommand as *mut redisCommand,
62746                args: ZREMRANGEBYLEX_Args.as_ptr() as *mut _,
62747                microseconds: 0,
62748                calls: 0,
62749                rejected_calls: 0,
62750                failed_calls: 0,
62751                id: 0,
62752                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62753                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62754                key_specs: 0 as *const keySpec as *mut keySpec,
62755                legacy_range_key_spec: keySpec {
62756                    notes: 0 as *const libc::c_char,
62757                    flags: 0,
62758                    begin_search_type: KSPEC_BS_INVALID,
62759                    bs: C2RustUnnamed_3 {
62760                        index: C2RustUnnamed_5 { pos: 0 },
62761                    },
62762                    find_keys_type: KSPEC_FK_INVALID,
62763                    fk: C2RustUnnamed_0 {
62764                        range: C2RustUnnamed_2 {
62765                            lastkey: 0,
62766                            keystep: 0,
62767                            limit: 0,
62768                        },
62769                    },
62770                },
62771                num_args: 0,
62772                num_history: 0,
62773                num_tips: 0,
62774                key_specs_num: 0,
62775                key_specs_max: 0,
62776                subcommands_dict: 0 as *const dict as *mut dict,
62777                parent: 0 as *const redisCommand as *mut redisCommand,
62778                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62779            };
62780            init
62781        },
62782        {
62783            let mut init = redisCommand {
62784                declared_name: b"zremrangebyrank\0" as *const u8 as *const libc::c_char,
62785                summary: b"Remove all members in a sorted set within the given indexes\0"
62786                    as *const u8 as *const libc::c_char,
62787                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.\0"
62788                    as *const u8 as *const libc::c_char,
62789                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
62790                doc_flags: 0 as libc::c_int,
62791                replaced_by: 0 as *const libc::c_char,
62792                deprecated_since: 0 as *const libc::c_char,
62793                group: COMMAND_GROUP_SORTED_SET,
62794                history: 0 as *const commandHistory as *mut commandHistory,
62795                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62796                proc_0: Some(
62797                    zremrangebyrankCommand as unsafe extern "C" fn(*mut client) -> (),
62798                ),
62799                arity: 4 as libc::c_int,
62800                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
62801                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62802                    as uint64_t,
62803                key_specs_static: [
62804                    {
62805                        let mut init = keySpec {
62806                            notes: 0 as *const libc::c_char,
62807                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
62808                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
62809                            begin_search_type: KSPEC_BS_INDEX,
62810                            bs: C2RustUnnamed_3 {
62811                                index: {
62812                                    let mut init = C2RustUnnamed_5 {
62813                                        pos: 1 as libc::c_int,
62814                                    };
62815                                    init
62816                                },
62817                            },
62818                            find_keys_type: KSPEC_FK_RANGE,
62819                            fk: C2RustUnnamed_0 {
62820                                range: {
62821                                    let mut init = C2RustUnnamed_2 {
62822                                        lastkey: 0 as libc::c_int,
62823                                        keystep: 1 as libc::c_int,
62824                                        limit: 0 as libc::c_int,
62825                                    };
62826                                    init
62827                                },
62828                            },
62829                        };
62830                        init
62831                    },
62832                    keySpec {
62833                        notes: 0 as *const libc::c_char,
62834                        flags: 0,
62835                        begin_search_type: KSPEC_BS_INVALID,
62836                        bs: C2RustUnnamed_3 {
62837                            index: C2RustUnnamed_5 { pos: 0 },
62838                        },
62839                        find_keys_type: KSPEC_FK_INVALID,
62840                        fk: C2RustUnnamed_0 {
62841                            range: C2RustUnnamed_2 {
62842                                lastkey: 0,
62843                                keystep: 0,
62844                                limit: 0,
62845                            },
62846                        },
62847                    },
62848                    keySpec {
62849                        notes: 0 as *const libc::c_char,
62850                        flags: 0,
62851                        begin_search_type: KSPEC_BS_INVALID,
62852                        bs: C2RustUnnamed_3 {
62853                            index: C2RustUnnamed_5 { pos: 0 },
62854                        },
62855                        find_keys_type: KSPEC_FK_INVALID,
62856                        fk: C2RustUnnamed_0 {
62857                            range: C2RustUnnamed_2 {
62858                                lastkey: 0,
62859                                keystep: 0,
62860                                limit: 0,
62861                            },
62862                        },
62863                    },
62864                    keySpec {
62865                        notes: 0 as *const libc::c_char,
62866                        flags: 0,
62867                        begin_search_type: KSPEC_BS_INVALID,
62868                        bs: C2RustUnnamed_3 {
62869                            index: C2RustUnnamed_5 { pos: 0 },
62870                        },
62871                        find_keys_type: KSPEC_FK_INVALID,
62872                        fk: C2RustUnnamed_0 {
62873                            range: C2RustUnnamed_2 {
62874                                lastkey: 0,
62875                                keystep: 0,
62876                                limit: 0,
62877                            },
62878                        },
62879                    },
62880                ],
62881                getkeys_proc: None,
62882                subcommands: 0 as *const redisCommand as *mut redisCommand,
62883                args: ZREMRANGEBYRANK_Args.as_ptr() as *mut _,
62884                microseconds: 0,
62885                calls: 0,
62886                rejected_calls: 0,
62887                failed_calls: 0,
62888                id: 0,
62889                fullname: 0 as *const libc::c_char as *mut libc::c_char,
62890                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
62891                key_specs: 0 as *const keySpec as *mut keySpec,
62892                legacy_range_key_spec: keySpec {
62893                    notes: 0 as *const libc::c_char,
62894                    flags: 0,
62895                    begin_search_type: KSPEC_BS_INVALID,
62896                    bs: C2RustUnnamed_3 {
62897                        index: C2RustUnnamed_5 { pos: 0 },
62898                    },
62899                    find_keys_type: KSPEC_FK_INVALID,
62900                    fk: C2RustUnnamed_0 {
62901                        range: C2RustUnnamed_2 {
62902                            lastkey: 0,
62903                            keystep: 0,
62904                            limit: 0,
62905                        },
62906                    },
62907                },
62908                num_args: 0,
62909                num_history: 0,
62910                num_tips: 0,
62911                key_specs_num: 0,
62912                key_specs_max: 0,
62913                subcommands_dict: 0 as *const dict as *mut dict,
62914                parent: 0 as *const redisCommand as *mut redisCommand,
62915                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
62916            };
62917            init
62918        },
62919        {
62920            let mut init = redisCommand {
62921                declared_name: b"zremrangebyscore\0" as *const u8 as *const libc::c_char,
62922                summary: b"Remove all members in a sorted set within the given scores\0"
62923                    as *const u8 as *const libc::c_char,
62924                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.\0"
62925                    as *const u8 as *const libc::c_char,
62926                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
62927                doc_flags: 0 as libc::c_int,
62928                replaced_by: 0 as *const libc::c_char,
62929                deprecated_since: 0 as *const libc::c_char,
62930                group: COMMAND_GROUP_SORTED_SET,
62931                history: 0 as *const commandHistory as *mut commandHistory,
62932                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
62933                proc_0: Some(
62934                    zremrangebyscoreCommand as unsafe extern "C" fn(*mut client) -> (),
62935                ),
62936                arity: 4 as libc::c_int,
62937                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
62938                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
62939                    as uint64_t,
62940                key_specs_static: [
62941                    {
62942                        let mut init = keySpec {
62943                            notes: 0 as *const libc::c_char,
62944                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
62945                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
62946                            begin_search_type: KSPEC_BS_INDEX,
62947                            bs: C2RustUnnamed_3 {
62948                                index: {
62949                                    let mut init = C2RustUnnamed_5 {
62950                                        pos: 1 as libc::c_int,
62951                                    };
62952                                    init
62953                                },
62954                            },
62955                            find_keys_type: KSPEC_FK_RANGE,
62956                            fk: C2RustUnnamed_0 {
62957                                range: {
62958                                    let mut init = C2RustUnnamed_2 {
62959                                        lastkey: 0 as libc::c_int,
62960                                        keystep: 1 as libc::c_int,
62961                                        limit: 0 as libc::c_int,
62962                                    };
62963                                    init
62964                                },
62965                            },
62966                        };
62967                        init
62968                    },
62969                    keySpec {
62970                        notes: 0 as *const libc::c_char,
62971                        flags: 0,
62972                        begin_search_type: KSPEC_BS_INVALID,
62973                        bs: C2RustUnnamed_3 {
62974                            index: C2RustUnnamed_5 { pos: 0 },
62975                        },
62976                        find_keys_type: KSPEC_FK_INVALID,
62977                        fk: C2RustUnnamed_0 {
62978                            range: C2RustUnnamed_2 {
62979                                lastkey: 0,
62980                                keystep: 0,
62981                                limit: 0,
62982                            },
62983                        },
62984                    },
62985                    keySpec {
62986                        notes: 0 as *const libc::c_char,
62987                        flags: 0,
62988                        begin_search_type: KSPEC_BS_INVALID,
62989                        bs: C2RustUnnamed_3 {
62990                            index: C2RustUnnamed_5 { pos: 0 },
62991                        },
62992                        find_keys_type: KSPEC_FK_INVALID,
62993                        fk: C2RustUnnamed_0 {
62994                            range: C2RustUnnamed_2 {
62995                                lastkey: 0,
62996                                keystep: 0,
62997                                limit: 0,
62998                            },
62999                        },
63000                    },
63001                    keySpec {
63002                        notes: 0 as *const libc::c_char,
63003                        flags: 0,
63004                        begin_search_type: KSPEC_BS_INVALID,
63005                        bs: C2RustUnnamed_3 {
63006                            index: C2RustUnnamed_5 { pos: 0 },
63007                        },
63008                        find_keys_type: KSPEC_FK_INVALID,
63009                        fk: C2RustUnnamed_0 {
63010                            range: C2RustUnnamed_2 {
63011                                lastkey: 0,
63012                                keystep: 0,
63013                                limit: 0,
63014                            },
63015                        },
63016                    },
63017                ],
63018                getkeys_proc: None,
63019                subcommands: 0 as *const redisCommand as *mut redisCommand,
63020                args: ZREMRANGEBYSCORE_Args.as_ptr() as *mut _,
63021                microseconds: 0,
63022                calls: 0,
63023                rejected_calls: 0,
63024                failed_calls: 0,
63025                id: 0,
63026                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63027                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63028                key_specs: 0 as *const keySpec as *mut keySpec,
63029                legacy_range_key_spec: keySpec {
63030                    notes: 0 as *const libc::c_char,
63031                    flags: 0,
63032                    begin_search_type: KSPEC_BS_INVALID,
63033                    bs: C2RustUnnamed_3 {
63034                        index: C2RustUnnamed_5 { pos: 0 },
63035                    },
63036                    find_keys_type: KSPEC_FK_INVALID,
63037                    fk: C2RustUnnamed_0 {
63038                        range: C2RustUnnamed_2 {
63039                            lastkey: 0,
63040                            keystep: 0,
63041                            limit: 0,
63042                        },
63043                    },
63044                },
63045                num_args: 0,
63046                num_history: 0,
63047                num_tips: 0,
63048                key_specs_num: 0,
63049                key_specs_max: 0,
63050                subcommands_dict: 0 as *const dict as *mut dict,
63051                parent: 0 as *const redisCommand as *mut redisCommand,
63052                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63053            };
63054            init
63055        },
63056        {
63057            let mut init = redisCommand {
63058                declared_name: b"zrevrange\0" as *const u8 as *const libc::c_char,
63059                summary: b"Return a range of members in a sorted set, by index, with scores ordered from high to low\0"
63060                    as *const u8 as *const libc::c_char,
63061                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.\0"
63062                    as *const u8 as *const libc::c_char,
63063                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
63064                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
63065                replaced_by: b"`ZRANGE` with the `REV` argument\0" as *const u8
63066                    as *const libc::c_char,
63067                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
63068                group: COMMAND_GROUP_SORTED_SET,
63069                history: 0 as *const commandHistory as *mut commandHistory,
63070                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63071                proc_0: Some(
63072                    zrevrangeCommand as unsafe extern "C" fn(*mut client) -> (),
63073                ),
63074                arity: -(4 as libc::c_int),
63075                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
63076                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63077                    as uint64_t,
63078                key_specs_static: [
63079                    {
63080                        let mut init = keySpec {
63081                            notes: 0 as *const libc::c_char,
63082                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63083                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63084                            begin_search_type: KSPEC_BS_INDEX,
63085                            bs: C2RustUnnamed_3 {
63086                                index: {
63087                                    let mut init = C2RustUnnamed_5 {
63088                                        pos: 1 as libc::c_int,
63089                                    };
63090                                    init
63091                                },
63092                            },
63093                            find_keys_type: KSPEC_FK_RANGE,
63094                            fk: C2RustUnnamed_0 {
63095                                range: {
63096                                    let mut init = C2RustUnnamed_2 {
63097                                        lastkey: 0 as libc::c_int,
63098                                        keystep: 1 as libc::c_int,
63099                                        limit: 0 as libc::c_int,
63100                                    };
63101                                    init
63102                                },
63103                            },
63104                        };
63105                        init
63106                    },
63107                    keySpec {
63108                        notes: 0 as *const libc::c_char,
63109                        flags: 0,
63110                        begin_search_type: KSPEC_BS_INVALID,
63111                        bs: C2RustUnnamed_3 {
63112                            index: C2RustUnnamed_5 { pos: 0 },
63113                        },
63114                        find_keys_type: KSPEC_FK_INVALID,
63115                        fk: C2RustUnnamed_0 {
63116                            range: C2RustUnnamed_2 {
63117                                lastkey: 0,
63118                                keystep: 0,
63119                                limit: 0,
63120                            },
63121                        },
63122                    },
63123                    keySpec {
63124                        notes: 0 as *const libc::c_char,
63125                        flags: 0,
63126                        begin_search_type: KSPEC_BS_INVALID,
63127                        bs: C2RustUnnamed_3 {
63128                            index: C2RustUnnamed_5 { pos: 0 },
63129                        },
63130                        find_keys_type: KSPEC_FK_INVALID,
63131                        fk: C2RustUnnamed_0 {
63132                            range: C2RustUnnamed_2 {
63133                                lastkey: 0,
63134                                keystep: 0,
63135                                limit: 0,
63136                            },
63137                        },
63138                    },
63139                    keySpec {
63140                        notes: 0 as *const libc::c_char,
63141                        flags: 0,
63142                        begin_search_type: KSPEC_BS_INVALID,
63143                        bs: C2RustUnnamed_3 {
63144                            index: C2RustUnnamed_5 { pos: 0 },
63145                        },
63146                        find_keys_type: KSPEC_FK_INVALID,
63147                        fk: C2RustUnnamed_0 {
63148                            range: C2RustUnnamed_2 {
63149                                lastkey: 0,
63150                                keystep: 0,
63151                                limit: 0,
63152                            },
63153                        },
63154                    },
63155                ],
63156                getkeys_proc: None,
63157                subcommands: 0 as *const redisCommand as *mut redisCommand,
63158                args: ZREVRANGE_Args.as_ptr() as *mut _,
63159                microseconds: 0,
63160                calls: 0,
63161                rejected_calls: 0,
63162                failed_calls: 0,
63163                id: 0,
63164                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63165                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63166                key_specs: 0 as *const keySpec as *mut keySpec,
63167                legacy_range_key_spec: keySpec {
63168                    notes: 0 as *const libc::c_char,
63169                    flags: 0,
63170                    begin_search_type: KSPEC_BS_INVALID,
63171                    bs: C2RustUnnamed_3 {
63172                        index: C2RustUnnamed_5 { pos: 0 },
63173                    },
63174                    find_keys_type: KSPEC_FK_INVALID,
63175                    fk: C2RustUnnamed_0 {
63176                        range: C2RustUnnamed_2 {
63177                            lastkey: 0,
63178                            keystep: 0,
63179                            limit: 0,
63180                        },
63181                    },
63182                },
63183                num_args: 0,
63184                num_history: 0,
63185                num_tips: 0,
63186                key_specs_num: 0,
63187                key_specs_max: 0,
63188                subcommands_dict: 0 as *const dict as *mut dict,
63189                parent: 0 as *const redisCommand as *mut redisCommand,
63190                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63191            };
63192            init
63193        },
63194        {
63195            let mut init = redisCommand {
63196                declared_name: b"zrevrangebylex\0" as *const u8 as *const libc::c_char,
63197                summary: b"Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.\0"
63198                    as *const u8 as *const libc::c_char,
63199                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).\0"
63200                    as *const u8 as *const libc::c_char,
63201                since: b"2.8.9\0" as *const u8 as *const libc::c_char,
63202                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
63203                replaced_by: b"`ZRANGE` with the `REV` and `BYLEX` arguments\0"
63204                    as *const u8 as *const libc::c_char,
63205                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
63206                group: COMMAND_GROUP_SORTED_SET,
63207                history: 0 as *const commandHistory as *mut commandHistory,
63208                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63209                proc_0: Some(
63210                    zrevrangebylexCommand as unsafe extern "C" fn(*mut client) -> (),
63211                ),
63212                arity: -(4 as libc::c_int),
63213                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
63214                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63215                    as uint64_t,
63216                key_specs_static: [
63217                    {
63218                        let mut init = keySpec {
63219                            notes: 0 as *const libc::c_char,
63220                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63221                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63222                            begin_search_type: KSPEC_BS_INDEX,
63223                            bs: C2RustUnnamed_3 {
63224                                index: {
63225                                    let mut init = C2RustUnnamed_5 {
63226                                        pos: 1 as libc::c_int,
63227                                    };
63228                                    init
63229                                },
63230                            },
63231                            find_keys_type: KSPEC_FK_RANGE,
63232                            fk: C2RustUnnamed_0 {
63233                                range: {
63234                                    let mut init = C2RustUnnamed_2 {
63235                                        lastkey: 0 as libc::c_int,
63236                                        keystep: 1 as libc::c_int,
63237                                        limit: 0 as libc::c_int,
63238                                    };
63239                                    init
63240                                },
63241                            },
63242                        };
63243                        init
63244                    },
63245                    keySpec {
63246                        notes: 0 as *const libc::c_char,
63247                        flags: 0,
63248                        begin_search_type: KSPEC_BS_INVALID,
63249                        bs: C2RustUnnamed_3 {
63250                            index: C2RustUnnamed_5 { pos: 0 },
63251                        },
63252                        find_keys_type: KSPEC_FK_INVALID,
63253                        fk: C2RustUnnamed_0 {
63254                            range: C2RustUnnamed_2 {
63255                                lastkey: 0,
63256                                keystep: 0,
63257                                limit: 0,
63258                            },
63259                        },
63260                    },
63261                    keySpec {
63262                        notes: 0 as *const libc::c_char,
63263                        flags: 0,
63264                        begin_search_type: KSPEC_BS_INVALID,
63265                        bs: C2RustUnnamed_3 {
63266                            index: C2RustUnnamed_5 { pos: 0 },
63267                        },
63268                        find_keys_type: KSPEC_FK_INVALID,
63269                        fk: C2RustUnnamed_0 {
63270                            range: C2RustUnnamed_2 {
63271                                lastkey: 0,
63272                                keystep: 0,
63273                                limit: 0,
63274                            },
63275                        },
63276                    },
63277                    keySpec {
63278                        notes: 0 as *const libc::c_char,
63279                        flags: 0,
63280                        begin_search_type: KSPEC_BS_INVALID,
63281                        bs: C2RustUnnamed_3 {
63282                            index: C2RustUnnamed_5 { pos: 0 },
63283                        },
63284                        find_keys_type: KSPEC_FK_INVALID,
63285                        fk: C2RustUnnamed_0 {
63286                            range: C2RustUnnamed_2 {
63287                                lastkey: 0,
63288                                keystep: 0,
63289                                limit: 0,
63290                            },
63291                        },
63292                    },
63293                ],
63294                getkeys_proc: None,
63295                subcommands: 0 as *const redisCommand as *mut redisCommand,
63296                args: ZREVRANGEBYLEX_Args.as_ptr() as *mut _,
63297                microseconds: 0,
63298                calls: 0,
63299                rejected_calls: 0,
63300                failed_calls: 0,
63301                id: 0,
63302                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63303                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63304                key_specs: 0 as *const keySpec as *mut keySpec,
63305                legacy_range_key_spec: keySpec {
63306                    notes: 0 as *const libc::c_char,
63307                    flags: 0,
63308                    begin_search_type: KSPEC_BS_INVALID,
63309                    bs: C2RustUnnamed_3 {
63310                        index: C2RustUnnamed_5 { pos: 0 },
63311                    },
63312                    find_keys_type: KSPEC_FK_INVALID,
63313                    fk: C2RustUnnamed_0 {
63314                        range: C2RustUnnamed_2 {
63315                            lastkey: 0,
63316                            keystep: 0,
63317                            limit: 0,
63318                        },
63319                    },
63320                },
63321                num_args: 0,
63322                num_history: 0,
63323                num_tips: 0,
63324                key_specs_num: 0,
63325                key_specs_max: 0,
63326                subcommands_dict: 0 as *const dict as *mut dict,
63327                parent: 0 as *const redisCommand as *mut redisCommand,
63328                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63329            };
63330            init
63331        },
63332        {
63333            let mut init = redisCommand {
63334                declared_name: b"zrevrangebyscore\0" as *const u8 as *const libc::c_char,
63335                summary: b"Return a range of members in a sorted set, by score, with scores ordered from high to low\0"
63336                    as *const u8 as *const libc::c_char,
63337                complexity: b"O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).\0"
63338                    as *const u8 as *const libc::c_char,
63339                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
63340                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
63341                replaced_by: b"`ZRANGE` with the `REV` and `BYSCORE` arguments\0"
63342                    as *const u8 as *const libc::c_char,
63343                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
63344                group: COMMAND_GROUP_SORTED_SET,
63345                history: ZREVRANGEBYSCORE_History.as_ptr() as *mut _,
63346                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63347                proc_0: Some(
63348                    zrevrangebyscoreCommand as unsafe extern "C" fn(*mut client) -> (),
63349                ),
63350                arity: -(4 as libc::c_int),
63351                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
63352                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63353                    as uint64_t,
63354                key_specs_static: [
63355                    {
63356                        let mut init = keySpec {
63357                            notes: 0 as *const libc::c_char,
63358                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63359                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63360                            begin_search_type: KSPEC_BS_INDEX,
63361                            bs: C2RustUnnamed_3 {
63362                                index: {
63363                                    let mut init = C2RustUnnamed_5 {
63364                                        pos: 1 as libc::c_int,
63365                                    };
63366                                    init
63367                                },
63368                            },
63369                            find_keys_type: KSPEC_FK_RANGE,
63370                            fk: C2RustUnnamed_0 {
63371                                range: {
63372                                    let mut init = C2RustUnnamed_2 {
63373                                        lastkey: 0 as libc::c_int,
63374                                        keystep: 1 as libc::c_int,
63375                                        limit: 0 as libc::c_int,
63376                                    };
63377                                    init
63378                                },
63379                            },
63380                        };
63381                        init
63382                    },
63383                    keySpec {
63384                        notes: 0 as *const libc::c_char,
63385                        flags: 0,
63386                        begin_search_type: KSPEC_BS_INVALID,
63387                        bs: C2RustUnnamed_3 {
63388                            index: C2RustUnnamed_5 { pos: 0 },
63389                        },
63390                        find_keys_type: KSPEC_FK_INVALID,
63391                        fk: C2RustUnnamed_0 {
63392                            range: C2RustUnnamed_2 {
63393                                lastkey: 0,
63394                                keystep: 0,
63395                                limit: 0,
63396                            },
63397                        },
63398                    },
63399                    keySpec {
63400                        notes: 0 as *const libc::c_char,
63401                        flags: 0,
63402                        begin_search_type: KSPEC_BS_INVALID,
63403                        bs: C2RustUnnamed_3 {
63404                            index: C2RustUnnamed_5 { pos: 0 },
63405                        },
63406                        find_keys_type: KSPEC_FK_INVALID,
63407                        fk: C2RustUnnamed_0 {
63408                            range: C2RustUnnamed_2 {
63409                                lastkey: 0,
63410                                keystep: 0,
63411                                limit: 0,
63412                            },
63413                        },
63414                    },
63415                    keySpec {
63416                        notes: 0 as *const libc::c_char,
63417                        flags: 0,
63418                        begin_search_type: KSPEC_BS_INVALID,
63419                        bs: C2RustUnnamed_3 {
63420                            index: C2RustUnnamed_5 { pos: 0 },
63421                        },
63422                        find_keys_type: KSPEC_FK_INVALID,
63423                        fk: C2RustUnnamed_0 {
63424                            range: C2RustUnnamed_2 {
63425                                lastkey: 0,
63426                                keystep: 0,
63427                                limit: 0,
63428                            },
63429                        },
63430                    },
63431                ],
63432                getkeys_proc: None,
63433                subcommands: 0 as *const redisCommand as *mut redisCommand,
63434                args: ZREVRANGEBYSCORE_Args.as_ptr() as *mut _,
63435                microseconds: 0,
63436                calls: 0,
63437                rejected_calls: 0,
63438                failed_calls: 0,
63439                id: 0,
63440                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63441                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63442                key_specs: 0 as *const keySpec as *mut keySpec,
63443                legacy_range_key_spec: keySpec {
63444                    notes: 0 as *const libc::c_char,
63445                    flags: 0,
63446                    begin_search_type: KSPEC_BS_INVALID,
63447                    bs: C2RustUnnamed_3 {
63448                        index: C2RustUnnamed_5 { pos: 0 },
63449                    },
63450                    find_keys_type: KSPEC_FK_INVALID,
63451                    fk: C2RustUnnamed_0 {
63452                        range: C2RustUnnamed_2 {
63453                            lastkey: 0,
63454                            keystep: 0,
63455                            limit: 0,
63456                        },
63457                    },
63458                },
63459                num_args: 0,
63460                num_history: 0,
63461                num_tips: 0,
63462                key_specs_num: 0,
63463                key_specs_max: 0,
63464                subcommands_dict: 0 as *const dict as *mut dict,
63465                parent: 0 as *const redisCommand as *mut redisCommand,
63466                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63467            };
63468            init
63469        },
63470        {
63471            let mut init = redisCommand {
63472                declared_name: b"zrevrank\0" as *const u8 as *const libc::c_char,
63473                summary: b"Determine the index of a member in a sorted set, with scores ordered from high to low\0"
63474                    as *const u8 as *const libc::c_char,
63475                complexity: b"O(log(N))\0" as *const u8 as *const libc::c_char,
63476                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
63477                doc_flags: 0 as libc::c_int,
63478                replaced_by: 0 as *const libc::c_char,
63479                deprecated_since: 0 as *const libc::c_char,
63480                group: COMMAND_GROUP_SORTED_SET,
63481                history: 0 as *const commandHistory as *mut commandHistory,
63482                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63483                proc_0: Some(zrevrankCommand as unsafe extern "C" fn(*mut client) -> ()),
63484                arity: 3 as libc::c_int,
63485                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
63486                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
63487                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63488                    as uint64_t,
63489                key_specs_static: [
63490                    {
63491                        let mut init = keySpec {
63492                            notes: 0 as *const libc::c_char,
63493                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63494                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63495                            begin_search_type: KSPEC_BS_INDEX,
63496                            bs: C2RustUnnamed_3 {
63497                                index: {
63498                                    let mut init = C2RustUnnamed_5 {
63499                                        pos: 1 as libc::c_int,
63500                                    };
63501                                    init
63502                                },
63503                            },
63504                            find_keys_type: KSPEC_FK_RANGE,
63505                            fk: C2RustUnnamed_0 {
63506                                range: {
63507                                    let mut init = C2RustUnnamed_2 {
63508                                        lastkey: 0 as libc::c_int,
63509                                        keystep: 1 as libc::c_int,
63510                                        limit: 0 as libc::c_int,
63511                                    };
63512                                    init
63513                                },
63514                            },
63515                        };
63516                        init
63517                    },
63518                    keySpec {
63519                        notes: 0 as *const libc::c_char,
63520                        flags: 0,
63521                        begin_search_type: KSPEC_BS_INVALID,
63522                        bs: C2RustUnnamed_3 {
63523                            index: C2RustUnnamed_5 { pos: 0 },
63524                        },
63525                        find_keys_type: KSPEC_FK_INVALID,
63526                        fk: C2RustUnnamed_0 {
63527                            range: C2RustUnnamed_2 {
63528                                lastkey: 0,
63529                                keystep: 0,
63530                                limit: 0,
63531                            },
63532                        },
63533                    },
63534                    keySpec {
63535                        notes: 0 as *const libc::c_char,
63536                        flags: 0,
63537                        begin_search_type: KSPEC_BS_INVALID,
63538                        bs: C2RustUnnamed_3 {
63539                            index: C2RustUnnamed_5 { pos: 0 },
63540                        },
63541                        find_keys_type: KSPEC_FK_INVALID,
63542                        fk: C2RustUnnamed_0 {
63543                            range: C2RustUnnamed_2 {
63544                                lastkey: 0,
63545                                keystep: 0,
63546                                limit: 0,
63547                            },
63548                        },
63549                    },
63550                    keySpec {
63551                        notes: 0 as *const libc::c_char,
63552                        flags: 0,
63553                        begin_search_type: KSPEC_BS_INVALID,
63554                        bs: C2RustUnnamed_3 {
63555                            index: C2RustUnnamed_5 { pos: 0 },
63556                        },
63557                        find_keys_type: KSPEC_FK_INVALID,
63558                        fk: C2RustUnnamed_0 {
63559                            range: C2RustUnnamed_2 {
63560                                lastkey: 0,
63561                                keystep: 0,
63562                                limit: 0,
63563                            },
63564                        },
63565                    },
63566                ],
63567                getkeys_proc: None,
63568                subcommands: 0 as *const redisCommand as *mut redisCommand,
63569                args: ZREVRANK_Args.as_ptr() as *mut _,
63570                microseconds: 0,
63571                calls: 0,
63572                rejected_calls: 0,
63573                failed_calls: 0,
63574                id: 0,
63575                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63576                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63577                key_specs: 0 as *const keySpec as *mut keySpec,
63578                legacy_range_key_spec: keySpec {
63579                    notes: 0 as *const libc::c_char,
63580                    flags: 0,
63581                    begin_search_type: KSPEC_BS_INVALID,
63582                    bs: C2RustUnnamed_3 {
63583                        index: C2RustUnnamed_5 { pos: 0 },
63584                    },
63585                    find_keys_type: KSPEC_FK_INVALID,
63586                    fk: C2RustUnnamed_0 {
63587                        range: C2RustUnnamed_2 {
63588                            lastkey: 0,
63589                            keystep: 0,
63590                            limit: 0,
63591                        },
63592                    },
63593                },
63594                num_args: 0,
63595                num_history: 0,
63596                num_tips: 0,
63597                key_specs_num: 0,
63598                key_specs_max: 0,
63599                subcommands_dict: 0 as *const dict as *mut dict,
63600                parent: 0 as *const redisCommand as *mut redisCommand,
63601                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63602            };
63603            init
63604        },
63605        {
63606            let mut init = redisCommand {
63607                declared_name: b"zscan\0" as *const u8 as *const libc::c_char,
63608                summary: b"Incrementally iterate sorted sets elements and associated scores\0"
63609                    as *const u8 as *const libc::c_char,
63610                complexity: b"O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..\0"
63611                    as *const u8 as *const libc::c_char,
63612                since: b"2.8.0\0" as *const u8 as *const libc::c_char,
63613                doc_flags: 0 as libc::c_int,
63614                replaced_by: 0 as *const libc::c_char,
63615                deprecated_since: 0 as *const libc::c_char,
63616                group: COMMAND_GROUP_SORTED_SET,
63617                history: 0 as *const commandHistory as *mut commandHistory,
63618                tips: ZSCAN_tips.as_ptr() as *mut _,
63619                proc_0: Some(zscanCommand as unsafe extern "C" fn(*mut client) -> ()),
63620                arity: -(3 as libc::c_int),
63621                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
63622                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63623                    as uint64_t,
63624                key_specs_static: [
63625                    {
63626                        let mut init = keySpec {
63627                            notes: 0 as *const libc::c_char,
63628                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63629                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63630                            begin_search_type: KSPEC_BS_INDEX,
63631                            bs: C2RustUnnamed_3 {
63632                                index: {
63633                                    let mut init = C2RustUnnamed_5 {
63634                                        pos: 1 as libc::c_int,
63635                                    };
63636                                    init
63637                                },
63638                            },
63639                            find_keys_type: KSPEC_FK_RANGE,
63640                            fk: C2RustUnnamed_0 {
63641                                range: {
63642                                    let mut init = C2RustUnnamed_2 {
63643                                        lastkey: 0 as libc::c_int,
63644                                        keystep: 1 as libc::c_int,
63645                                        limit: 0 as libc::c_int,
63646                                    };
63647                                    init
63648                                },
63649                            },
63650                        };
63651                        init
63652                    },
63653                    keySpec {
63654                        notes: 0 as *const libc::c_char,
63655                        flags: 0,
63656                        begin_search_type: KSPEC_BS_INVALID,
63657                        bs: C2RustUnnamed_3 {
63658                            index: C2RustUnnamed_5 { pos: 0 },
63659                        },
63660                        find_keys_type: KSPEC_FK_INVALID,
63661                        fk: C2RustUnnamed_0 {
63662                            range: C2RustUnnamed_2 {
63663                                lastkey: 0,
63664                                keystep: 0,
63665                                limit: 0,
63666                            },
63667                        },
63668                    },
63669                    keySpec {
63670                        notes: 0 as *const libc::c_char,
63671                        flags: 0,
63672                        begin_search_type: KSPEC_BS_INVALID,
63673                        bs: C2RustUnnamed_3 {
63674                            index: C2RustUnnamed_5 { pos: 0 },
63675                        },
63676                        find_keys_type: KSPEC_FK_INVALID,
63677                        fk: C2RustUnnamed_0 {
63678                            range: C2RustUnnamed_2 {
63679                                lastkey: 0,
63680                                keystep: 0,
63681                                limit: 0,
63682                            },
63683                        },
63684                    },
63685                    keySpec {
63686                        notes: 0 as *const libc::c_char,
63687                        flags: 0,
63688                        begin_search_type: KSPEC_BS_INVALID,
63689                        bs: C2RustUnnamed_3 {
63690                            index: C2RustUnnamed_5 { pos: 0 },
63691                        },
63692                        find_keys_type: KSPEC_FK_INVALID,
63693                        fk: C2RustUnnamed_0 {
63694                            range: C2RustUnnamed_2 {
63695                                lastkey: 0,
63696                                keystep: 0,
63697                                limit: 0,
63698                            },
63699                        },
63700                    },
63701                ],
63702                getkeys_proc: None,
63703                subcommands: 0 as *const redisCommand as *mut redisCommand,
63704                args: ZSCAN_Args.as_ptr() as *mut _,
63705                microseconds: 0,
63706                calls: 0,
63707                rejected_calls: 0,
63708                failed_calls: 0,
63709                id: 0,
63710                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63711                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63712                key_specs: 0 as *const keySpec as *mut keySpec,
63713                legacy_range_key_spec: keySpec {
63714                    notes: 0 as *const libc::c_char,
63715                    flags: 0,
63716                    begin_search_type: KSPEC_BS_INVALID,
63717                    bs: C2RustUnnamed_3 {
63718                        index: C2RustUnnamed_5 { pos: 0 },
63719                    },
63720                    find_keys_type: KSPEC_FK_INVALID,
63721                    fk: C2RustUnnamed_0 {
63722                        range: C2RustUnnamed_2 {
63723                            lastkey: 0,
63724                            keystep: 0,
63725                            limit: 0,
63726                        },
63727                    },
63728                },
63729                num_args: 0,
63730                num_history: 0,
63731                num_tips: 0,
63732                key_specs_num: 0,
63733                key_specs_max: 0,
63734                subcommands_dict: 0 as *const dict as *mut dict,
63735                parent: 0 as *const redisCommand as *mut redisCommand,
63736                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63737            };
63738            init
63739        },
63740        {
63741            let mut init = redisCommand {
63742                declared_name: b"zscore\0" as *const u8 as *const libc::c_char,
63743                summary: b"Get the score associated with the given member in a sorted set\0"
63744                    as *const u8 as *const libc::c_char,
63745                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
63746                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
63747                doc_flags: 0 as libc::c_int,
63748                replaced_by: 0 as *const libc::c_char,
63749                deprecated_since: 0 as *const libc::c_char,
63750                group: COMMAND_GROUP_SORTED_SET,
63751                history: 0 as *const commandHistory as *mut commandHistory,
63752                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63753                proc_0: Some(zscoreCommand as unsafe extern "C" fn(*mut client) -> ()),
63754                arity: 3 as libc::c_int,
63755                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
63756                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
63757                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63758                    as uint64_t,
63759                key_specs_static: [
63760                    {
63761                        let mut init = keySpec {
63762                            notes: 0 as *const libc::c_char,
63763                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63764                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63765                            begin_search_type: KSPEC_BS_INDEX,
63766                            bs: C2RustUnnamed_3 {
63767                                index: {
63768                                    let mut init = C2RustUnnamed_5 {
63769                                        pos: 1 as libc::c_int,
63770                                    };
63771                                    init
63772                                },
63773                            },
63774                            find_keys_type: KSPEC_FK_RANGE,
63775                            fk: C2RustUnnamed_0 {
63776                                range: {
63777                                    let mut init = C2RustUnnamed_2 {
63778                                        lastkey: 0 as libc::c_int,
63779                                        keystep: 1 as libc::c_int,
63780                                        limit: 0 as libc::c_int,
63781                                    };
63782                                    init
63783                                },
63784                            },
63785                        };
63786                        init
63787                    },
63788                    keySpec {
63789                        notes: 0 as *const libc::c_char,
63790                        flags: 0,
63791                        begin_search_type: KSPEC_BS_INVALID,
63792                        bs: C2RustUnnamed_3 {
63793                            index: C2RustUnnamed_5 { pos: 0 },
63794                        },
63795                        find_keys_type: KSPEC_FK_INVALID,
63796                        fk: C2RustUnnamed_0 {
63797                            range: C2RustUnnamed_2 {
63798                                lastkey: 0,
63799                                keystep: 0,
63800                                limit: 0,
63801                            },
63802                        },
63803                    },
63804                    keySpec {
63805                        notes: 0 as *const libc::c_char,
63806                        flags: 0,
63807                        begin_search_type: KSPEC_BS_INVALID,
63808                        bs: C2RustUnnamed_3 {
63809                            index: C2RustUnnamed_5 { pos: 0 },
63810                        },
63811                        find_keys_type: KSPEC_FK_INVALID,
63812                        fk: C2RustUnnamed_0 {
63813                            range: C2RustUnnamed_2 {
63814                                lastkey: 0,
63815                                keystep: 0,
63816                                limit: 0,
63817                            },
63818                        },
63819                    },
63820                    keySpec {
63821                        notes: 0 as *const libc::c_char,
63822                        flags: 0,
63823                        begin_search_type: KSPEC_BS_INVALID,
63824                        bs: C2RustUnnamed_3 {
63825                            index: C2RustUnnamed_5 { pos: 0 },
63826                        },
63827                        find_keys_type: KSPEC_FK_INVALID,
63828                        fk: C2RustUnnamed_0 {
63829                            range: C2RustUnnamed_2 {
63830                                lastkey: 0,
63831                                keystep: 0,
63832                                limit: 0,
63833                            },
63834                        },
63835                    },
63836                ],
63837                getkeys_proc: None,
63838                subcommands: 0 as *const redisCommand as *mut redisCommand,
63839                args: ZSCORE_Args.as_ptr() as *mut _,
63840                microseconds: 0,
63841                calls: 0,
63842                rejected_calls: 0,
63843                failed_calls: 0,
63844                id: 0,
63845                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63846                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63847                key_specs: 0 as *const keySpec as *mut keySpec,
63848                legacy_range_key_spec: keySpec {
63849                    notes: 0 as *const libc::c_char,
63850                    flags: 0,
63851                    begin_search_type: KSPEC_BS_INVALID,
63852                    bs: C2RustUnnamed_3 {
63853                        index: C2RustUnnamed_5 { pos: 0 },
63854                    },
63855                    find_keys_type: KSPEC_FK_INVALID,
63856                    fk: C2RustUnnamed_0 {
63857                        range: C2RustUnnamed_2 {
63858                            lastkey: 0,
63859                            keystep: 0,
63860                            limit: 0,
63861                        },
63862                    },
63863                },
63864                num_args: 0,
63865                num_history: 0,
63866                num_tips: 0,
63867                key_specs_num: 0,
63868                key_specs_max: 0,
63869                subcommands_dict: 0 as *const dict as *mut dict,
63870                parent: 0 as *const redisCommand as *mut redisCommand,
63871                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
63872            };
63873            init
63874        },
63875        {
63876            let mut init = redisCommand {
63877                declared_name: b"zunion\0" as *const u8 as *const libc::c_char,
63878                summary: b"Add multiple sorted sets\0" as *const u8
63879                    as *const libc::c_char,
63880                complexity: b"O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.\0"
63881                    as *const u8 as *const libc::c_char,
63882                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
63883                doc_flags: 0 as libc::c_int,
63884                replaced_by: 0 as *const libc::c_char,
63885                deprecated_since: 0 as *const libc::c_char,
63886                group: COMMAND_GROUP_SORTED_SET,
63887                history: 0 as *const commandHistory as *mut commandHistory,
63888                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
63889                proc_0: Some(zunionCommand as unsafe extern "C" fn(*mut client) -> ()),
63890                arity: -(3 as libc::c_int),
63891                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
63892                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
63893                    as uint64_t,
63894                key_specs_static: [
63895                    {
63896                        let mut init = keySpec {
63897                            notes: 0 as *const libc::c_char,
63898                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
63899                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
63900                            begin_search_type: KSPEC_BS_INDEX,
63901                            bs: C2RustUnnamed_3 {
63902                                index: {
63903                                    let mut init = C2RustUnnamed_5 {
63904                                        pos: 1 as libc::c_int,
63905                                    };
63906                                    init
63907                                },
63908                            },
63909                            find_keys_type: KSPEC_FK_KEYNUM,
63910                            fk: C2RustUnnamed_0 {
63911                                keynum: {
63912                                    let mut init = C2RustUnnamed_1 {
63913                                        keynumidx: 0 as libc::c_int,
63914                                        firstkey: 1 as libc::c_int,
63915                                        keystep: 1 as libc::c_int,
63916                                    };
63917                                    init
63918                                },
63919                            },
63920                        };
63921                        init
63922                    },
63923                    keySpec {
63924                        notes: 0 as *const libc::c_char,
63925                        flags: 0,
63926                        begin_search_type: KSPEC_BS_INVALID,
63927                        bs: C2RustUnnamed_3 {
63928                            index: C2RustUnnamed_5 { pos: 0 },
63929                        },
63930                        find_keys_type: KSPEC_FK_INVALID,
63931                        fk: C2RustUnnamed_0 {
63932                            range: C2RustUnnamed_2 {
63933                                lastkey: 0,
63934                                keystep: 0,
63935                                limit: 0,
63936                            },
63937                        },
63938                    },
63939                    keySpec {
63940                        notes: 0 as *const libc::c_char,
63941                        flags: 0,
63942                        begin_search_type: KSPEC_BS_INVALID,
63943                        bs: C2RustUnnamed_3 {
63944                            index: C2RustUnnamed_5 { pos: 0 },
63945                        },
63946                        find_keys_type: KSPEC_FK_INVALID,
63947                        fk: C2RustUnnamed_0 {
63948                            range: C2RustUnnamed_2 {
63949                                lastkey: 0,
63950                                keystep: 0,
63951                                limit: 0,
63952                            },
63953                        },
63954                    },
63955                    keySpec {
63956                        notes: 0 as *const libc::c_char,
63957                        flags: 0,
63958                        begin_search_type: KSPEC_BS_INVALID,
63959                        bs: C2RustUnnamed_3 {
63960                            index: C2RustUnnamed_5 { pos: 0 },
63961                        },
63962                        find_keys_type: KSPEC_FK_INVALID,
63963                        fk: C2RustUnnamed_0 {
63964                            range: C2RustUnnamed_2 {
63965                                lastkey: 0,
63966                                keystep: 0,
63967                                limit: 0,
63968                            },
63969                        },
63970                    },
63971                ],
63972                getkeys_proc: Some(
63973                    zunionInterDiffGetKeys
63974                        as unsafe extern "C" fn(
63975                            *mut redisCommand,
63976                            *mut *mut robj,
63977                            libc::c_int,
63978                            *mut getKeysResult,
63979                        ) -> libc::c_int,
63980                ),
63981                subcommands: 0 as *const redisCommand as *mut redisCommand,
63982                args: ZUNION_Args.as_ptr() as *mut _,
63983                microseconds: 0,
63984                calls: 0,
63985                rejected_calls: 0,
63986                failed_calls: 0,
63987                id: 0,
63988                fullname: 0 as *const libc::c_char as *mut libc::c_char,
63989                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
63990                key_specs: 0 as *const keySpec as *mut keySpec,
63991                legacy_range_key_spec: keySpec {
63992                    notes: 0 as *const libc::c_char,
63993                    flags: 0,
63994                    begin_search_type: KSPEC_BS_INVALID,
63995                    bs: C2RustUnnamed_3 {
63996                        index: C2RustUnnamed_5 { pos: 0 },
63997                    },
63998                    find_keys_type: KSPEC_FK_INVALID,
63999                    fk: C2RustUnnamed_0 {
64000                        range: C2RustUnnamed_2 {
64001                            lastkey: 0,
64002                            keystep: 0,
64003                            limit: 0,
64004                        },
64005                    },
64006                },
64007                num_args: 0,
64008                num_history: 0,
64009                num_tips: 0,
64010                key_specs_num: 0,
64011                key_specs_max: 0,
64012                subcommands_dict: 0 as *const dict as *mut dict,
64013                parent: 0 as *const redisCommand as *mut redisCommand,
64014                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64015            };
64016            init
64017        },
64018        {
64019            let mut init = redisCommand {
64020                declared_name: b"zunionstore\0" as *const u8 as *const libc::c_char,
64021                summary: b"Add multiple sorted sets and store the resulting sorted set in a new key\0"
64022                    as *const u8 as *const libc::c_char,
64023                complexity: b"O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.\0"
64024                    as *const u8 as *const libc::c_char,
64025                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
64026                doc_flags: 0 as libc::c_int,
64027                replaced_by: 0 as *const libc::c_char,
64028                deprecated_since: 0 as *const libc::c_char,
64029                group: COMMAND_GROUP_SORTED_SET,
64030                history: 0 as *const commandHistory as *mut commandHistory,
64031                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
64032                proc_0: Some(
64033                    zunionstoreCommand as unsafe extern "C" fn(*mut client) -> (),
64034                ),
64035                arity: -(4 as libc::c_int),
64036                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64037                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
64038                acl_categories: ((1 as libc::c_ulonglong) << 4 as libc::c_int)
64039                    as uint64_t,
64040                key_specs_static: [
64041                    {
64042                        let mut init = keySpec {
64043                            notes: 0 as *const libc::c_char,
64044                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
64045                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
64046                            begin_search_type: KSPEC_BS_INDEX,
64047                            bs: C2RustUnnamed_3 {
64048                                index: {
64049                                    let mut init = C2RustUnnamed_5 {
64050                                        pos: 1 as libc::c_int,
64051                                    };
64052                                    init
64053                                },
64054                            },
64055                            find_keys_type: KSPEC_FK_RANGE,
64056                            fk: C2RustUnnamed_0 {
64057                                range: {
64058                                    let mut init = C2RustUnnamed_2 {
64059                                        lastkey: 0 as libc::c_int,
64060                                        keystep: 1 as libc::c_int,
64061                                        limit: 0 as libc::c_int,
64062                                    };
64063                                    init
64064                                },
64065                            },
64066                        };
64067                        init
64068                    },
64069                    {
64070                        let mut init = keySpec {
64071                            notes: 0 as *const libc::c_char,
64072                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64073                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
64074                            begin_search_type: KSPEC_BS_INDEX,
64075                            bs: C2RustUnnamed_3 {
64076                                index: {
64077                                    let mut init = C2RustUnnamed_5 {
64078                                        pos: 2 as libc::c_int,
64079                                    };
64080                                    init
64081                                },
64082                            },
64083                            find_keys_type: KSPEC_FK_KEYNUM,
64084                            fk: C2RustUnnamed_0 {
64085                                keynum: {
64086                                    let mut init = C2RustUnnamed_1 {
64087                                        keynumidx: 0 as libc::c_int,
64088                                        firstkey: 1 as libc::c_int,
64089                                        keystep: 1 as libc::c_int,
64090                                    };
64091                                    init
64092                                },
64093                            },
64094                        };
64095                        init
64096                    },
64097                    keySpec {
64098                        notes: 0 as *const libc::c_char,
64099                        flags: 0,
64100                        begin_search_type: KSPEC_BS_INVALID,
64101                        bs: C2RustUnnamed_3 {
64102                            index: C2RustUnnamed_5 { pos: 0 },
64103                        },
64104                        find_keys_type: KSPEC_FK_INVALID,
64105                        fk: C2RustUnnamed_0 {
64106                            range: C2RustUnnamed_2 {
64107                                lastkey: 0,
64108                                keystep: 0,
64109                                limit: 0,
64110                            },
64111                        },
64112                    },
64113                    keySpec {
64114                        notes: 0 as *const libc::c_char,
64115                        flags: 0,
64116                        begin_search_type: KSPEC_BS_INVALID,
64117                        bs: C2RustUnnamed_3 {
64118                            index: C2RustUnnamed_5 { pos: 0 },
64119                        },
64120                        find_keys_type: KSPEC_FK_INVALID,
64121                        fk: C2RustUnnamed_0 {
64122                            range: C2RustUnnamed_2 {
64123                                lastkey: 0,
64124                                keystep: 0,
64125                                limit: 0,
64126                            },
64127                        },
64128                    },
64129                ],
64130                getkeys_proc: Some(
64131                    zunionInterDiffStoreGetKeys
64132                        as unsafe extern "C" fn(
64133                            *mut redisCommand,
64134                            *mut *mut robj,
64135                            libc::c_int,
64136                            *mut getKeysResult,
64137                        ) -> libc::c_int,
64138                ),
64139                subcommands: 0 as *const redisCommand as *mut redisCommand,
64140                args: ZUNIONSTORE_Args.as_ptr() as *mut _,
64141                microseconds: 0,
64142                calls: 0,
64143                rejected_calls: 0,
64144                failed_calls: 0,
64145                id: 0,
64146                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64147                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64148                key_specs: 0 as *const keySpec as *mut keySpec,
64149                legacy_range_key_spec: keySpec {
64150                    notes: 0 as *const libc::c_char,
64151                    flags: 0,
64152                    begin_search_type: KSPEC_BS_INVALID,
64153                    bs: C2RustUnnamed_3 {
64154                        index: C2RustUnnamed_5 { pos: 0 },
64155                    },
64156                    find_keys_type: KSPEC_FK_INVALID,
64157                    fk: C2RustUnnamed_0 {
64158                        range: C2RustUnnamed_2 {
64159                            lastkey: 0,
64160                            keystep: 0,
64161                            limit: 0,
64162                        },
64163                    },
64164                },
64165                num_args: 0,
64166                num_history: 0,
64167                num_tips: 0,
64168                key_specs_num: 0,
64169                key_specs_max: 0,
64170                subcommands_dict: 0 as *const dict as *mut dict,
64171                parent: 0 as *const redisCommand as *mut redisCommand,
64172                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64173            };
64174            init
64175        },
64176        {
64177            let mut init = redisCommand {
64178                declared_name: b"xack\0" as *const u8 as *const libc::c_char,
64179                summary: b"Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.\0"
64180                    as *const u8 as *const libc::c_char,
64181                complexity: b"O(1) for each message ID processed.\0" as *const u8
64182                    as *const libc::c_char,
64183                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64184                doc_flags: 0 as libc::c_int,
64185                replaced_by: 0 as *const libc::c_char,
64186                deprecated_since: 0 as *const libc::c_char,
64187                group: COMMAND_GROUP_STREAM,
64188                history: 0 as *const commandHistory as *mut commandHistory,
64189                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
64190                proc_0: Some(xackCommand as unsafe extern "C" fn(*mut client) -> ()),
64191                arity: -(4 as libc::c_int),
64192                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64193                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
64194                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
64195                    as uint64_t,
64196                key_specs_static: [
64197                    {
64198                        let mut init = keySpec {
64199                            notes: 0 as *const libc::c_char,
64200                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
64201                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
64202                            begin_search_type: KSPEC_BS_INDEX,
64203                            bs: C2RustUnnamed_3 {
64204                                index: {
64205                                    let mut init = C2RustUnnamed_5 {
64206                                        pos: 1 as libc::c_int,
64207                                    };
64208                                    init
64209                                },
64210                            },
64211                            find_keys_type: KSPEC_FK_RANGE,
64212                            fk: C2RustUnnamed_0 {
64213                                range: {
64214                                    let mut init = C2RustUnnamed_2 {
64215                                        lastkey: 0 as libc::c_int,
64216                                        keystep: 1 as libc::c_int,
64217                                        limit: 0 as libc::c_int,
64218                                    };
64219                                    init
64220                                },
64221                            },
64222                        };
64223                        init
64224                    },
64225                    keySpec {
64226                        notes: 0 as *const libc::c_char,
64227                        flags: 0,
64228                        begin_search_type: KSPEC_BS_INVALID,
64229                        bs: C2RustUnnamed_3 {
64230                            index: C2RustUnnamed_5 { pos: 0 },
64231                        },
64232                        find_keys_type: KSPEC_FK_INVALID,
64233                        fk: C2RustUnnamed_0 {
64234                            range: C2RustUnnamed_2 {
64235                                lastkey: 0,
64236                                keystep: 0,
64237                                limit: 0,
64238                            },
64239                        },
64240                    },
64241                    keySpec {
64242                        notes: 0 as *const libc::c_char,
64243                        flags: 0,
64244                        begin_search_type: KSPEC_BS_INVALID,
64245                        bs: C2RustUnnamed_3 {
64246                            index: C2RustUnnamed_5 { pos: 0 },
64247                        },
64248                        find_keys_type: KSPEC_FK_INVALID,
64249                        fk: C2RustUnnamed_0 {
64250                            range: C2RustUnnamed_2 {
64251                                lastkey: 0,
64252                                keystep: 0,
64253                                limit: 0,
64254                            },
64255                        },
64256                    },
64257                    keySpec {
64258                        notes: 0 as *const libc::c_char,
64259                        flags: 0,
64260                        begin_search_type: KSPEC_BS_INVALID,
64261                        bs: C2RustUnnamed_3 {
64262                            index: C2RustUnnamed_5 { pos: 0 },
64263                        },
64264                        find_keys_type: KSPEC_FK_INVALID,
64265                        fk: C2RustUnnamed_0 {
64266                            range: C2RustUnnamed_2 {
64267                                lastkey: 0,
64268                                keystep: 0,
64269                                limit: 0,
64270                            },
64271                        },
64272                    },
64273                ],
64274                getkeys_proc: None,
64275                subcommands: 0 as *const redisCommand as *mut redisCommand,
64276                args: XACK_Args.as_ptr() as *mut _,
64277                microseconds: 0,
64278                calls: 0,
64279                rejected_calls: 0,
64280                failed_calls: 0,
64281                id: 0,
64282                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64283                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64284                key_specs: 0 as *const keySpec as *mut keySpec,
64285                legacy_range_key_spec: keySpec {
64286                    notes: 0 as *const libc::c_char,
64287                    flags: 0,
64288                    begin_search_type: KSPEC_BS_INVALID,
64289                    bs: C2RustUnnamed_3 {
64290                        index: C2RustUnnamed_5 { pos: 0 },
64291                    },
64292                    find_keys_type: KSPEC_FK_INVALID,
64293                    fk: C2RustUnnamed_0 {
64294                        range: C2RustUnnamed_2 {
64295                            lastkey: 0,
64296                            keystep: 0,
64297                            limit: 0,
64298                        },
64299                    },
64300                },
64301                num_args: 0,
64302                num_history: 0,
64303                num_tips: 0,
64304                key_specs_num: 0,
64305                key_specs_max: 0,
64306                subcommands_dict: 0 as *const dict as *mut dict,
64307                parent: 0 as *const redisCommand as *mut redisCommand,
64308                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64309            };
64310            init
64311        },
64312        {
64313            let mut init = redisCommand {
64314                declared_name: b"xadd\0" as *const u8 as *const libc::c_char,
64315                summary: b"Appends a new entry to a stream\0" as *const u8
64316                    as *const libc::c_char,
64317                complexity: b"O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.\0"
64318                    as *const u8 as *const libc::c_char,
64319                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64320                doc_flags: 0 as libc::c_int,
64321                replaced_by: 0 as *const libc::c_char,
64322                deprecated_since: 0 as *const libc::c_char,
64323                group: COMMAND_GROUP_STREAM,
64324                history: XADD_History.as_ptr() as *mut _,
64325                tips: XADD_tips.as_ptr() as *mut _,
64326                proc_0: Some(xaddCommand as unsafe extern "C" fn(*mut client) -> ()),
64327                arity: -(5 as libc::c_int),
64328                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64329                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
64330                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
64331                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
64332                    as uint64_t,
64333                key_specs_static: [
64334                    {
64335                        let mut init = keySpec {
64336                            notes: b"UPDATE instead of INSERT because of the optional trimming feature\0"
64337                                as *const u8 as *const libc::c_char,
64338                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
64339                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
64340                            begin_search_type: KSPEC_BS_INDEX,
64341                            bs: C2RustUnnamed_3 {
64342                                index: {
64343                                    let mut init = C2RustUnnamed_5 {
64344                                        pos: 1 as libc::c_int,
64345                                    };
64346                                    init
64347                                },
64348                            },
64349                            find_keys_type: KSPEC_FK_RANGE,
64350                            fk: C2RustUnnamed_0 {
64351                                range: {
64352                                    let mut init = C2RustUnnamed_2 {
64353                                        lastkey: 0 as libc::c_int,
64354                                        keystep: 1 as libc::c_int,
64355                                        limit: 0 as libc::c_int,
64356                                    };
64357                                    init
64358                                },
64359                            },
64360                        };
64361                        init
64362                    },
64363                    keySpec {
64364                        notes: 0 as *const libc::c_char,
64365                        flags: 0,
64366                        begin_search_type: KSPEC_BS_INVALID,
64367                        bs: C2RustUnnamed_3 {
64368                            index: C2RustUnnamed_5 { pos: 0 },
64369                        },
64370                        find_keys_type: KSPEC_FK_INVALID,
64371                        fk: C2RustUnnamed_0 {
64372                            range: C2RustUnnamed_2 {
64373                                lastkey: 0,
64374                                keystep: 0,
64375                                limit: 0,
64376                            },
64377                        },
64378                    },
64379                    keySpec {
64380                        notes: 0 as *const libc::c_char,
64381                        flags: 0,
64382                        begin_search_type: KSPEC_BS_INVALID,
64383                        bs: C2RustUnnamed_3 {
64384                            index: C2RustUnnamed_5 { pos: 0 },
64385                        },
64386                        find_keys_type: KSPEC_FK_INVALID,
64387                        fk: C2RustUnnamed_0 {
64388                            range: C2RustUnnamed_2 {
64389                                lastkey: 0,
64390                                keystep: 0,
64391                                limit: 0,
64392                            },
64393                        },
64394                    },
64395                    keySpec {
64396                        notes: 0 as *const libc::c_char,
64397                        flags: 0,
64398                        begin_search_type: KSPEC_BS_INVALID,
64399                        bs: C2RustUnnamed_3 {
64400                            index: C2RustUnnamed_5 { pos: 0 },
64401                        },
64402                        find_keys_type: KSPEC_FK_INVALID,
64403                        fk: C2RustUnnamed_0 {
64404                            range: C2RustUnnamed_2 {
64405                                lastkey: 0,
64406                                keystep: 0,
64407                                limit: 0,
64408                            },
64409                        },
64410                    },
64411                ],
64412                getkeys_proc: None,
64413                subcommands: 0 as *const redisCommand as *mut redisCommand,
64414                args: XADD_Args.as_ptr() as *mut _,
64415                microseconds: 0,
64416                calls: 0,
64417                rejected_calls: 0,
64418                failed_calls: 0,
64419                id: 0,
64420                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64421                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64422                key_specs: 0 as *const keySpec as *mut keySpec,
64423                legacy_range_key_spec: keySpec {
64424                    notes: 0 as *const libc::c_char,
64425                    flags: 0,
64426                    begin_search_type: KSPEC_BS_INVALID,
64427                    bs: C2RustUnnamed_3 {
64428                        index: C2RustUnnamed_5 { pos: 0 },
64429                    },
64430                    find_keys_type: KSPEC_FK_INVALID,
64431                    fk: C2RustUnnamed_0 {
64432                        range: C2RustUnnamed_2 {
64433                            lastkey: 0,
64434                            keystep: 0,
64435                            limit: 0,
64436                        },
64437                    },
64438                },
64439                num_args: 0,
64440                num_history: 0,
64441                num_tips: 0,
64442                key_specs_num: 0,
64443                key_specs_max: 0,
64444                subcommands_dict: 0 as *const dict as *mut dict,
64445                parent: 0 as *const redisCommand as *mut redisCommand,
64446                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64447            };
64448            init
64449        },
64450        {
64451            let mut init = redisCommand {
64452                declared_name: b"xautoclaim\0" as *const u8 as *const libc::c_char,
64453                summary: b"Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.\0"
64454                    as *const u8 as *const libc::c_char,
64455                complexity: b"O(1) if COUNT is small.\0" as *const u8
64456                    as *const libc::c_char,
64457                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
64458                doc_flags: 0 as libc::c_int,
64459                replaced_by: 0 as *const libc::c_char,
64460                deprecated_since: 0 as *const libc::c_char,
64461                group: COMMAND_GROUP_STREAM,
64462                history: XAUTOCLAIM_History.as_ptr() as *mut _,
64463                tips: XAUTOCLAIM_tips.as_ptr() as *mut _,
64464                proc_0: Some(
64465                    xautoclaimCommand as unsafe extern "C" fn(*mut client) -> (),
64466                ),
64467                arity: -(6 as libc::c_int),
64468                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64469                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
64470                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
64471                    as uint64_t,
64472                key_specs_static: [
64473                    {
64474                        let mut init = keySpec {
64475                            notes: 0 as *const libc::c_char,
64476                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
64477                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
64478                            begin_search_type: KSPEC_BS_INDEX,
64479                            bs: C2RustUnnamed_3 {
64480                                index: {
64481                                    let mut init = C2RustUnnamed_5 {
64482                                        pos: 1 as libc::c_int,
64483                                    };
64484                                    init
64485                                },
64486                            },
64487                            find_keys_type: KSPEC_FK_RANGE,
64488                            fk: C2RustUnnamed_0 {
64489                                range: {
64490                                    let mut init = C2RustUnnamed_2 {
64491                                        lastkey: 0 as libc::c_int,
64492                                        keystep: 1 as libc::c_int,
64493                                        limit: 0 as libc::c_int,
64494                                    };
64495                                    init
64496                                },
64497                            },
64498                        };
64499                        init
64500                    },
64501                    keySpec {
64502                        notes: 0 as *const libc::c_char,
64503                        flags: 0,
64504                        begin_search_type: KSPEC_BS_INVALID,
64505                        bs: C2RustUnnamed_3 {
64506                            index: C2RustUnnamed_5 { pos: 0 },
64507                        },
64508                        find_keys_type: KSPEC_FK_INVALID,
64509                        fk: C2RustUnnamed_0 {
64510                            range: C2RustUnnamed_2 {
64511                                lastkey: 0,
64512                                keystep: 0,
64513                                limit: 0,
64514                            },
64515                        },
64516                    },
64517                    keySpec {
64518                        notes: 0 as *const libc::c_char,
64519                        flags: 0,
64520                        begin_search_type: KSPEC_BS_INVALID,
64521                        bs: C2RustUnnamed_3 {
64522                            index: C2RustUnnamed_5 { pos: 0 },
64523                        },
64524                        find_keys_type: KSPEC_FK_INVALID,
64525                        fk: C2RustUnnamed_0 {
64526                            range: C2RustUnnamed_2 {
64527                                lastkey: 0,
64528                                keystep: 0,
64529                                limit: 0,
64530                            },
64531                        },
64532                    },
64533                    keySpec {
64534                        notes: 0 as *const libc::c_char,
64535                        flags: 0,
64536                        begin_search_type: KSPEC_BS_INVALID,
64537                        bs: C2RustUnnamed_3 {
64538                            index: C2RustUnnamed_5 { pos: 0 },
64539                        },
64540                        find_keys_type: KSPEC_FK_INVALID,
64541                        fk: C2RustUnnamed_0 {
64542                            range: C2RustUnnamed_2 {
64543                                lastkey: 0,
64544                                keystep: 0,
64545                                limit: 0,
64546                            },
64547                        },
64548                    },
64549                ],
64550                getkeys_proc: None,
64551                subcommands: 0 as *const redisCommand as *mut redisCommand,
64552                args: XAUTOCLAIM_Args.as_ptr() as *mut _,
64553                microseconds: 0,
64554                calls: 0,
64555                rejected_calls: 0,
64556                failed_calls: 0,
64557                id: 0,
64558                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64559                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64560                key_specs: 0 as *const keySpec as *mut keySpec,
64561                legacy_range_key_spec: keySpec {
64562                    notes: 0 as *const libc::c_char,
64563                    flags: 0,
64564                    begin_search_type: KSPEC_BS_INVALID,
64565                    bs: C2RustUnnamed_3 {
64566                        index: C2RustUnnamed_5 { pos: 0 },
64567                    },
64568                    find_keys_type: KSPEC_FK_INVALID,
64569                    fk: C2RustUnnamed_0 {
64570                        range: C2RustUnnamed_2 {
64571                            lastkey: 0,
64572                            keystep: 0,
64573                            limit: 0,
64574                        },
64575                    },
64576                },
64577                num_args: 0,
64578                num_history: 0,
64579                num_tips: 0,
64580                key_specs_num: 0,
64581                key_specs_max: 0,
64582                subcommands_dict: 0 as *const dict as *mut dict,
64583                parent: 0 as *const redisCommand as *mut redisCommand,
64584                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64585            };
64586            init
64587        },
64588        {
64589            let mut init = redisCommand {
64590                declared_name: b"xclaim\0" as *const u8 as *const libc::c_char,
64591                summary: b"Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.\0"
64592                    as *const u8 as *const libc::c_char,
64593                complexity: b"O(log N) with N being the number of messages in the PEL of the consumer group.\0"
64594                    as *const u8 as *const libc::c_char,
64595                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64596                doc_flags: 0 as libc::c_int,
64597                replaced_by: 0 as *const libc::c_char,
64598                deprecated_since: 0 as *const libc::c_char,
64599                group: COMMAND_GROUP_STREAM,
64600                history: 0 as *const commandHistory as *mut commandHistory,
64601                tips: XCLAIM_tips.as_ptr() as *mut _,
64602                proc_0: Some(xclaimCommand as unsafe extern "C" fn(*mut client) -> ()),
64603                arity: -(6 as libc::c_int),
64604                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64605                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
64606                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
64607                    as uint64_t,
64608                key_specs_static: [
64609                    {
64610                        let mut init = keySpec {
64611                            notes: 0 as *const libc::c_char,
64612                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
64613                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
64614                            begin_search_type: KSPEC_BS_INDEX,
64615                            bs: C2RustUnnamed_3 {
64616                                index: {
64617                                    let mut init = C2RustUnnamed_5 {
64618                                        pos: 1 as libc::c_int,
64619                                    };
64620                                    init
64621                                },
64622                            },
64623                            find_keys_type: KSPEC_FK_RANGE,
64624                            fk: C2RustUnnamed_0 {
64625                                range: {
64626                                    let mut init = C2RustUnnamed_2 {
64627                                        lastkey: 0 as libc::c_int,
64628                                        keystep: 1 as libc::c_int,
64629                                        limit: 0 as libc::c_int,
64630                                    };
64631                                    init
64632                                },
64633                            },
64634                        };
64635                        init
64636                    },
64637                    keySpec {
64638                        notes: 0 as *const libc::c_char,
64639                        flags: 0,
64640                        begin_search_type: KSPEC_BS_INVALID,
64641                        bs: C2RustUnnamed_3 {
64642                            index: C2RustUnnamed_5 { pos: 0 },
64643                        },
64644                        find_keys_type: KSPEC_FK_INVALID,
64645                        fk: C2RustUnnamed_0 {
64646                            range: C2RustUnnamed_2 {
64647                                lastkey: 0,
64648                                keystep: 0,
64649                                limit: 0,
64650                            },
64651                        },
64652                    },
64653                    keySpec {
64654                        notes: 0 as *const libc::c_char,
64655                        flags: 0,
64656                        begin_search_type: KSPEC_BS_INVALID,
64657                        bs: C2RustUnnamed_3 {
64658                            index: C2RustUnnamed_5 { pos: 0 },
64659                        },
64660                        find_keys_type: KSPEC_FK_INVALID,
64661                        fk: C2RustUnnamed_0 {
64662                            range: C2RustUnnamed_2 {
64663                                lastkey: 0,
64664                                keystep: 0,
64665                                limit: 0,
64666                            },
64667                        },
64668                    },
64669                    keySpec {
64670                        notes: 0 as *const libc::c_char,
64671                        flags: 0,
64672                        begin_search_type: KSPEC_BS_INVALID,
64673                        bs: C2RustUnnamed_3 {
64674                            index: C2RustUnnamed_5 { pos: 0 },
64675                        },
64676                        find_keys_type: KSPEC_FK_INVALID,
64677                        fk: C2RustUnnamed_0 {
64678                            range: C2RustUnnamed_2 {
64679                                lastkey: 0,
64680                                keystep: 0,
64681                                limit: 0,
64682                            },
64683                        },
64684                    },
64685                ],
64686                getkeys_proc: None,
64687                subcommands: 0 as *const redisCommand as *mut redisCommand,
64688                args: XCLAIM_Args.as_ptr() as *mut _,
64689                microseconds: 0,
64690                calls: 0,
64691                rejected_calls: 0,
64692                failed_calls: 0,
64693                id: 0,
64694                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64695                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64696                key_specs: 0 as *const keySpec as *mut keySpec,
64697                legacy_range_key_spec: keySpec {
64698                    notes: 0 as *const libc::c_char,
64699                    flags: 0,
64700                    begin_search_type: KSPEC_BS_INVALID,
64701                    bs: C2RustUnnamed_3 {
64702                        index: C2RustUnnamed_5 { pos: 0 },
64703                    },
64704                    find_keys_type: KSPEC_FK_INVALID,
64705                    fk: C2RustUnnamed_0 {
64706                        range: C2RustUnnamed_2 {
64707                            lastkey: 0,
64708                            keystep: 0,
64709                            limit: 0,
64710                        },
64711                    },
64712                },
64713                num_args: 0,
64714                num_history: 0,
64715                num_tips: 0,
64716                key_specs_num: 0,
64717                key_specs_max: 0,
64718                subcommands_dict: 0 as *const dict as *mut dict,
64719                parent: 0 as *const redisCommand as *mut redisCommand,
64720                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64721            };
64722            init
64723        },
64724        {
64725            let mut init = redisCommand {
64726                declared_name: b"xdel\0" as *const u8 as *const libc::c_char,
64727                summary: b"Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.\0"
64728                    as *const u8 as *const libc::c_char,
64729                complexity: b"O(1) for each single item to delete in the stream, regardless of the stream size.\0"
64730                    as *const u8 as *const libc::c_char,
64731                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64732                doc_flags: 0 as libc::c_int,
64733                replaced_by: 0 as *const libc::c_char,
64734                deprecated_since: 0 as *const libc::c_char,
64735                group: COMMAND_GROUP_STREAM,
64736                history: 0 as *const commandHistory as *mut commandHistory,
64737                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
64738                proc_0: Some(xdelCommand as unsafe extern "C" fn(*mut client) -> ()),
64739                arity: -(3 as libc::c_int),
64740                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
64741                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
64742                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
64743                    as uint64_t,
64744                key_specs_static: [
64745                    {
64746                        let mut init = keySpec {
64747                            notes: 0 as *const libc::c_char,
64748                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
64749                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
64750                            begin_search_type: KSPEC_BS_INDEX,
64751                            bs: C2RustUnnamed_3 {
64752                                index: {
64753                                    let mut init = C2RustUnnamed_5 {
64754                                        pos: 1 as libc::c_int,
64755                                    };
64756                                    init
64757                                },
64758                            },
64759                            find_keys_type: KSPEC_FK_RANGE,
64760                            fk: C2RustUnnamed_0 {
64761                                range: {
64762                                    let mut init = C2RustUnnamed_2 {
64763                                        lastkey: 0 as libc::c_int,
64764                                        keystep: 1 as libc::c_int,
64765                                        limit: 0 as libc::c_int,
64766                                    };
64767                                    init
64768                                },
64769                            },
64770                        };
64771                        init
64772                    },
64773                    keySpec {
64774                        notes: 0 as *const libc::c_char,
64775                        flags: 0,
64776                        begin_search_type: KSPEC_BS_INVALID,
64777                        bs: C2RustUnnamed_3 {
64778                            index: C2RustUnnamed_5 { pos: 0 },
64779                        },
64780                        find_keys_type: KSPEC_FK_INVALID,
64781                        fk: C2RustUnnamed_0 {
64782                            range: C2RustUnnamed_2 {
64783                                lastkey: 0,
64784                                keystep: 0,
64785                                limit: 0,
64786                            },
64787                        },
64788                    },
64789                    keySpec {
64790                        notes: 0 as *const libc::c_char,
64791                        flags: 0,
64792                        begin_search_type: KSPEC_BS_INVALID,
64793                        bs: C2RustUnnamed_3 {
64794                            index: C2RustUnnamed_5 { pos: 0 },
64795                        },
64796                        find_keys_type: KSPEC_FK_INVALID,
64797                        fk: C2RustUnnamed_0 {
64798                            range: C2RustUnnamed_2 {
64799                                lastkey: 0,
64800                                keystep: 0,
64801                                limit: 0,
64802                            },
64803                        },
64804                    },
64805                    keySpec {
64806                        notes: 0 as *const libc::c_char,
64807                        flags: 0,
64808                        begin_search_type: KSPEC_BS_INVALID,
64809                        bs: C2RustUnnamed_3 {
64810                            index: C2RustUnnamed_5 { pos: 0 },
64811                        },
64812                        find_keys_type: KSPEC_FK_INVALID,
64813                        fk: C2RustUnnamed_0 {
64814                            range: C2RustUnnamed_2 {
64815                                lastkey: 0,
64816                                keystep: 0,
64817                                limit: 0,
64818                            },
64819                        },
64820                    },
64821                ],
64822                getkeys_proc: None,
64823                subcommands: 0 as *const redisCommand as *mut redisCommand,
64824                args: XDEL_Args.as_ptr() as *mut _,
64825                microseconds: 0,
64826                calls: 0,
64827                rejected_calls: 0,
64828                failed_calls: 0,
64829                id: 0,
64830                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64831                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64832                key_specs: 0 as *const keySpec as *mut keySpec,
64833                legacy_range_key_spec: keySpec {
64834                    notes: 0 as *const libc::c_char,
64835                    flags: 0,
64836                    begin_search_type: KSPEC_BS_INVALID,
64837                    bs: C2RustUnnamed_3 {
64838                        index: C2RustUnnamed_5 { pos: 0 },
64839                    },
64840                    find_keys_type: KSPEC_FK_INVALID,
64841                    fk: C2RustUnnamed_0 {
64842                        range: C2RustUnnamed_2 {
64843                            lastkey: 0,
64844                            keystep: 0,
64845                            limit: 0,
64846                        },
64847                    },
64848                },
64849                num_args: 0,
64850                num_history: 0,
64851                num_tips: 0,
64852                key_specs_num: 0,
64853                key_specs_max: 0,
64854                subcommands_dict: 0 as *const dict as *mut dict,
64855                parent: 0 as *const redisCommand as *mut redisCommand,
64856                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64857            };
64858            init
64859        },
64860        {
64861            let mut init = redisCommand {
64862                declared_name: b"xgroup\0" as *const u8 as *const libc::c_char,
64863                summary: b"A container for consumer groups commands\0" as *const u8
64864                    as *const libc::c_char,
64865                complexity: b"Depends on subcommand.\0" as *const u8
64866                    as *const libc::c_char,
64867                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64868                doc_flags: 0 as libc::c_int,
64869                replaced_by: 0 as *const libc::c_char,
64870                deprecated_since: 0 as *const libc::c_char,
64871                group: COMMAND_GROUP_STREAM,
64872                history: 0 as *const commandHistory as *mut commandHistory,
64873                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
64874                proc_0: None,
64875                arity: -(2 as libc::c_int),
64876                flags: 0 as libc::c_int as uint64_t,
64877                acl_categories: 0 as libc::c_int as uint64_t,
64878                key_specs_static: [keySpec {
64879                    notes: 0 as *const libc::c_char,
64880                    flags: 0,
64881                    begin_search_type: KSPEC_BS_INVALID,
64882                    bs: C2RustUnnamed_3 {
64883                        index: C2RustUnnamed_5 { pos: 0 },
64884                    },
64885                    find_keys_type: KSPEC_FK_INVALID,
64886                    fk: C2RustUnnamed_0 {
64887                        range: C2RustUnnamed_2 {
64888                            lastkey: 0,
64889                            keystep: 0,
64890                            limit: 0,
64891                        },
64892                    },
64893                }; 4],
64894                getkeys_proc: None,
64895                subcommands: XGROUP_Subcommands.as_ptr() as *mut _,
64896                args: 0 as *const redisCommandArg as *mut redisCommandArg,
64897                microseconds: 0,
64898                calls: 0,
64899                rejected_calls: 0,
64900                failed_calls: 0,
64901                id: 0,
64902                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64903                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64904                key_specs: 0 as *const keySpec as *mut keySpec,
64905                legacy_range_key_spec: keySpec {
64906                    notes: 0 as *const libc::c_char,
64907                    flags: 0,
64908                    begin_search_type: KSPEC_BS_INVALID,
64909                    bs: C2RustUnnamed_3 {
64910                        index: C2RustUnnamed_5 { pos: 0 },
64911                    },
64912                    find_keys_type: KSPEC_FK_INVALID,
64913                    fk: C2RustUnnamed_0 {
64914                        range: C2RustUnnamed_2 {
64915                            lastkey: 0,
64916                            keystep: 0,
64917                            limit: 0,
64918                        },
64919                    },
64920                },
64921                num_args: 0,
64922                num_history: 0,
64923                num_tips: 0,
64924                key_specs_num: 0,
64925                key_specs_max: 0,
64926                subcommands_dict: 0 as *const dict as *mut dict,
64927                parent: 0 as *const redisCommand as *mut redisCommand,
64928                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
64929            };
64930            init
64931        },
64932        {
64933            let mut init = redisCommand {
64934                declared_name: b"xinfo\0" as *const u8 as *const libc::c_char,
64935                summary: b"A container for stream introspection commands\0" as *const u8
64936                    as *const libc::c_char,
64937                complexity: b"Depends on subcommand.\0" as *const u8
64938                    as *const libc::c_char,
64939                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
64940                doc_flags: 0 as libc::c_int,
64941                replaced_by: 0 as *const libc::c_char,
64942                deprecated_since: 0 as *const libc::c_char,
64943                group: COMMAND_GROUP_STREAM,
64944                history: 0 as *const commandHistory as *mut commandHistory,
64945                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
64946                proc_0: None,
64947                arity: -(2 as libc::c_int),
64948                flags: 0 as libc::c_int as uint64_t,
64949                acl_categories: 0 as libc::c_int as uint64_t,
64950                key_specs_static: [keySpec {
64951                    notes: 0 as *const libc::c_char,
64952                    flags: 0,
64953                    begin_search_type: KSPEC_BS_INVALID,
64954                    bs: C2RustUnnamed_3 {
64955                        index: C2RustUnnamed_5 { pos: 0 },
64956                    },
64957                    find_keys_type: KSPEC_FK_INVALID,
64958                    fk: C2RustUnnamed_0 {
64959                        range: C2RustUnnamed_2 {
64960                            lastkey: 0,
64961                            keystep: 0,
64962                            limit: 0,
64963                        },
64964                    },
64965                }; 4],
64966                getkeys_proc: None,
64967                subcommands: XINFO_Subcommands.as_ptr() as *mut _,
64968                args: 0 as *const redisCommandArg as *mut redisCommandArg,
64969                microseconds: 0,
64970                calls: 0,
64971                rejected_calls: 0,
64972                failed_calls: 0,
64973                id: 0,
64974                fullname: 0 as *const libc::c_char as *mut libc::c_char,
64975                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
64976                key_specs: 0 as *const keySpec as *mut keySpec,
64977                legacy_range_key_spec: keySpec {
64978                    notes: 0 as *const libc::c_char,
64979                    flags: 0,
64980                    begin_search_type: KSPEC_BS_INVALID,
64981                    bs: C2RustUnnamed_3 {
64982                        index: C2RustUnnamed_5 { pos: 0 },
64983                    },
64984                    find_keys_type: KSPEC_FK_INVALID,
64985                    fk: C2RustUnnamed_0 {
64986                        range: C2RustUnnamed_2 {
64987                            lastkey: 0,
64988                            keystep: 0,
64989                            limit: 0,
64990                        },
64991                    },
64992                },
64993                num_args: 0,
64994                num_history: 0,
64995                num_tips: 0,
64996                key_specs_num: 0,
64997                key_specs_max: 0,
64998                subcommands_dict: 0 as *const dict as *mut dict,
64999                parent: 0 as *const redisCommand as *mut redisCommand,
65000                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65001            };
65002            init
65003        },
65004        {
65005            let mut init = redisCommand {
65006                declared_name: b"xlen\0" as *const u8 as *const libc::c_char,
65007                summary: b"Return the number of entries in a stream\0" as *const u8
65008                    as *const libc::c_char,
65009                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
65010                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65011                doc_flags: 0 as libc::c_int,
65012                replaced_by: 0 as *const libc::c_char,
65013                deprecated_since: 0 as *const libc::c_char,
65014                group: COMMAND_GROUP_STREAM,
65015                history: 0 as *const commandHistory as *mut commandHistory,
65016                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65017                proc_0: Some(xlenCommand as unsafe extern "C" fn(*mut client) -> ()),
65018                arity: 2 as libc::c_int,
65019                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
65020                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
65021                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65022                    as uint64_t,
65023                key_specs_static: [
65024                    {
65025                        let mut init = keySpec {
65026                            notes: 0 as *const libc::c_char,
65027                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
65028                                as uint64_t,
65029                            begin_search_type: KSPEC_BS_INDEX,
65030                            bs: C2RustUnnamed_3 {
65031                                index: {
65032                                    let mut init = C2RustUnnamed_5 {
65033                                        pos: 1 as libc::c_int,
65034                                    };
65035                                    init
65036                                },
65037                            },
65038                            find_keys_type: KSPEC_FK_RANGE,
65039                            fk: C2RustUnnamed_0 {
65040                                range: {
65041                                    let mut init = C2RustUnnamed_2 {
65042                                        lastkey: 0 as libc::c_int,
65043                                        keystep: 1 as libc::c_int,
65044                                        limit: 0 as libc::c_int,
65045                                    };
65046                                    init
65047                                },
65048                            },
65049                        };
65050                        init
65051                    },
65052                    keySpec {
65053                        notes: 0 as *const libc::c_char,
65054                        flags: 0,
65055                        begin_search_type: KSPEC_BS_INVALID,
65056                        bs: C2RustUnnamed_3 {
65057                            index: C2RustUnnamed_5 { pos: 0 },
65058                        },
65059                        find_keys_type: KSPEC_FK_INVALID,
65060                        fk: C2RustUnnamed_0 {
65061                            range: C2RustUnnamed_2 {
65062                                lastkey: 0,
65063                                keystep: 0,
65064                                limit: 0,
65065                            },
65066                        },
65067                    },
65068                    keySpec {
65069                        notes: 0 as *const libc::c_char,
65070                        flags: 0,
65071                        begin_search_type: KSPEC_BS_INVALID,
65072                        bs: C2RustUnnamed_3 {
65073                            index: C2RustUnnamed_5 { pos: 0 },
65074                        },
65075                        find_keys_type: KSPEC_FK_INVALID,
65076                        fk: C2RustUnnamed_0 {
65077                            range: C2RustUnnamed_2 {
65078                                lastkey: 0,
65079                                keystep: 0,
65080                                limit: 0,
65081                            },
65082                        },
65083                    },
65084                    keySpec {
65085                        notes: 0 as *const libc::c_char,
65086                        flags: 0,
65087                        begin_search_type: KSPEC_BS_INVALID,
65088                        bs: C2RustUnnamed_3 {
65089                            index: C2RustUnnamed_5 { pos: 0 },
65090                        },
65091                        find_keys_type: KSPEC_FK_INVALID,
65092                        fk: C2RustUnnamed_0 {
65093                            range: C2RustUnnamed_2 {
65094                                lastkey: 0,
65095                                keystep: 0,
65096                                limit: 0,
65097                            },
65098                        },
65099                    },
65100                ],
65101                getkeys_proc: None,
65102                subcommands: 0 as *const redisCommand as *mut redisCommand,
65103                args: XLEN_Args.as_ptr() as *mut _,
65104                microseconds: 0,
65105                calls: 0,
65106                rejected_calls: 0,
65107                failed_calls: 0,
65108                id: 0,
65109                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65110                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65111                key_specs: 0 as *const keySpec as *mut keySpec,
65112                legacy_range_key_spec: keySpec {
65113                    notes: 0 as *const libc::c_char,
65114                    flags: 0,
65115                    begin_search_type: KSPEC_BS_INVALID,
65116                    bs: C2RustUnnamed_3 {
65117                        index: C2RustUnnamed_5 { pos: 0 },
65118                    },
65119                    find_keys_type: KSPEC_FK_INVALID,
65120                    fk: C2RustUnnamed_0 {
65121                        range: C2RustUnnamed_2 {
65122                            lastkey: 0,
65123                            keystep: 0,
65124                            limit: 0,
65125                        },
65126                    },
65127                },
65128                num_args: 0,
65129                num_history: 0,
65130                num_tips: 0,
65131                key_specs_num: 0,
65132                key_specs_max: 0,
65133                subcommands_dict: 0 as *const dict as *mut dict,
65134                parent: 0 as *const redisCommand as *mut redisCommand,
65135                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65136            };
65137            init
65138        },
65139        {
65140            let mut init = redisCommand {
65141                declared_name: b"xpending\0" as *const u8 as *const libc::c_char,
65142                summary: b"Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.\0"
65143                    as *const u8 as *const libc::c_char,
65144                complexity: b"O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.\0"
65145                    as *const u8 as *const libc::c_char,
65146                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65147                doc_flags: 0 as libc::c_int,
65148                replaced_by: 0 as *const libc::c_char,
65149                deprecated_since: 0 as *const libc::c_char,
65150                group: COMMAND_GROUP_STREAM,
65151                history: XPENDING_History.as_ptr() as *mut _,
65152                tips: XPENDING_tips.as_ptr() as *mut _,
65153                proc_0: Some(xpendingCommand as unsafe extern "C" fn(*mut client) -> ()),
65154                arity: -(3 as libc::c_int),
65155                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
65156                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65157                    as uint64_t,
65158                key_specs_static: [
65159                    {
65160                        let mut init = keySpec {
65161                            notes: 0 as *const libc::c_char,
65162                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65163                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
65164                            begin_search_type: KSPEC_BS_INDEX,
65165                            bs: C2RustUnnamed_3 {
65166                                index: {
65167                                    let mut init = C2RustUnnamed_5 {
65168                                        pos: 1 as libc::c_int,
65169                                    };
65170                                    init
65171                                },
65172                            },
65173                            find_keys_type: KSPEC_FK_RANGE,
65174                            fk: C2RustUnnamed_0 {
65175                                range: {
65176                                    let mut init = C2RustUnnamed_2 {
65177                                        lastkey: 0 as libc::c_int,
65178                                        keystep: 1 as libc::c_int,
65179                                        limit: 0 as libc::c_int,
65180                                    };
65181                                    init
65182                                },
65183                            },
65184                        };
65185                        init
65186                    },
65187                    keySpec {
65188                        notes: 0 as *const libc::c_char,
65189                        flags: 0,
65190                        begin_search_type: KSPEC_BS_INVALID,
65191                        bs: C2RustUnnamed_3 {
65192                            index: C2RustUnnamed_5 { pos: 0 },
65193                        },
65194                        find_keys_type: KSPEC_FK_INVALID,
65195                        fk: C2RustUnnamed_0 {
65196                            range: C2RustUnnamed_2 {
65197                                lastkey: 0,
65198                                keystep: 0,
65199                                limit: 0,
65200                            },
65201                        },
65202                    },
65203                    keySpec {
65204                        notes: 0 as *const libc::c_char,
65205                        flags: 0,
65206                        begin_search_type: KSPEC_BS_INVALID,
65207                        bs: C2RustUnnamed_3 {
65208                            index: C2RustUnnamed_5 { pos: 0 },
65209                        },
65210                        find_keys_type: KSPEC_FK_INVALID,
65211                        fk: C2RustUnnamed_0 {
65212                            range: C2RustUnnamed_2 {
65213                                lastkey: 0,
65214                                keystep: 0,
65215                                limit: 0,
65216                            },
65217                        },
65218                    },
65219                    keySpec {
65220                        notes: 0 as *const libc::c_char,
65221                        flags: 0,
65222                        begin_search_type: KSPEC_BS_INVALID,
65223                        bs: C2RustUnnamed_3 {
65224                            index: C2RustUnnamed_5 { pos: 0 },
65225                        },
65226                        find_keys_type: KSPEC_FK_INVALID,
65227                        fk: C2RustUnnamed_0 {
65228                            range: C2RustUnnamed_2 {
65229                                lastkey: 0,
65230                                keystep: 0,
65231                                limit: 0,
65232                            },
65233                        },
65234                    },
65235                ],
65236                getkeys_proc: None,
65237                subcommands: 0 as *const redisCommand as *mut redisCommand,
65238                args: XPENDING_Args.as_ptr() as *mut _,
65239                microseconds: 0,
65240                calls: 0,
65241                rejected_calls: 0,
65242                failed_calls: 0,
65243                id: 0,
65244                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65245                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65246                key_specs: 0 as *const keySpec as *mut keySpec,
65247                legacy_range_key_spec: keySpec {
65248                    notes: 0 as *const libc::c_char,
65249                    flags: 0,
65250                    begin_search_type: KSPEC_BS_INVALID,
65251                    bs: C2RustUnnamed_3 {
65252                        index: C2RustUnnamed_5 { pos: 0 },
65253                    },
65254                    find_keys_type: KSPEC_FK_INVALID,
65255                    fk: C2RustUnnamed_0 {
65256                        range: C2RustUnnamed_2 {
65257                            lastkey: 0,
65258                            keystep: 0,
65259                            limit: 0,
65260                        },
65261                    },
65262                },
65263                num_args: 0,
65264                num_history: 0,
65265                num_tips: 0,
65266                key_specs_num: 0,
65267                key_specs_max: 0,
65268                subcommands_dict: 0 as *const dict as *mut dict,
65269                parent: 0 as *const redisCommand as *mut redisCommand,
65270                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65271            };
65272            init
65273        },
65274        {
65275            let mut init = redisCommand {
65276                declared_name: b"xrange\0" as *const u8 as *const libc::c_char,
65277                summary: b"Return a range of elements in a stream, with IDs matching the specified IDs interval\0"
65278                    as *const u8 as *const libc::c_char,
65279                complexity: b"O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).\0"
65280                    as *const u8 as *const libc::c_char,
65281                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65282                doc_flags: 0 as libc::c_int,
65283                replaced_by: 0 as *const libc::c_char,
65284                deprecated_since: 0 as *const libc::c_char,
65285                group: COMMAND_GROUP_STREAM,
65286                history: XRANGE_History.as_ptr() as *mut _,
65287                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65288                proc_0: Some(xrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
65289                arity: -(4 as libc::c_int),
65290                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
65291                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65292                    as uint64_t,
65293                key_specs_static: [
65294                    {
65295                        let mut init = keySpec {
65296                            notes: 0 as *const libc::c_char,
65297                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65298                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
65299                            begin_search_type: KSPEC_BS_INDEX,
65300                            bs: C2RustUnnamed_3 {
65301                                index: {
65302                                    let mut init = C2RustUnnamed_5 {
65303                                        pos: 1 as libc::c_int,
65304                                    };
65305                                    init
65306                                },
65307                            },
65308                            find_keys_type: KSPEC_FK_RANGE,
65309                            fk: C2RustUnnamed_0 {
65310                                range: {
65311                                    let mut init = C2RustUnnamed_2 {
65312                                        lastkey: 0 as libc::c_int,
65313                                        keystep: 1 as libc::c_int,
65314                                        limit: 0 as libc::c_int,
65315                                    };
65316                                    init
65317                                },
65318                            },
65319                        };
65320                        init
65321                    },
65322                    keySpec {
65323                        notes: 0 as *const libc::c_char,
65324                        flags: 0,
65325                        begin_search_type: KSPEC_BS_INVALID,
65326                        bs: C2RustUnnamed_3 {
65327                            index: C2RustUnnamed_5 { pos: 0 },
65328                        },
65329                        find_keys_type: KSPEC_FK_INVALID,
65330                        fk: C2RustUnnamed_0 {
65331                            range: C2RustUnnamed_2 {
65332                                lastkey: 0,
65333                                keystep: 0,
65334                                limit: 0,
65335                            },
65336                        },
65337                    },
65338                    keySpec {
65339                        notes: 0 as *const libc::c_char,
65340                        flags: 0,
65341                        begin_search_type: KSPEC_BS_INVALID,
65342                        bs: C2RustUnnamed_3 {
65343                            index: C2RustUnnamed_5 { pos: 0 },
65344                        },
65345                        find_keys_type: KSPEC_FK_INVALID,
65346                        fk: C2RustUnnamed_0 {
65347                            range: C2RustUnnamed_2 {
65348                                lastkey: 0,
65349                                keystep: 0,
65350                                limit: 0,
65351                            },
65352                        },
65353                    },
65354                    keySpec {
65355                        notes: 0 as *const libc::c_char,
65356                        flags: 0,
65357                        begin_search_type: KSPEC_BS_INVALID,
65358                        bs: C2RustUnnamed_3 {
65359                            index: C2RustUnnamed_5 { pos: 0 },
65360                        },
65361                        find_keys_type: KSPEC_FK_INVALID,
65362                        fk: C2RustUnnamed_0 {
65363                            range: C2RustUnnamed_2 {
65364                                lastkey: 0,
65365                                keystep: 0,
65366                                limit: 0,
65367                            },
65368                        },
65369                    },
65370                ],
65371                getkeys_proc: None,
65372                subcommands: 0 as *const redisCommand as *mut redisCommand,
65373                args: XRANGE_Args.as_ptr() as *mut _,
65374                microseconds: 0,
65375                calls: 0,
65376                rejected_calls: 0,
65377                failed_calls: 0,
65378                id: 0,
65379                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65380                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65381                key_specs: 0 as *const keySpec as *mut keySpec,
65382                legacy_range_key_spec: keySpec {
65383                    notes: 0 as *const libc::c_char,
65384                    flags: 0,
65385                    begin_search_type: KSPEC_BS_INVALID,
65386                    bs: C2RustUnnamed_3 {
65387                        index: C2RustUnnamed_5 { pos: 0 },
65388                    },
65389                    find_keys_type: KSPEC_FK_INVALID,
65390                    fk: C2RustUnnamed_0 {
65391                        range: C2RustUnnamed_2 {
65392                            lastkey: 0,
65393                            keystep: 0,
65394                            limit: 0,
65395                        },
65396                    },
65397                },
65398                num_args: 0,
65399                num_history: 0,
65400                num_tips: 0,
65401                key_specs_num: 0,
65402                key_specs_max: 0,
65403                subcommands_dict: 0 as *const dict as *mut dict,
65404                parent: 0 as *const redisCommand as *mut redisCommand,
65405                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65406            };
65407            init
65408        },
65409        {
65410            let mut init = redisCommand {
65411                declared_name: b"xread\0" as *const u8 as *const libc::c_char,
65412                summary: b"Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.\0"
65413                    as *const u8 as *const libc::c_char,
65414                complexity: b"For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.\0"
65415                    as *const u8 as *const libc::c_char,
65416                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65417                doc_flags: 0 as libc::c_int,
65418                replaced_by: 0 as *const libc::c_char,
65419                deprecated_since: 0 as *const libc::c_char,
65420                group: COMMAND_GROUP_STREAM,
65421                history: 0 as *const commandHistory as *mut commandHistory,
65422                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65423                proc_0: Some(xreadCommand as unsafe extern "C" fn(*mut client) -> ()),
65424                arity: -(4 as libc::c_int),
65425                flags: ((1 as libc::c_ulonglong) << 8 as libc::c_int
65426                    | (1 as libc::c_ulonglong) << 1 as libc::c_int
65427                    | (1 as libc::c_ulonglong) << 8 as libc::c_int) as uint64_t,
65428                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65429                    as uint64_t,
65430                key_specs_static: [
65431                    {
65432                        let mut init = keySpec {
65433                            notes: 0 as *const libc::c_char,
65434                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65435                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
65436                            begin_search_type: KSPEC_BS_KEYWORD,
65437                            bs: C2RustUnnamed_3 {
65438                                keyword: {
65439                                    let mut init = C2RustUnnamed_4 {
65440                                        keyword: b"STREAMS\0" as *const u8 as *const libc::c_char,
65441                                        startfrom: 1 as libc::c_int,
65442                                    };
65443                                    init
65444                                },
65445                            },
65446                            find_keys_type: KSPEC_FK_RANGE,
65447                            fk: C2RustUnnamed_0 {
65448                                range: {
65449                                    let mut init = C2RustUnnamed_2 {
65450                                        lastkey: -(1 as libc::c_int),
65451                                        keystep: 1 as libc::c_int,
65452                                        limit: 2 as libc::c_int,
65453                                    };
65454                                    init
65455                                },
65456                            },
65457                        };
65458                        init
65459                    },
65460                    keySpec {
65461                        notes: 0 as *const libc::c_char,
65462                        flags: 0,
65463                        begin_search_type: KSPEC_BS_INVALID,
65464                        bs: C2RustUnnamed_3 {
65465                            index: C2RustUnnamed_5 { pos: 0 },
65466                        },
65467                        find_keys_type: KSPEC_FK_INVALID,
65468                        fk: C2RustUnnamed_0 {
65469                            range: C2RustUnnamed_2 {
65470                                lastkey: 0,
65471                                keystep: 0,
65472                                limit: 0,
65473                            },
65474                        },
65475                    },
65476                    keySpec {
65477                        notes: 0 as *const libc::c_char,
65478                        flags: 0,
65479                        begin_search_type: KSPEC_BS_INVALID,
65480                        bs: C2RustUnnamed_3 {
65481                            index: C2RustUnnamed_5 { pos: 0 },
65482                        },
65483                        find_keys_type: KSPEC_FK_INVALID,
65484                        fk: C2RustUnnamed_0 {
65485                            range: C2RustUnnamed_2 {
65486                                lastkey: 0,
65487                                keystep: 0,
65488                                limit: 0,
65489                            },
65490                        },
65491                    },
65492                    keySpec {
65493                        notes: 0 as *const libc::c_char,
65494                        flags: 0,
65495                        begin_search_type: KSPEC_BS_INVALID,
65496                        bs: C2RustUnnamed_3 {
65497                            index: C2RustUnnamed_5 { pos: 0 },
65498                        },
65499                        find_keys_type: KSPEC_FK_INVALID,
65500                        fk: C2RustUnnamed_0 {
65501                            range: C2RustUnnamed_2 {
65502                                lastkey: 0,
65503                                keystep: 0,
65504                                limit: 0,
65505                            },
65506                        },
65507                    },
65508                ],
65509                getkeys_proc: Some(
65510                    xreadGetKeys
65511                        as unsafe extern "C" fn(
65512                            *mut redisCommand,
65513                            *mut *mut robj,
65514                            libc::c_int,
65515                            *mut getKeysResult,
65516                        ) -> libc::c_int,
65517                ),
65518                subcommands: 0 as *const redisCommand as *mut redisCommand,
65519                args: XREAD_Args.as_ptr() as *mut _,
65520                microseconds: 0,
65521                calls: 0,
65522                rejected_calls: 0,
65523                failed_calls: 0,
65524                id: 0,
65525                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65526                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65527                key_specs: 0 as *const keySpec as *mut keySpec,
65528                legacy_range_key_spec: keySpec {
65529                    notes: 0 as *const libc::c_char,
65530                    flags: 0,
65531                    begin_search_type: KSPEC_BS_INVALID,
65532                    bs: C2RustUnnamed_3 {
65533                        index: C2RustUnnamed_5 { pos: 0 },
65534                    },
65535                    find_keys_type: KSPEC_FK_INVALID,
65536                    fk: C2RustUnnamed_0 {
65537                        range: C2RustUnnamed_2 {
65538                            lastkey: 0,
65539                            keystep: 0,
65540                            limit: 0,
65541                        },
65542                    },
65543                },
65544                num_args: 0,
65545                num_history: 0,
65546                num_tips: 0,
65547                key_specs_num: 0,
65548                key_specs_max: 0,
65549                subcommands_dict: 0 as *const dict as *mut dict,
65550                parent: 0 as *const redisCommand as *mut redisCommand,
65551                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65552            };
65553            init
65554        },
65555        {
65556            let mut init = redisCommand {
65557                declared_name: b"xreadgroup\0" as *const u8 as *const libc::c_char,
65558                summary: b"Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.\0"
65559                    as *const u8 as *const libc::c_char,
65560                complexity: b"For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.\0"
65561                    as *const u8 as *const libc::c_char,
65562                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65563                doc_flags: 0 as libc::c_int,
65564                replaced_by: 0 as *const libc::c_char,
65565                deprecated_since: 0 as *const libc::c_char,
65566                group: COMMAND_GROUP_STREAM,
65567                history: 0 as *const commandHistory as *mut commandHistory,
65568                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65569                proc_0: Some(xreadCommand as unsafe extern "C" fn(*mut client) -> ()),
65570                arity: -(7 as libc::c_int),
65571                flags: ((1 as libc::c_ulonglong) << 8 as libc::c_int
65572                    | (1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
65573                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65574                    as uint64_t,
65575                key_specs_static: [
65576                    {
65577                        let mut init = keySpec {
65578                            notes: 0 as *const libc::c_char,
65579                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65580                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
65581                            begin_search_type: KSPEC_BS_KEYWORD,
65582                            bs: C2RustUnnamed_3 {
65583                                keyword: {
65584                                    let mut init = C2RustUnnamed_4 {
65585                                        keyword: b"STREAMS\0" as *const u8 as *const libc::c_char,
65586                                        startfrom: 4 as libc::c_int,
65587                                    };
65588                                    init
65589                                },
65590                            },
65591                            find_keys_type: KSPEC_FK_RANGE,
65592                            fk: C2RustUnnamed_0 {
65593                                range: {
65594                                    let mut init = C2RustUnnamed_2 {
65595                                        lastkey: -(1 as libc::c_int),
65596                                        keystep: 1 as libc::c_int,
65597                                        limit: 2 as libc::c_int,
65598                                    };
65599                                    init
65600                                },
65601                            },
65602                        };
65603                        init
65604                    },
65605                    keySpec {
65606                        notes: 0 as *const libc::c_char,
65607                        flags: 0,
65608                        begin_search_type: KSPEC_BS_INVALID,
65609                        bs: C2RustUnnamed_3 {
65610                            index: C2RustUnnamed_5 { pos: 0 },
65611                        },
65612                        find_keys_type: KSPEC_FK_INVALID,
65613                        fk: C2RustUnnamed_0 {
65614                            range: C2RustUnnamed_2 {
65615                                lastkey: 0,
65616                                keystep: 0,
65617                                limit: 0,
65618                            },
65619                        },
65620                    },
65621                    keySpec {
65622                        notes: 0 as *const libc::c_char,
65623                        flags: 0,
65624                        begin_search_type: KSPEC_BS_INVALID,
65625                        bs: C2RustUnnamed_3 {
65626                            index: C2RustUnnamed_5 { pos: 0 },
65627                        },
65628                        find_keys_type: KSPEC_FK_INVALID,
65629                        fk: C2RustUnnamed_0 {
65630                            range: C2RustUnnamed_2 {
65631                                lastkey: 0,
65632                                keystep: 0,
65633                                limit: 0,
65634                            },
65635                        },
65636                    },
65637                    keySpec {
65638                        notes: 0 as *const libc::c_char,
65639                        flags: 0,
65640                        begin_search_type: KSPEC_BS_INVALID,
65641                        bs: C2RustUnnamed_3 {
65642                            index: C2RustUnnamed_5 { pos: 0 },
65643                        },
65644                        find_keys_type: KSPEC_FK_INVALID,
65645                        fk: C2RustUnnamed_0 {
65646                            range: C2RustUnnamed_2 {
65647                                lastkey: 0,
65648                                keystep: 0,
65649                                limit: 0,
65650                            },
65651                        },
65652                    },
65653                ],
65654                getkeys_proc: Some(
65655                    xreadGetKeys
65656                        as unsafe extern "C" fn(
65657                            *mut redisCommand,
65658                            *mut *mut robj,
65659                            libc::c_int,
65660                            *mut getKeysResult,
65661                        ) -> libc::c_int,
65662                ),
65663                subcommands: 0 as *const redisCommand as *mut redisCommand,
65664                args: XREADGROUP_Args.as_ptr() as *mut _,
65665                microseconds: 0,
65666                calls: 0,
65667                rejected_calls: 0,
65668                failed_calls: 0,
65669                id: 0,
65670                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65671                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65672                key_specs: 0 as *const keySpec as *mut keySpec,
65673                legacy_range_key_spec: keySpec {
65674                    notes: 0 as *const libc::c_char,
65675                    flags: 0,
65676                    begin_search_type: KSPEC_BS_INVALID,
65677                    bs: C2RustUnnamed_3 {
65678                        index: C2RustUnnamed_5 { pos: 0 },
65679                    },
65680                    find_keys_type: KSPEC_FK_INVALID,
65681                    fk: C2RustUnnamed_0 {
65682                        range: C2RustUnnamed_2 {
65683                            lastkey: 0,
65684                            keystep: 0,
65685                            limit: 0,
65686                        },
65687                    },
65688                },
65689                num_args: 0,
65690                num_history: 0,
65691                num_tips: 0,
65692                key_specs_num: 0,
65693                key_specs_max: 0,
65694                subcommands_dict: 0 as *const dict as *mut dict,
65695                parent: 0 as *const redisCommand as *mut redisCommand,
65696                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65697            };
65698            init
65699        },
65700        {
65701            let mut init = redisCommand {
65702                declared_name: b"xrevrange\0" as *const u8 as *const libc::c_char,
65703                summary: b"Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE\0"
65704                    as *const u8 as *const libc::c_char,
65705                complexity: b"O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).\0"
65706                    as *const u8 as *const libc::c_char,
65707                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65708                doc_flags: 0 as libc::c_int,
65709                replaced_by: 0 as *const libc::c_char,
65710                deprecated_since: 0 as *const libc::c_char,
65711                group: COMMAND_GROUP_STREAM,
65712                history: XREVRANGE_History.as_ptr() as *mut _,
65713                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65714                proc_0: Some(
65715                    xrevrangeCommand as unsafe extern "C" fn(*mut client) -> (),
65716                ),
65717                arity: -(4 as libc::c_int),
65718                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
65719                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65720                    as uint64_t,
65721                key_specs_static: [
65722                    {
65723                        let mut init = keySpec {
65724                            notes: 0 as *const libc::c_char,
65725                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65726                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
65727                            begin_search_type: KSPEC_BS_INDEX,
65728                            bs: C2RustUnnamed_3 {
65729                                index: {
65730                                    let mut init = C2RustUnnamed_5 {
65731                                        pos: 1 as libc::c_int,
65732                                    };
65733                                    init
65734                                },
65735                            },
65736                            find_keys_type: KSPEC_FK_RANGE,
65737                            fk: C2RustUnnamed_0 {
65738                                range: {
65739                                    let mut init = C2RustUnnamed_2 {
65740                                        lastkey: 0 as libc::c_int,
65741                                        keystep: 1 as libc::c_int,
65742                                        limit: 0 as libc::c_int,
65743                                    };
65744                                    init
65745                                },
65746                            },
65747                        };
65748                        init
65749                    },
65750                    keySpec {
65751                        notes: 0 as *const libc::c_char,
65752                        flags: 0,
65753                        begin_search_type: KSPEC_BS_INVALID,
65754                        bs: C2RustUnnamed_3 {
65755                            index: C2RustUnnamed_5 { pos: 0 },
65756                        },
65757                        find_keys_type: KSPEC_FK_INVALID,
65758                        fk: C2RustUnnamed_0 {
65759                            range: C2RustUnnamed_2 {
65760                                lastkey: 0,
65761                                keystep: 0,
65762                                limit: 0,
65763                            },
65764                        },
65765                    },
65766                    keySpec {
65767                        notes: 0 as *const libc::c_char,
65768                        flags: 0,
65769                        begin_search_type: KSPEC_BS_INVALID,
65770                        bs: C2RustUnnamed_3 {
65771                            index: C2RustUnnamed_5 { pos: 0 },
65772                        },
65773                        find_keys_type: KSPEC_FK_INVALID,
65774                        fk: C2RustUnnamed_0 {
65775                            range: C2RustUnnamed_2 {
65776                                lastkey: 0,
65777                                keystep: 0,
65778                                limit: 0,
65779                            },
65780                        },
65781                    },
65782                    keySpec {
65783                        notes: 0 as *const libc::c_char,
65784                        flags: 0,
65785                        begin_search_type: KSPEC_BS_INVALID,
65786                        bs: C2RustUnnamed_3 {
65787                            index: C2RustUnnamed_5 { pos: 0 },
65788                        },
65789                        find_keys_type: KSPEC_FK_INVALID,
65790                        fk: C2RustUnnamed_0 {
65791                            range: C2RustUnnamed_2 {
65792                                lastkey: 0,
65793                                keystep: 0,
65794                                limit: 0,
65795                            },
65796                        },
65797                    },
65798                ],
65799                getkeys_proc: None,
65800                subcommands: 0 as *const redisCommand as *mut redisCommand,
65801                args: XREVRANGE_Args.as_ptr() as *mut _,
65802                microseconds: 0,
65803                calls: 0,
65804                rejected_calls: 0,
65805                failed_calls: 0,
65806                id: 0,
65807                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65808                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65809                key_specs: 0 as *const keySpec as *mut keySpec,
65810                legacy_range_key_spec: keySpec {
65811                    notes: 0 as *const libc::c_char,
65812                    flags: 0,
65813                    begin_search_type: KSPEC_BS_INVALID,
65814                    bs: C2RustUnnamed_3 {
65815                        index: C2RustUnnamed_5 { pos: 0 },
65816                    },
65817                    find_keys_type: KSPEC_FK_INVALID,
65818                    fk: C2RustUnnamed_0 {
65819                        range: C2RustUnnamed_2 {
65820                            lastkey: 0,
65821                            keystep: 0,
65822                            limit: 0,
65823                        },
65824                    },
65825                },
65826                num_args: 0,
65827                num_history: 0,
65828                num_tips: 0,
65829                key_specs_num: 0,
65830                key_specs_max: 0,
65831                subcommands_dict: 0 as *const dict as *mut dict,
65832                parent: 0 as *const redisCommand as *mut redisCommand,
65833                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65834            };
65835            init
65836        },
65837        {
65838            let mut init = redisCommand {
65839                declared_name: b"xsetid\0" as *const u8 as *const libc::c_char,
65840                summary: b"An internal command for replicating stream values\0"
65841                    as *const u8 as *const libc::c_char,
65842                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
65843                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65844                doc_flags: 0 as libc::c_int,
65845                replaced_by: 0 as *const libc::c_char,
65846                deprecated_since: 0 as *const libc::c_char,
65847                group: COMMAND_GROUP_STREAM,
65848                history: XSETID_History.as_ptr() as *mut _,
65849                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
65850                proc_0: Some(xsetidCommand as unsafe extern "C" fn(*mut client) -> ()),
65851                arity: -(3 as libc::c_int),
65852                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
65853                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
65854                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
65855                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65856                    as uint64_t,
65857                key_specs_static: [
65858                    {
65859                        let mut init = keySpec {
65860                            notes: 0 as *const libc::c_char,
65861                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
65862                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
65863                            begin_search_type: KSPEC_BS_INDEX,
65864                            bs: C2RustUnnamed_3 {
65865                                index: {
65866                                    let mut init = C2RustUnnamed_5 {
65867                                        pos: 1 as libc::c_int,
65868                                    };
65869                                    init
65870                                },
65871                            },
65872                            find_keys_type: KSPEC_FK_RANGE,
65873                            fk: C2RustUnnamed_0 {
65874                                range: {
65875                                    let mut init = C2RustUnnamed_2 {
65876                                        lastkey: 0 as libc::c_int,
65877                                        keystep: 1 as libc::c_int,
65878                                        limit: 0 as libc::c_int,
65879                                    };
65880                                    init
65881                                },
65882                            },
65883                        };
65884                        init
65885                    },
65886                    keySpec {
65887                        notes: 0 as *const libc::c_char,
65888                        flags: 0,
65889                        begin_search_type: KSPEC_BS_INVALID,
65890                        bs: C2RustUnnamed_3 {
65891                            index: C2RustUnnamed_5 { pos: 0 },
65892                        },
65893                        find_keys_type: KSPEC_FK_INVALID,
65894                        fk: C2RustUnnamed_0 {
65895                            range: C2RustUnnamed_2 {
65896                                lastkey: 0,
65897                                keystep: 0,
65898                                limit: 0,
65899                            },
65900                        },
65901                    },
65902                    keySpec {
65903                        notes: 0 as *const libc::c_char,
65904                        flags: 0,
65905                        begin_search_type: KSPEC_BS_INVALID,
65906                        bs: C2RustUnnamed_3 {
65907                            index: C2RustUnnamed_5 { pos: 0 },
65908                        },
65909                        find_keys_type: KSPEC_FK_INVALID,
65910                        fk: C2RustUnnamed_0 {
65911                            range: C2RustUnnamed_2 {
65912                                lastkey: 0,
65913                                keystep: 0,
65914                                limit: 0,
65915                            },
65916                        },
65917                    },
65918                    keySpec {
65919                        notes: 0 as *const libc::c_char,
65920                        flags: 0,
65921                        begin_search_type: KSPEC_BS_INVALID,
65922                        bs: C2RustUnnamed_3 {
65923                            index: C2RustUnnamed_5 { pos: 0 },
65924                        },
65925                        find_keys_type: KSPEC_FK_INVALID,
65926                        fk: C2RustUnnamed_0 {
65927                            range: C2RustUnnamed_2 {
65928                                lastkey: 0,
65929                                keystep: 0,
65930                                limit: 0,
65931                            },
65932                        },
65933                    },
65934                ],
65935                getkeys_proc: None,
65936                subcommands: 0 as *const redisCommand as *mut redisCommand,
65937                args: XSETID_Args.as_ptr() as *mut _,
65938                microseconds: 0,
65939                calls: 0,
65940                rejected_calls: 0,
65941                failed_calls: 0,
65942                id: 0,
65943                fullname: 0 as *const libc::c_char as *mut libc::c_char,
65944                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
65945                key_specs: 0 as *const keySpec as *mut keySpec,
65946                legacy_range_key_spec: keySpec {
65947                    notes: 0 as *const libc::c_char,
65948                    flags: 0,
65949                    begin_search_type: KSPEC_BS_INVALID,
65950                    bs: C2RustUnnamed_3 {
65951                        index: C2RustUnnamed_5 { pos: 0 },
65952                    },
65953                    find_keys_type: KSPEC_FK_INVALID,
65954                    fk: C2RustUnnamed_0 {
65955                        range: C2RustUnnamed_2 {
65956                            lastkey: 0,
65957                            keystep: 0,
65958                            limit: 0,
65959                        },
65960                    },
65961                },
65962                num_args: 0,
65963                num_history: 0,
65964                num_tips: 0,
65965                key_specs_num: 0,
65966                key_specs_max: 0,
65967                subcommands_dict: 0 as *const dict as *mut dict,
65968                parent: 0 as *const redisCommand as *mut redisCommand,
65969                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
65970            };
65971            init
65972        },
65973        {
65974            let mut init = redisCommand {
65975                declared_name: b"xtrim\0" as *const u8 as *const libc::c_char,
65976                summary: b"Trims the stream to (approximately if '~' is passed) a certain size\0"
65977                    as *const u8 as *const libc::c_char,
65978                complexity: b"O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.\0"
65979                    as *const u8 as *const libc::c_char,
65980                since: b"5.0.0\0" as *const u8 as *const libc::c_char,
65981                doc_flags: 0 as libc::c_int,
65982                replaced_by: 0 as *const libc::c_char,
65983                deprecated_since: 0 as *const libc::c_char,
65984                group: COMMAND_GROUP_STREAM,
65985                history: XTRIM_History.as_ptr() as *mut _,
65986                tips: XTRIM_tips.as_ptr() as *mut _,
65987                proc_0: Some(xtrimCommand as unsafe extern "C" fn(*mut client) -> ()),
65988                arity: -(4 as libc::c_int),
65989                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int) as uint64_t,
65990                acl_categories: ((1 as libc::c_ulonglong) << 11 as libc::c_int)
65991                    as uint64_t,
65992                key_specs_static: [
65993                    {
65994                        let mut init = keySpec {
65995                            notes: 0 as *const libc::c_char,
65996                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
65997                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
65998                            begin_search_type: KSPEC_BS_INDEX,
65999                            bs: C2RustUnnamed_3 {
66000                                index: {
66001                                    let mut init = C2RustUnnamed_5 {
66002                                        pos: 1 as libc::c_int,
66003                                    };
66004                                    init
66005                                },
66006                            },
66007                            find_keys_type: KSPEC_FK_RANGE,
66008                            fk: C2RustUnnamed_0 {
66009                                range: {
66010                                    let mut init = C2RustUnnamed_2 {
66011                                        lastkey: 0 as libc::c_int,
66012                                        keystep: 1 as libc::c_int,
66013                                        limit: 0 as libc::c_int,
66014                                    };
66015                                    init
66016                                },
66017                            },
66018                        };
66019                        init
66020                    },
66021                    keySpec {
66022                        notes: 0 as *const libc::c_char,
66023                        flags: 0,
66024                        begin_search_type: KSPEC_BS_INVALID,
66025                        bs: C2RustUnnamed_3 {
66026                            index: C2RustUnnamed_5 { pos: 0 },
66027                        },
66028                        find_keys_type: KSPEC_FK_INVALID,
66029                        fk: C2RustUnnamed_0 {
66030                            range: C2RustUnnamed_2 {
66031                                lastkey: 0,
66032                                keystep: 0,
66033                                limit: 0,
66034                            },
66035                        },
66036                    },
66037                    keySpec {
66038                        notes: 0 as *const libc::c_char,
66039                        flags: 0,
66040                        begin_search_type: KSPEC_BS_INVALID,
66041                        bs: C2RustUnnamed_3 {
66042                            index: C2RustUnnamed_5 { pos: 0 },
66043                        },
66044                        find_keys_type: KSPEC_FK_INVALID,
66045                        fk: C2RustUnnamed_0 {
66046                            range: C2RustUnnamed_2 {
66047                                lastkey: 0,
66048                                keystep: 0,
66049                                limit: 0,
66050                            },
66051                        },
66052                    },
66053                    keySpec {
66054                        notes: 0 as *const libc::c_char,
66055                        flags: 0,
66056                        begin_search_type: KSPEC_BS_INVALID,
66057                        bs: C2RustUnnamed_3 {
66058                            index: C2RustUnnamed_5 { pos: 0 },
66059                        },
66060                        find_keys_type: KSPEC_FK_INVALID,
66061                        fk: C2RustUnnamed_0 {
66062                            range: C2RustUnnamed_2 {
66063                                lastkey: 0,
66064                                keystep: 0,
66065                                limit: 0,
66066                            },
66067                        },
66068                    },
66069                ],
66070                getkeys_proc: None,
66071                subcommands: 0 as *const redisCommand as *mut redisCommand,
66072                args: XTRIM_Args.as_ptr() as *mut _,
66073                microseconds: 0,
66074                calls: 0,
66075                rejected_calls: 0,
66076                failed_calls: 0,
66077                id: 0,
66078                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66079                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66080                key_specs: 0 as *const keySpec as *mut keySpec,
66081                legacy_range_key_spec: keySpec {
66082                    notes: 0 as *const libc::c_char,
66083                    flags: 0,
66084                    begin_search_type: KSPEC_BS_INVALID,
66085                    bs: C2RustUnnamed_3 {
66086                        index: C2RustUnnamed_5 { pos: 0 },
66087                    },
66088                    find_keys_type: KSPEC_FK_INVALID,
66089                    fk: C2RustUnnamed_0 {
66090                        range: C2RustUnnamed_2 {
66091                            lastkey: 0,
66092                            keystep: 0,
66093                            limit: 0,
66094                        },
66095                    },
66096                },
66097                num_args: 0,
66098                num_history: 0,
66099                num_tips: 0,
66100                key_specs_num: 0,
66101                key_specs_max: 0,
66102                subcommands_dict: 0 as *const dict as *mut dict,
66103                parent: 0 as *const redisCommand as *mut redisCommand,
66104                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66105            };
66106            init
66107        },
66108        {
66109            let mut init = redisCommand {
66110                declared_name: b"append\0" as *const u8 as *const libc::c_char,
66111                summary: b"Append a value to a key\0" as *const u8
66112                    as *const libc::c_char,
66113                complexity: b"O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.\0"
66114                    as *const u8 as *const libc::c_char,
66115                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
66116                doc_flags: 0 as libc::c_int,
66117                replaced_by: 0 as *const libc::c_char,
66118                deprecated_since: 0 as *const libc::c_char,
66119                group: COMMAND_GROUP_STRING,
66120                history: 0 as *const commandHistory as *mut commandHistory,
66121                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66122                proc_0: Some(appendCommand as unsafe extern "C" fn(*mut client) -> ()),
66123                arity: 3 as libc::c_int,
66124                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66125                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
66126                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66127                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66128                    as uint64_t,
66129                key_specs_static: [
66130                    {
66131                        let mut init = keySpec {
66132                            notes: 0 as *const libc::c_char,
66133                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66134                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
66135                            begin_search_type: KSPEC_BS_INDEX,
66136                            bs: C2RustUnnamed_3 {
66137                                index: {
66138                                    let mut init = C2RustUnnamed_5 {
66139                                        pos: 1 as libc::c_int,
66140                                    };
66141                                    init
66142                                },
66143                            },
66144                            find_keys_type: KSPEC_FK_RANGE,
66145                            fk: C2RustUnnamed_0 {
66146                                range: {
66147                                    let mut init = C2RustUnnamed_2 {
66148                                        lastkey: 0 as libc::c_int,
66149                                        keystep: 1 as libc::c_int,
66150                                        limit: 0 as libc::c_int,
66151                                    };
66152                                    init
66153                                },
66154                            },
66155                        };
66156                        init
66157                    },
66158                    keySpec {
66159                        notes: 0 as *const libc::c_char,
66160                        flags: 0,
66161                        begin_search_type: KSPEC_BS_INVALID,
66162                        bs: C2RustUnnamed_3 {
66163                            index: C2RustUnnamed_5 { pos: 0 },
66164                        },
66165                        find_keys_type: KSPEC_FK_INVALID,
66166                        fk: C2RustUnnamed_0 {
66167                            range: C2RustUnnamed_2 {
66168                                lastkey: 0,
66169                                keystep: 0,
66170                                limit: 0,
66171                            },
66172                        },
66173                    },
66174                    keySpec {
66175                        notes: 0 as *const libc::c_char,
66176                        flags: 0,
66177                        begin_search_type: KSPEC_BS_INVALID,
66178                        bs: C2RustUnnamed_3 {
66179                            index: C2RustUnnamed_5 { pos: 0 },
66180                        },
66181                        find_keys_type: KSPEC_FK_INVALID,
66182                        fk: C2RustUnnamed_0 {
66183                            range: C2RustUnnamed_2 {
66184                                lastkey: 0,
66185                                keystep: 0,
66186                                limit: 0,
66187                            },
66188                        },
66189                    },
66190                    keySpec {
66191                        notes: 0 as *const libc::c_char,
66192                        flags: 0,
66193                        begin_search_type: KSPEC_BS_INVALID,
66194                        bs: C2RustUnnamed_3 {
66195                            index: C2RustUnnamed_5 { pos: 0 },
66196                        },
66197                        find_keys_type: KSPEC_FK_INVALID,
66198                        fk: C2RustUnnamed_0 {
66199                            range: C2RustUnnamed_2 {
66200                                lastkey: 0,
66201                                keystep: 0,
66202                                limit: 0,
66203                            },
66204                        },
66205                    },
66206                ],
66207                getkeys_proc: None,
66208                subcommands: 0 as *const redisCommand as *mut redisCommand,
66209                args: APPEND_Args.as_ptr() as *mut _,
66210                microseconds: 0,
66211                calls: 0,
66212                rejected_calls: 0,
66213                failed_calls: 0,
66214                id: 0,
66215                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66216                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66217                key_specs: 0 as *const keySpec as *mut keySpec,
66218                legacy_range_key_spec: keySpec {
66219                    notes: 0 as *const libc::c_char,
66220                    flags: 0,
66221                    begin_search_type: KSPEC_BS_INVALID,
66222                    bs: C2RustUnnamed_3 {
66223                        index: C2RustUnnamed_5 { pos: 0 },
66224                    },
66225                    find_keys_type: KSPEC_FK_INVALID,
66226                    fk: C2RustUnnamed_0 {
66227                        range: C2RustUnnamed_2 {
66228                            lastkey: 0,
66229                            keystep: 0,
66230                            limit: 0,
66231                        },
66232                    },
66233                },
66234                num_args: 0,
66235                num_history: 0,
66236                num_tips: 0,
66237                key_specs_num: 0,
66238                key_specs_max: 0,
66239                subcommands_dict: 0 as *const dict as *mut dict,
66240                parent: 0 as *const redisCommand as *mut redisCommand,
66241                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66242            };
66243            init
66244        },
66245        {
66246            let mut init = redisCommand {
66247                declared_name: b"decr\0" as *const u8 as *const libc::c_char,
66248                summary: b"Decrement the integer value of a key by one\0" as *const u8
66249                    as *const libc::c_char,
66250                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
66251                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
66252                doc_flags: 0 as libc::c_int,
66253                replaced_by: 0 as *const libc::c_char,
66254                deprecated_since: 0 as *const libc::c_char,
66255                group: COMMAND_GROUP_STRING,
66256                history: 0 as *const commandHistory as *mut commandHistory,
66257                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66258                proc_0: Some(decrCommand as unsafe extern "C" fn(*mut client) -> ()),
66259                arity: 2 as libc::c_int,
66260                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66261                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
66262                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66263                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66264                    as uint64_t,
66265                key_specs_static: [
66266                    {
66267                        let mut init = keySpec {
66268                            notes: 0 as *const libc::c_char,
66269                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66270                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
66271                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
66272                            begin_search_type: KSPEC_BS_INDEX,
66273                            bs: C2RustUnnamed_3 {
66274                                index: {
66275                                    let mut init = C2RustUnnamed_5 {
66276                                        pos: 1 as libc::c_int,
66277                                    };
66278                                    init
66279                                },
66280                            },
66281                            find_keys_type: KSPEC_FK_RANGE,
66282                            fk: C2RustUnnamed_0 {
66283                                range: {
66284                                    let mut init = C2RustUnnamed_2 {
66285                                        lastkey: 0 as libc::c_int,
66286                                        keystep: 1 as libc::c_int,
66287                                        limit: 0 as libc::c_int,
66288                                    };
66289                                    init
66290                                },
66291                            },
66292                        };
66293                        init
66294                    },
66295                    keySpec {
66296                        notes: 0 as *const libc::c_char,
66297                        flags: 0,
66298                        begin_search_type: KSPEC_BS_INVALID,
66299                        bs: C2RustUnnamed_3 {
66300                            index: C2RustUnnamed_5 { pos: 0 },
66301                        },
66302                        find_keys_type: KSPEC_FK_INVALID,
66303                        fk: C2RustUnnamed_0 {
66304                            range: C2RustUnnamed_2 {
66305                                lastkey: 0,
66306                                keystep: 0,
66307                                limit: 0,
66308                            },
66309                        },
66310                    },
66311                    keySpec {
66312                        notes: 0 as *const libc::c_char,
66313                        flags: 0,
66314                        begin_search_type: KSPEC_BS_INVALID,
66315                        bs: C2RustUnnamed_3 {
66316                            index: C2RustUnnamed_5 { pos: 0 },
66317                        },
66318                        find_keys_type: KSPEC_FK_INVALID,
66319                        fk: C2RustUnnamed_0 {
66320                            range: C2RustUnnamed_2 {
66321                                lastkey: 0,
66322                                keystep: 0,
66323                                limit: 0,
66324                            },
66325                        },
66326                    },
66327                    keySpec {
66328                        notes: 0 as *const libc::c_char,
66329                        flags: 0,
66330                        begin_search_type: KSPEC_BS_INVALID,
66331                        bs: C2RustUnnamed_3 {
66332                            index: C2RustUnnamed_5 { pos: 0 },
66333                        },
66334                        find_keys_type: KSPEC_FK_INVALID,
66335                        fk: C2RustUnnamed_0 {
66336                            range: C2RustUnnamed_2 {
66337                                lastkey: 0,
66338                                keystep: 0,
66339                                limit: 0,
66340                            },
66341                        },
66342                    },
66343                ],
66344                getkeys_proc: None,
66345                subcommands: 0 as *const redisCommand as *mut redisCommand,
66346                args: DECR_Args.as_ptr() as *mut _,
66347                microseconds: 0,
66348                calls: 0,
66349                rejected_calls: 0,
66350                failed_calls: 0,
66351                id: 0,
66352                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66353                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66354                key_specs: 0 as *const keySpec as *mut keySpec,
66355                legacy_range_key_spec: keySpec {
66356                    notes: 0 as *const libc::c_char,
66357                    flags: 0,
66358                    begin_search_type: KSPEC_BS_INVALID,
66359                    bs: C2RustUnnamed_3 {
66360                        index: C2RustUnnamed_5 { pos: 0 },
66361                    },
66362                    find_keys_type: KSPEC_FK_INVALID,
66363                    fk: C2RustUnnamed_0 {
66364                        range: C2RustUnnamed_2 {
66365                            lastkey: 0,
66366                            keystep: 0,
66367                            limit: 0,
66368                        },
66369                    },
66370                },
66371                num_args: 0,
66372                num_history: 0,
66373                num_tips: 0,
66374                key_specs_num: 0,
66375                key_specs_max: 0,
66376                subcommands_dict: 0 as *const dict as *mut dict,
66377                parent: 0 as *const redisCommand as *mut redisCommand,
66378                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66379            };
66380            init
66381        },
66382        {
66383            let mut init = redisCommand {
66384                declared_name: b"decrby\0" as *const u8 as *const libc::c_char,
66385                summary: b"Decrement the integer value of a key by the given number\0"
66386                    as *const u8 as *const libc::c_char,
66387                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
66388                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
66389                doc_flags: 0 as libc::c_int,
66390                replaced_by: 0 as *const libc::c_char,
66391                deprecated_since: 0 as *const libc::c_char,
66392                group: COMMAND_GROUP_STRING,
66393                history: 0 as *const commandHistory as *mut commandHistory,
66394                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66395                proc_0: Some(decrbyCommand as unsafe extern "C" fn(*mut client) -> ()),
66396                arity: 3 as libc::c_int,
66397                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66398                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
66399                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66400                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66401                    as uint64_t,
66402                key_specs_static: [
66403                    {
66404                        let mut init = keySpec {
66405                            notes: 0 as *const libc::c_char,
66406                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66407                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
66408                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
66409                            begin_search_type: KSPEC_BS_INDEX,
66410                            bs: C2RustUnnamed_3 {
66411                                index: {
66412                                    let mut init = C2RustUnnamed_5 {
66413                                        pos: 1 as libc::c_int,
66414                                    };
66415                                    init
66416                                },
66417                            },
66418                            find_keys_type: KSPEC_FK_RANGE,
66419                            fk: C2RustUnnamed_0 {
66420                                range: {
66421                                    let mut init = C2RustUnnamed_2 {
66422                                        lastkey: 0 as libc::c_int,
66423                                        keystep: 1 as libc::c_int,
66424                                        limit: 0 as libc::c_int,
66425                                    };
66426                                    init
66427                                },
66428                            },
66429                        };
66430                        init
66431                    },
66432                    keySpec {
66433                        notes: 0 as *const libc::c_char,
66434                        flags: 0,
66435                        begin_search_type: KSPEC_BS_INVALID,
66436                        bs: C2RustUnnamed_3 {
66437                            index: C2RustUnnamed_5 { pos: 0 },
66438                        },
66439                        find_keys_type: KSPEC_FK_INVALID,
66440                        fk: C2RustUnnamed_0 {
66441                            range: C2RustUnnamed_2 {
66442                                lastkey: 0,
66443                                keystep: 0,
66444                                limit: 0,
66445                            },
66446                        },
66447                    },
66448                    keySpec {
66449                        notes: 0 as *const libc::c_char,
66450                        flags: 0,
66451                        begin_search_type: KSPEC_BS_INVALID,
66452                        bs: C2RustUnnamed_3 {
66453                            index: C2RustUnnamed_5 { pos: 0 },
66454                        },
66455                        find_keys_type: KSPEC_FK_INVALID,
66456                        fk: C2RustUnnamed_0 {
66457                            range: C2RustUnnamed_2 {
66458                                lastkey: 0,
66459                                keystep: 0,
66460                                limit: 0,
66461                            },
66462                        },
66463                    },
66464                    keySpec {
66465                        notes: 0 as *const libc::c_char,
66466                        flags: 0,
66467                        begin_search_type: KSPEC_BS_INVALID,
66468                        bs: C2RustUnnamed_3 {
66469                            index: C2RustUnnamed_5 { pos: 0 },
66470                        },
66471                        find_keys_type: KSPEC_FK_INVALID,
66472                        fk: C2RustUnnamed_0 {
66473                            range: C2RustUnnamed_2 {
66474                                lastkey: 0,
66475                                keystep: 0,
66476                                limit: 0,
66477                            },
66478                        },
66479                    },
66480                ],
66481                getkeys_proc: None,
66482                subcommands: 0 as *const redisCommand as *mut redisCommand,
66483                args: DECRBY_Args.as_ptr() as *mut _,
66484                microseconds: 0,
66485                calls: 0,
66486                rejected_calls: 0,
66487                failed_calls: 0,
66488                id: 0,
66489                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66490                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66491                key_specs: 0 as *const keySpec as *mut keySpec,
66492                legacy_range_key_spec: keySpec {
66493                    notes: 0 as *const libc::c_char,
66494                    flags: 0,
66495                    begin_search_type: KSPEC_BS_INVALID,
66496                    bs: C2RustUnnamed_3 {
66497                        index: C2RustUnnamed_5 { pos: 0 },
66498                    },
66499                    find_keys_type: KSPEC_FK_INVALID,
66500                    fk: C2RustUnnamed_0 {
66501                        range: C2RustUnnamed_2 {
66502                            lastkey: 0,
66503                            keystep: 0,
66504                            limit: 0,
66505                        },
66506                    },
66507                },
66508                num_args: 0,
66509                num_history: 0,
66510                num_tips: 0,
66511                key_specs_num: 0,
66512                key_specs_max: 0,
66513                subcommands_dict: 0 as *const dict as *mut dict,
66514                parent: 0 as *const redisCommand as *mut redisCommand,
66515                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66516            };
66517            init
66518        },
66519        {
66520            let mut init = redisCommand {
66521                declared_name: b"get\0" as *const u8 as *const libc::c_char,
66522                summary: b"Get the value of a key\0" as *const u8 as *const libc::c_char,
66523                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
66524                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
66525                doc_flags: 0 as libc::c_int,
66526                replaced_by: 0 as *const libc::c_char,
66527                deprecated_since: 0 as *const libc::c_char,
66528                group: COMMAND_GROUP_STRING,
66529                history: 0 as *const commandHistory as *mut commandHistory,
66530                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66531                proc_0: Some(getCommand as unsafe extern "C" fn(*mut client) -> ()),
66532                arity: 2 as libc::c_int,
66533                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66534                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66535                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66536                    as uint64_t,
66537                key_specs_static: [
66538                    {
66539                        let mut init = keySpec {
66540                            notes: 0 as *const libc::c_char,
66541                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66542                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
66543                            begin_search_type: KSPEC_BS_INDEX,
66544                            bs: C2RustUnnamed_3 {
66545                                index: {
66546                                    let mut init = C2RustUnnamed_5 {
66547                                        pos: 1 as libc::c_int,
66548                                    };
66549                                    init
66550                                },
66551                            },
66552                            find_keys_type: KSPEC_FK_RANGE,
66553                            fk: C2RustUnnamed_0 {
66554                                range: {
66555                                    let mut init = C2RustUnnamed_2 {
66556                                        lastkey: 0 as libc::c_int,
66557                                        keystep: 1 as libc::c_int,
66558                                        limit: 0 as libc::c_int,
66559                                    };
66560                                    init
66561                                },
66562                            },
66563                        };
66564                        init
66565                    },
66566                    keySpec {
66567                        notes: 0 as *const libc::c_char,
66568                        flags: 0,
66569                        begin_search_type: KSPEC_BS_INVALID,
66570                        bs: C2RustUnnamed_3 {
66571                            index: C2RustUnnamed_5 { pos: 0 },
66572                        },
66573                        find_keys_type: KSPEC_FK_INVALID,
66574                        fk: C2RustUnnamed_0 {
66575                            range: C2RustUnnamed_2 {
66576                                lastkey: 0,
66577                                keystep: 0,
66578                                limit: 0,
66579                            },
66580                        },
66581                    },
66582                    keySpec {
66583                        notes: 0 as *const libc::c_char,
66584                        flags: 0,
66585                        begin_search_type: KSPEC_BS_INVALID,
66586                        bs: C2RustUnnamed_3 {
66587                            index: C2RustUnnamed_5 { pos: 0 },
66588                        },
66589                        find_keys_type: KSPEC_FK_INVALID,
66590                        fk: C2RustUnnamed_0 {
66591                            range: C2RustUnnamed_2 {
66592                                lastkey: 0,
66593                                keystep: 0,
66594                                limit: 0,
66595                            },
66596                        },
66597                    },
66598                    keySpec {
66599                        notes: 0 as *const libc::c_char,
66600                        flags: 0,
66601                        begin_search_type: KSPEC_BS_INVALID,
66602                        bs: C2RustUnnamed_3 {
66603                            index: C2RustUnnamed_5 { pos: 0 },
66604                        },
66605                        find_keys_type: KSPEC_FK_INVALID,
66606                        fk: C2RustUnnamed_0 {
66607                            range: C2RustUnnamed_2 {
66608                                lastkey: 0,
66609                                keystep: 0,
66610                                limit: 0,
66611                            },
66612                        },
66613                    },
66614                ],
66615                getkeys_proc: None,
66616                subcommands: 0 as *const redisCommand as *mut redisCommand,
66617                args: GET_Args.as_ptr() as *mut _,
66618                microseconds: 0,
66619                calls: 0,
66620                rejected_calls: 0,
66621                failed_calls: 0,
66622                id: 0,
66623                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66624                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66625                key_specs: 0 as *const keySpec as *mut keySpec,
66626                legacy_range_key_spec: keySpec {
66627                    notes: 0 as *const libc::c_char,
66628                    flags: 0,
66629                    begin_search_type: KSPEC_BS_INVALID,
66630                    bs: C2RustUnnamed_3 {
66631                        index: C2RustUnnamed_5 { pos: 0 },
66632                    },
66633                    find_keys_type: KSPEC_FK_INVALID,
66634                    fk: C2RustUnnamed_0 {
66635                        range: C2RustUnnamed_2 {
66636                            lastkey: 0,
66637                            keystep: 0,
66638                            limit: 0,
66639                        },
66640                    },
66641                },
66642                num_args: 0,
66643                num_history: 0,
66644                num_tips: 0,
66645                key_specs_num: 0,
66646                key_specs_max: 0,
66647                subcommands_dict: 0 as *const dict as *mut dict,
66648                parent: 0 as *const redisCommand as *mut redisCommand,
66649                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66650            };
66651            init
66652        },
66653        {
66654            let mut init = redisCommand {
66655                declared_name: b"getdel\0" as *const u8 as *const libc::c_char,
66656                summary: b"Get the value of a key and delete the key\0" as *const u8
66657                    as *const libc::c_char,
66658                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
66659                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
66660                doc_flags: 0 as libc::c_int,
66661                replaced_by: 0 as *const libc::c_char,
66662                deprecated_since: 0 as *const libc::c_char,
66663                group: COMMAND_GROUP_STRING,
66664                history: 0 as *const commandHistory as *mut commandHistory,
66665                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66666                proc_0: Some(getdelCommand as unsafe extern "C" fn(*mut client) -> ()),
66667                arity: 2 as libc::c_int,
66668                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66669                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66670                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66671                    as uint64_t,
66672                key_specs_static: [
66673                    {
66674                        let mut init = keySpec {
66675                            notes: 0 as *const libc::c_char,
66676                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66677                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
66678                                | (1 as libc::c_ulonglong) << 7 as libc::c_int) as uint64_t,
66679                            begin_search_type: KSPEC_BS_INDEX,
66680                            bs: C2RustUnnamed_3 {
66681                                index: {
66682                                    let mut init = C2RustUnnamed_5 {
66683                                        pos: 1 as libc::c_int,
66684                                    };
66685                                    init
66686                                },
66687                            },
66688                            find_keys_type: KSPEC_FK_RANGE,
66689                            fk: C2RustUnnamed_0 {
66690                                range: {
66691                                    let mut init = C2RustUnnamed_2 {
66692                                        lastkey: 0 as libc::c_int,
66693                                        keystep: 1 as libc::c_int,
66694                                        limit: 0 as libc::c_int,
66695                                    };
66696                                    init
66697                                },
66698                            },
66699                        };
66700                        init
66701                    },
66702                    keySpec {
66703                        notes: 0 as *const libc::c_char,
66704                        flags: 0,
66705                        begin_search_type: KSPEC_BS_INVALID,
66706                        bs: C2RustUnnamed_3 {
66707                            index: C2RustUnnamed_5 { pos: 0 },
66708                        },
66709                        find_keys_type: KSPEC_FK_INVALID,
66710                        fk: C2RustUnnamed_0 {
66711                            range: C2RustUnnamed_2 {
66712                                lastkey: 0,
66713                                keystep: 0,
66714                                limit: 0,
66715                            },
66716                        },
66717                    },
66718                    keySpec {
66719                        notes: 0 as *const libc::c_char,
66720                        flags: 0,
66721                        begin_search_type: KSPEC_BS_INVALID,
66722                        bs: C2RustUnnamed_3 {
66723                            index: C2RustUnnamed_5 { pos: 0 },
66724                        },
66725                        find_keys_type: KSPEC_FK_INVALID,
66726                        fk: C2RustUnnamed_0 {
66727                            range: C2RustUnnamed_2 {
66728                                lastkey: 0,
66729                                keystep: 0,
66730                                limit: 0,
66731                            },
66732                        },
66733                    },
66734                    keySpec {
66735                        notes: 0 as *const libc::c_char,
66736                        flags: 0,
66737                        begin_search_type: KSPEC_BS_INVALID,
66738                        bs: C2RustUnnamed_3 {
66739                            index: C2RustUnnamed_5 { pos: 0 },
66740                        },
66741                        find_keys_type: KSPEC_FK_INVALID,
66742                        fk: C2RustUnnamed_0 {
66743                            range: C2RustUnnamed_2 {
66744                                lastkey: 0,
66745                                keystep: 0,
66746                                limit: 0,
66747                            },
66748                        },
66749                    },
66750                ],
66751                getkeys_proc: None,
66752                subcommands: 0 as *const redisCommand as *mut redisCommand,
66753                args: GETDEL_Args.as_ptr() as *mut _,
66754                microseconds: 0,
66755                calls: 0,
66756                rejected_calls: 0,
66757                failed_calls: 0,
66758                id: 0,
66759                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66760                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66761                key_specs: 0 as *const keySpec as *mut keySpec,
66762                legacy_range_key_spec: keySpec {
66763                    notes: 0 as *const libc::c_char,
66764                    flags: 0,
66765                    begin_search_type: KSPEC_BS_INVALID,
66766                    bs: C2RustUnnamed_3 {
66767                        index: C2RustUnnamed_5 { pos: 0 },
66768                    },
66769                    find_keys_type: KSPEC_FK_INVALID,
66770                    fk: C2RustUnnamed_0 {
66771                        range: C2RustUnnamed_2 {
66772                            lastkey: 0,
66773                            keystep: 0,
66774                            limit: 0,
66775                        },
66776                    },
66777                },
66778                num_args: 0,
66779                num_history: 0,
66780                num_tips: 0,
66781                key_specs_num: 0,
66782                key_specs_max: 0,
66783                subcommands_dict: 0 as *const dict as *mut dict,
66784                parent: 0 as *const redisCommand as *mut redisCommand,
66785                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66786            };
66787            init
66788        },
66789        {
66790            let mut init = redisCommand {
66791                declared_name: b"getex\0" as *const u8 as *const libc::c_char,
66792                summary: b"Get the value of a key and optionally set its expiration\0"
66793                    as *const u8 as *const libc::c_char,
66794                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
66795                since: b"6.2.0\0" as *const u8 as *const libc::c_char,
66796                doc_flags: 0 as libc::c_int,
66797                replaced_by: 0 as *const libc::c_char,
66798                deprecated_since: 0 as *const libc::c_char,
66799                group: COMMAND_GROUP_STRING,
66800                history: 0 as *const commandHistory as *mut commandHistory,
66801                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66802                proc_0: Some(getexCommand as unsafe extern "C" fn(*mut client) -> ()),
66803                arity: -(2 as libc::c_int),
66804                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66805                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
66806                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66807                    as uint64_t,
66808                key_specs_static: [
66809                    {
66810                        let mut init = keySpec {
66811                            notes: b"RW and UPDATE because it changes the TTL\0"
66812                                as *const u8 as *const libc::c_char,
66813                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
66814                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
66815                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
66816                            begin_search_type: KSPEC_BS_INDEX,
66817                            bs: C2RustUnnamed_3 {
66818                                index: {
66819                                    let mut init = C2RustUnnamed_5 {
66820                                        pos: 1 as libc::c_int,
66821                                    };
66822                                    init
66823                                },
66824                            },
66825                            find_keys_type: KSPEC_FK_RANGE,
66826                            fk: C2RustUnnamed_0 {
66827                                range: {
66828                                    let mut init = C2RustUnnamed_2 {
66829                                        lastkey: 0 as libc::c_int,
66830                                        keystep: 1 as libc::c_int,
66831                                        limit: 0 as libc::c_int,
66832                                    };
66833                                    init
66834                                },
66835                            },
66836                        };
66837                        init
66838                    },
66839                    keySpec {
66840                        notes: 0 as *const libc::c_char,
66841                        flags: 0,
66842                        begin_search_type: KSPEC_BS_INVALID,
66843                        bs: C2RustUnnamed_3 {
66844                            index: C2RustUnnamed_5 { pos: 0 },
66845                        },
66846                        find_keys_type: KSPEC_FK_INVALID,
66847                        fk: C2RustUnnamed_0 {
66848                            range: C2RustUnnamed_2 {
66849                                lastkey: 0,
66850                                keystep: 0,
66851                                limit: 0,
66852                            },
66853                        },
66854                    },
66855                    keySpec {
66856                        notes: 0 as *const libc::c_char,
66857                        flags: 0,
66858                        begin_search_type: KSPEC_BS_INVALID,
66859                        bs: C2RustUnnamed_3 {
66860                            index: C2RustUnnamed_5 { pos: 0 },
66861                        },
66862                        find_keys_type: KSPEC_FK_INVALID,
66863                        fk: C2RustUnnamed_0 {
66864                            range: C2RustUnnamed_2 {
66865                                lastkey: 0,
66866                                keystep: 0,
66867                                limit: 0,
66868                            },
66869                        },
66870                    },
66871                    keySpec {
66872                        notes: 0 as *const libc::c_char,
66873                        flags: 0,
66874                        begin_search_type: KSPEC_BS_INVALID,
66875                        bs: C2RustUnnamed_3 {
66876                            index: C2RustUnnamed_5 { pos: 0 },
66877                        },
66878                        find_keys_type: KSPEC_FK_INVALID,
66879                        fk: C2RustUnnamed_0 {
66880                            range: C2RustUnnamed_2 {
66881                                lastkey: 0,
66882                                keystep: 0,
66883                                limit: 0,
66884                            },
66885                        },
66886                    },
66887                ],
66888                getkeys_proc: None,
66889                subcommands: 0 as *const redisCommand as *mut redisCommand,
66890                args: GETEX_Args.as_ptr() as *mut _,
66891                microseconds: 0,
66892                calls: 0,
66893                rejected_calls: 0,
66894                failed_calls: 0,
66895                id: 0,
66896                fullname: 0 as *const libc::c_char as *mut libc::c_char,
66897                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
66898                key_specs: 0 as *const keySpec as *mut keySpec,
66899                legacy_range_key_spec: keySpec {
66900                    notes: 0 as *const libc::c_char,
66901                    flags: 0,
66902                    begin_search_type: KSPEC_BS_INVALID,
66903                    bs: C2RustUnnamed_3 {
66904                        index: C2RustUnnamed_5 { pos: 0 },
66905                    },
66906                    find_keys_type: KSPEC_FK_INVALID,
66907                    fk: C2RustUnnamed_0 {
66908                        range: C2RustUnnamed_2 {
66909                            lastkey: 0,
66910                            keystep: 0,
66911                            limit: 0,
66912                        },
66913                    },
66914                },
66915                num_args: 0,
66916                num_history: 0,
66917                num_tips: 0,
66918                key_specs_num: 0,
66919                key_specs_max: 0,
66920                subcommands_dict: 0 as *const dict as *mut dict,
66921                parent: 0 as *const redisCommand as *mut redisCommand,
66922                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
66923            };
66924            init
66925        },
66926        {
66927            let mut init = redisCommand {
66928                declared_name: b"getrange\0" as *const u8 as *const libc::c_char,
66929                summary: b"Get a substring of the string stored at a key\0" as *const u8
66930                    as *const libc::c_char,
66931                complexity: b"O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.\0"
66932                    as *const u8 as *const libc::c_char,
66933                since: b"2.4.0\0" as *const u8 as *const libc::c_char,
66934                doc_flags: 0 as libc::c_int,
66935                replaced_by: 0 as *const libc::c_char,
66936                deprecated_since: 0 as *const libc::c_char,
66937                group: COMMAND_GROUP_STRING,
66938                history: 0 as *const commandHistory as *mut commandHistory,
66939                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
66940                proc_0: Some(getrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
66941                arity: 4 as libc::c_int,
66942                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
66943                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
66944                    as uint64_t,
66945                key_specs_static: [
66946                    {
66947                        let mut init = keySpec {
66948                            notes: 0 as *const libc::c_char,
66949                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
66950                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
66951                            begin_search_type: KSPEC_BS_INDEX,
66952                            bs: C2RustUnnamed_3 {
66953                                index: {
66954                                    let mut init = C2RustUnnamed_5 {
66955                                        pos: 1 as libc::c_int,
66956                                    };
66957                                    init
66958                                },
66959                            },
66960                            find_keys_type: KSPEC_FK_RANGE,
66961                            fk: C2RustUnnamed_0 {
66962                                range: {
66963                                    let mut init = C2RustUnnamed_2 {
66964                                        lastkey: 0 as libc::c_int,
66965                                        keystep: 1 as libc::c_int,
66966                                        limit: 0 as libc::c_int,
66967                                    };
66968                                    init
66969                                },
66970                            },
66971                        };
66972                        init
66973                    },
66974                    keySpec {
66975                        notes: 0 as *const libc::c_char,
66976                        flags: 0,
66977                        begin_search_type: KSPEC_BS_INVALID,
66978                        bs: C2RustUnnamed_3 {
66979                            index: C2RustUnnamed_5 { pos: 0 },
66980                        },
66981                        find_keys_type: KSPEC_FK_INVALID,
66982                        fk: C2RustUnnamed_0 {
66983                            range: C2RustUnnamed_2 {
66984                                lastkey: 0,
66985                                keystep: 0,
66986                                limit: 0,
66987                            },
66988                        },
66989                    },
66990                    keySpec {
66991                        notes: 0 as *const libc::c_char,
66992                        flags: 0,
66993                        begin_search_type: KSPEC_BS_INVALID,
66994                        bs: C2RustUnnamed_3 {
66995                            index: C2RustUnnamed_5 { pos: 0 },
66996                        },
66997                        find_keys_type: KSPEC_FK_INVALID,
66998                        fk: C2RustUnnamed_0 {
66999                            range: C2RustUnnamed_2 {
67000                                lastkey: 0,
67001                                keystep: 0,
67002                                limit: 0,
67003                            },
67004                        },
67005                    },
67006                    keySpec {
67007                        notes: 0 as *const libc::c_char,
67008                        flags: 0,
67009                        begin_search_type: KSPEC_BS_INVALID,
67010                        bs: C2RustUnnamed_3 {
67011                            index: C2RustUnnamed_5 { pos: 0 },
67012                        },
67013                        find_keys_type: KSPEC_FK_INVALID,
67014                        fk: C2RustUnnamed_0 {
67015                            range: C2RustUnnamed_2 {
67016                                lastkey: 0,
67017                                keystep: 0,
67018                                limit: 0,
67019                            },
67020                        },
67021                    },
67022                ],
67023                getkeys_proc: None,
67024                subcommands: 0 as *const redisCommand as *mut redisCommand,
67025                args: GETRANGE_Args.as_ptr() as *mut _,
67026                microseconds: 0,
67027                calls: 0,
67028                rejected_calls: 0,
67029                failed_calls: 0,
67030                id: 0,
67031                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67032                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67033                key_specs: 0 as *const keySpec as *mut keySpec,
67034                legacy_range_key_spec: keySpec {
67035                    notes: 0 as *const libc::c_char,
67036                    flags: 0,
67037                    begin_search_type: KSPEC_BS_INVALID,
67038                    bs: C2RustUnnamed_3 {
67039                        index: C2RustUnnamed_5 { pos: 0 },
67040                    },
67041                    find_keys_type: KSPEC_FK_INVALID,
67042                    fk: C2RustUnnamed_0 {
67043                        range: C2RustUnnamed_2 {
67044                            lastkey: 0,
67045                            keystep: 0,
67046                            limit: 0,
67047                        },
67048                    },
67049                },
67050                num_args: 0,
67051                num_history: 0,
67052                num_tips: 0,
67053                key_specs_num: 0,
67054                key_specs_max: 0,
67055                subcommands_dict: 0 as *const dict as *mut dict,
67056                parent: 0 as *const redisCommand as *mut redisCommand,
67057                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67058            };
67059            init
67060        },
67061        {
67062            let mut init = redisCommand {
67063                declared_name: b"getset\0" as *const u8 as *const libc::c_char,
67064                summary: b"Set the string value of a key and return its old value\0"
67065                    as *const u8 as *const libc::c_char,
67066                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
67067                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
67068                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
67069                replaced_by: b"`SET` with the `!GET` argument\0" as *const u8
67070                    as *const libc::c_char,
67071                deprecated_since: b"6.2.0\0" as *const u8 as *const libc::c_char,
67072                group: COMMAND_GROUP_STRING,
67073                history: 0 as *const commandHistory as *mut commandHistory,
67074                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
67075                proc_0: Some(getsetCommand as unsafe extern "C" fn(*mut client) -> ()),
67076                arity: 3 as libc::c_int,
67077                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67078                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
67079                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
67080                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67081                    as uint64_t,
67082                key_specs_static: [
67083                    {
67084                        let mut init = keySpec {
67085                            notes: 0 as *const libc::c_char,
67086                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
67087                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
67088                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
67089                            begin_search_type: KSPEC_BS_INDEX,
67090                            bs: C2RustUnnamed_3 {
67091                                index: {
67092                                    let mut init = C2RustUnnamed_5 {
67093                                        pos: 1 as libc::c_int,
67094                                    };
67095                                    init
67096                                },
67097                            },
67098                            find_keys_type: KSPEC_FK_RANGE,
67099                            fk: C2RustUnnamed_0 {
67100                                range: {
67101                                    let mut init = C2RustUnnamed_2 {
67102                                        lastkey: 0 as libc::c_int,
67103                                        keystep: 1 as libc::c_int,
67104                                        limit: 0 as libc::c_int,
67105                                    };
67106                                    init
67107                                },
67108                            },
67109                        };
67110                        init
67111                    },
67112                    keySpec {
67113                        notes: 0 as *const libc::c_char,
67114                        flags: 0,
67115                        begin_search_type: KSPEC_BS_INVALID,
67116                        bs: C2RustUnnamed_3 {
67117                            index: C2RustUnnamed_5 { pos: 0 },
67118                        },
67119                        find_keys_type: KSPEC_FK_INVALID,
67120                        fk: C2RustUnnamed_0 {
67121                            range: C2RustUnnamed_2 {
67122                                lastkey: 0,
67123                                keystep: 0,
67124                                limit: 0,
67125                            },
67126                        },
67127                    },
67128                    keySpec {
67129                        notes: 0 as *const libc::c_char,
67130                        flags: 0,
67131                        begin_search_type: KSPEC_BS_INVALID,
67132                        bs: C2RustUnnamed_3 {
67133                            index: C2RustUnnamed_5 { pos: 0 },
67134                        },
67135                        find_keys_type: KSPEC_FK_INVALID,
67136                        fk: C2RustUnnamed_0 {
67137                            range: C2RustUnnamed_2 {
67138                                lastkey: 0,
67139                                keystep: 0,
67140                                limit: 0,
67141                            },
67142                        },
67143                    },
67144                    keySpec {
67145                        notes: 0 as *const libc::c_char,
67146                        flags: 0,
67147                        begin_search_type: KSPEC_BS_INVALID,
67148                        bs: C2RustUnnamed_3 {
67149                            index: C2RustUnnamed_5 { pos: 0 },
67150                        },
67151                        find_keys_type: KSPEC_FK_INVALID,
67152                        fk: C2RustUnnamed_0 {
67153                            range: C2RustUnnamed_2 {
67154                                lastkey: 0,
67155                                keystep: 0,
67156                                limit: 0,
67157                            },
67158                        },
67159                    },
67160                ],
67161                getkeys_proc: None,
67162                subcommands: 0 as *const redisCommand as *mut redisCommand,
67163                args: GETSET_Args.as_ptr() as *mut _,
67164                microseconds: 0,
67165                calls: 0,
67166                rejected_calls: 0,
67167                failed_calls: 0,
67168                id: 0,
67169                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67170                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67171                key_specs: 0 as *const keySpec as *mut keySpec,
67172                legacy_range_key_spec: keySpec {
67173                    notes: 0 as *const libc::c_char,
67174                    flags: 0,
67175                    begin_search_type: KSPEC_BS_INVALID,
67176                    bs: C2RustUnnamed_3 {
67177                        index: C2RustUnnamed_5 { pos: 0 },
67178                    },
67179                    find_keys_type: KSPEC_FK_INVALID,
67180                    fk: C2RustUnnamed_0 {
67181                        range: C2RustUnnamed_2 {
67182                            lastkey: 0,
67183                            keystep: 0,
67184                            limit: 0,
67185                        },
67186                    },
67187                },
67188                num_args: 0,
67189                num_history: 0,
67190                num_tips: 0,
67191                key_specs_num: 0,
67192                key_specs_max: 0,
67193                subcommands_dict: 0 as *const dict as *mut dict,
67194                parent: 0 as *const redisCommand as *mut redisCommand,
67195                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67196            };
67197            init
67198        },
67199        {
67200            let mut init = redisCommand {
67201                declared_name: b"incr\0" as *const u8 as *const libc::c_char,
67202                summary: b"Increment the integer value of a key by one\0" as *const u8
67203                    as *const libc::c_char,
67204                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
67205                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
67206                doc_flags: 0 as libc::c_int,
67207                replaced_by: 0 as *const libc::c_char,
67208                deprecated_since: 0 as *const libc::c_char,
67209                group: COMMAND_GROUP_STRING,
67210                history: 0 as *const commandHistory as *mut commandHistory,
67211                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
67212                proc_0: Some(incrCommand as unsafe extern "C" fn(*mut client) -> ()),
67213                arity: 2 as libc::c_int,
67214                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67215                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
67216                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
67217                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67218                    as uint64_t,
67219                key_specs_static: [
67220                    {
67221                        let mut init = keySpec {
67222                            notes: 0 as *const libc::c_char,
67223                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
67224                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
67225                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
67226                            begin_search_type: KSPEC_BS_INDEX,
67227                            bs: C2RustUnnamed_3 {
67228                                index: {
67229                                    let mut init = C2RustUnnamed_5 {
67230                                        pos: 1 as libc::c_int,
67231                                    };
67232                                    init
67233                                },
67234                            },
67235                            find_keys_type: KSPEC_FK_RANGE,
67236                            fk: C2RustUnnamed_0 {
67237                                range: {
67238                                    let mut init = C2RustUnnamed_2 {
67239                                        lastkey: 0 as libc::c_int,
67240                                        keystep: 1 as libc::c_int,
67241                                        limit: 0 as libc::c_int,
67242                                    };
67243                                    init
67244                                },
67245                            },
67246                        };
67247                        init
67248                    },
67249                    keySpec {
67250                        notes: 0 as *const libc::c_char,
67251                        flags: 0,
67252                        begin_search_type: KSPEC_BS_INVALID,
67253                        bs: C2RustUnnamed_3 {
67254                            index: C2RustUnnamed_5 { pos: 0 },
67255                        },
67256                        find_keys_type: KSPEC_FK_INVALID,
67257                        fk: C2RustUnnamed_0 {
67258                            range: C2RustUnnamed_2 {
67259                                lastkey: 0,
67260                                keystep: 0,
67261                                limit: 0,
67262                            },
67263                        },
67264                    },
67265                    keySpec {
67266                        notes: 0 as *const libc::c_char,
67267                        flags: 0,
67268                        begin_search_type: KSPEC_BS_INVALID,
67269                        bs: C2RustUnnamed_3 {
67270                            index: C2RustUnnamed_5 { pos: 0 },
67271                        },
67272                        find_keys_type: KSPEC_FK_INVALID,
67273                        fk: C2RustUnnamed_0 {
67274                            range: C2RustUnnamed_2 {
67275                                lastkey: 0,
67276                                keystep: 0,
67277                                limit: 0,
67278                            },
67279                        },
67280                    },
67281                    keySpec {
67282                        notes: 0 as *const libc::c_char,
67283                        flags: 0,
67284                        begin_search_type: KSPEC_BS_INVALID,
67285                        bs: C2RustUnnamed_3 {
67286                            index: C2RustUnnamed_5 { pos: 0 },
67287                        },
67288                        find_keys_type: KSPEC_FK_INVALID,
67289                        fk: C2RustUnnamed_0 {
67290                            range: C2RustUnnamed_2 {
67291                                lastkey: 0,
67292                                keystep: 0,
67293                                limit: 0,
67294                            },
67295                        },
67296                    },
67297                ],
67298                getkeys_proc: None,
67299                subcommands: 0 as *const redisCommand as *mut redisCommand,
67300                args: INCR_Args.as_ptr() as *mut _,
67301                microseconds: 0,
67302                calls: 0,
67303                rejected_calls: 0,
67304                failed_calls: 0,
67305                id: 0,
67306                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67307                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67308                key_specs: 0 as *const keySpec as *mut keySpec,
67309                legacy_range_key_spec: keySpec {
67310                    notes: 0 as *const libc::c_char,
67311                    flags: 0,
67312                    begin_search_type: KSPEC_BS_INVALID,
67313                    bs: C2RustUnnamed_3 {
67314                        index: C2RustUnnamed_5 { pos: 0 },
67315                    },
67316                    find_keys_type: KSPEC_FK_INVALID,
67317                    fk: C2RustUnnamed_0 {
67318                        range: C2RustUnnamed_2 {
67319                            lastkey: 0,
67320                            keystep: 0,
67321                            limit: 0,
67322                        },
67323                    },
67324                },
67325                num_args: 0,
67326                num_history: 0,
67327                num_tips: 0,
67328                key_specs_num: 0,
67329                key_specs_max: 0,
67330                subcommands_dict: 0 as *const dict as *mut dict,
67331                parent: 0 as *const redisCommand as *mut redisCommand,
67332                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67333            };
67334            init
67335        },
67336        {
67337            let mut init = redisCommand {
67338                declared_name: b"incrby\0" as *const u8 as *const libc::c_char,
67339                summary: b"Increment the integer value of a key by the given amount\0"
67340                    as *const u8 as *const libc::c_char,
67341                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
67342                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
67343                doc_flags: 0 as libc::c_int,
67344                replaced_by: 0 as *const libc::c_char,
67345                deprecated_since: 0 as *const libc::c_char,
67346                group: COMMAND_GROUP_STRING,
67347                history: 0 as *const commandHistory as *mut commandHistory,
67348                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
67349                proc_0: Some(incrbyCommand as unsafe extern "C" fn(*mut client) -> ()),
67350                arity: 3 as libc::c_int,
67351                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67352                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
67353                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
67354                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67355                    as uint64_t,
67356                key_specs_static: [
67357                    {
67358                        let mut init = keySpec {
67359                            notes: 0 as *const libc::c_char,
67360                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
67361                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
67362                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
67363                            begin_search_type: KSPEC_BS_INDEX,
67364                            bs: C2RustUnnamed_3 {
67365                                index: {
67366                                    let mut init = C2RustUnnamed_5 {
67367                                        pos: 1 as libc::c_int,
67368                                    };
67369                                    init
67370                                },
67371                            },
67372                            find_keys_type: KSPEC_FK_RANGE,
67373                            fk: C2RustUnnamed_0 {
67374                                range: {
67375                                    let mut init = C2RustUnnamed_2 {
67376                                        lastkey: 0 as libc::c_int,
67377                                        keystep: 1 as libc::c_int,
67378                                        limit: 0 as libc::c_int,
67379                                    };
67380                                    init
67381                                },
67382                            },
67383                        };
67384                        init
67385                    },
67386                    keySpec {
67387                        notes: 0 as *const libc::c_char,
67388                        flags: 0,
67389                        begin_search_type: KSPEC_BS_INVALID,
67390                        bs: C2RustUnnamed_3 {
67391                            index: C2RustUnnamed_5 { pos: 0 },
67392                        },
67393                        find_keys_type: KSPEC_FK_INVALID,
67394                        fk: C2RustUnnamed_0 {
67395                            range: C2RustUnnamed_2 {
67396                                lastkey: 0,
67397                                keystep: 0,
67398                                limit: 0,
67399                            },
67400                        },
67401                    },
67402                    keySpec {
67403                        notes: 0 as *const libc::c_char,
67404                        flags: 0,
67405                        begin_search_type: KSPEC_BS_INVALID,
67406                        bs: C2RustUnnamed_3 {
67407                            index: C2RustUnnamed_5 { pos: 0 },
67408                        },
67409                        find_keys_type: KSPEC_FK_INVALID,
67410                        fk: C2RustUnnamed_0 {
67411                            range: C2RustUnnamed_2 {
67412                                lastkey: 0,
67413                                keystep: 0,
67414                                limit: 0,
67415                            },
67416                        },
67417                    },
67418                    keySpec {
67419                        notes: 0 as *const libc::c_char,
67420                        flags: 0,
67421                        begin_search_type: KSPEC_BS_INVALID,
67422                        bs: C2RustUnnamed_3 {
67423                            index: C2RustUnnamed_5 { pos: 0 },
67424                        },
67425                        find_keys_type: KSPEC_FK_INVALID,
67426                        fk: C2RustUnnamed_0 {
67427                            range: C2RustUnnamed_2 {
67428                                lastkey: 0,
67429                                keystep: 0,
67430                                limit: 0,
67431                            },
67432                        },
67433                    },
67434                ],
67435                getkeys_proc: None,
67436                subcommands: 0 as *const redisCommand as *mut redisCommand,
67437                args: INCRBY_Args.as_ptr() as *mut _,
67438                microseconds: 0,
67439                calls: 0,
67440                rejected_calls: 0,
67441                failed_calls: 0,
67442                id: 0,
67443                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67444                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67445                key_specs: 0 as *const keySpec as *mut keySpec,
67446                legacy_range_key_spec: keySpec {
67447                    notes: 0 as *const libc::c_char,
67448                    flags: 0,
67449                    begin_search_type: KSPEC_BS_INVALID,
67450                    bs: C2RustUnnamed_3 {
67451                        index: C2RustUnnamed_5 { pos: 0 },
67452                    },
67453                    find_keys_type: KSPEC_FK_INVALID,
67454                    fk: C2RustUnnamed_0 {
67455                        range: C2RustUnnamed_2 {
67456                            lastkey: 0,
67457                            keystep: 0,
67458                            limit: 0,
67459                        },
67460                    },
67461                },
67462                num_args: 0,
67463                num_history: 0,
67464                num_tips: 0,
67465                key_specs_num: 0,
67466                key_specs_max: 0,
67467                subcommands_dict: 0 as *const dict as *mut dict,
67468                parent: 0 as *const redisCommand as *mut redisCommand,
67469                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67470            };
67471            init
67472        },
67473        {
67474            let mut init = redisCommand {
67475                declared_name: b"incrbyfloat\0" as *const u8 as *const libc::c_char,
67476                summary: b"Increment the float value of a key by the given amount\0"
67477                    as *const u8 as *const libc::c_char,
67478                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
67479                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
67480                doc_flags: 0 as libc::c_int,
67481                replaced_by: 0 as *const libc::c_char,
67482                deprecated_since: 0 as *const libc::c_char,
67483                group: COMMAND_GROUP_STRING,
67484                history: 0 as *const commandHistory as *mut commandHistory,
67485                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
67486                proc_0: Some(
67487                    incrbyfloatCommand as unsafe extern "C" fn(*mut client) -> (),
67488                ),
67489                arity: 3 as libc::c_int,
67490                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67491                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
67492                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
67493                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67494                    as uint64_t,
67495                key_specs_static: [
67496                    {
67497                        let mut init = keySpec {
67498                            notes: 0 as *const libc::c_char,
67499                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
67500                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
67501                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
67502                            begin_search_type: KSPEC_BS_INDEX,
67503                            bs: C2RustUnnamed_3 {
67504                                index: {
67505                                    let mut init = C2RustUnnamed_5 {
67506                                        pos: 1 as libc::c_int,
67507                                    };
67508                                    init
67509                                },
67510                            },
67511                            find_keys_type: KSPEC_FK_RANGE,
67512                            fk: C2RustUnnamed_0 {
67513                                range: {
67514                                    let mut init = C2RustUnnamed_2 {
67515                                        lastkey: 0 as libc::c_int,
67516                                        keystep: 1 as libc::c_int,
67517                                        limit: 0 as libc::c_int,
67518                                    };
67519                                    init
67520                                },
67521                            },
67522                        };
67523                        init
67524                    },
67525                    keySpec {
67526                        notes: 0 as *const libc::c_char,
67527                        flags: 0,
67528                        begin_search_type: KSPEC_BS_INVALID,
67529                        bs: C2RustUnnamed_3 {
67530                            index: C2RustUnnamed_5 { pos: 0 },
67531                        },
67532                        find_keys_type: KSPEC_FK_INVALID,
67533                        fk: C2RustUnnamed_0 {
67534                            range: C2RustUnnamed_2 {
67535                                lastkey: 0,
67536                                keystep: 0,
67537                                limit: 0,
67538                            },
67539                        },
67540                    },
67541                    keySpec {
67542                        notes: 0 as *const libc::c_char,
67543                        flags: 0,
67544                        begin_search_type: KSPEC_BS_INVALID,
67545                        bs: C2RustUnnamed_3 {
67546                            index: C2RustUnnamed_5 { pos: 0 },
67547                        },
67548                        find_keys_type: KSPEC_FK_INVALID,
67549                        fk: C2RustUnnamed_0 {
67550                            range: C2RustUnnamed_2 {
67551                                lastkey: 0,
67552                                keystep: 0,
67553                                limit: 0,
67554                            },
67555                        },
67556                    },
67557                    keySpec {
67558                        notes: 0 as *const libc::c_char,
67559                        flags: 0,
67560                        begin_search_type: KSPEC_BS_INVALID,
67561                        bs: C2RustUnnamed_3 {
67562                            index: C2RustUnnamed_5 { pos: 0 },
67563                        },
67564                        find_keys_type: KSPEC_FK_INVALID,
67565                        fk: C2RustUnnamed_0 {
67566                            range: C2RustUnnamed_2 {
67567                                lastkey: 0,
67568                                keystep: 0,
67569                                limit: 0,
67570                            },
67571                        },
67572                    },
67573                ],
67574                getkeys_proc: None,
67575                subcommands: 0 as *const redisCommand as *mut redisCommand,
67576                args: INCRBYFLOAT_Args.as_ptr() as *mut _,
67577                microseconds: 0,
67578                calls: 0,
67579                rejected_calls: 0,
67580                failed_calls: 0,
67581                id: 0,
67582                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67583                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67584                key_specs: 0 as *const keySpec as *mut keySpec,
67585                legacy_range_key_spec: keySpec {
67586                    notes: 0 as *const libc::c_char,
67587                    flags: 0,
67588                    begin_search_type: KSPEC_BS_INVALID,
67589                    bs: C2RustUnnamed_3 {
67590                        index: C2RustUnnamed_5 { pos: 0 },
67591                    },
67592                    find_keys_type: KSPEC_FK_INVALID,
67593                    fk: C2RustUnnamed_0 {
67594                        range: C2RustUnnamed_2 {
67595                            lastkey: 0,
67596                            keystep: 0,
67597                            limit: 0,
67598                        },
67599                    },
67600                },
67601                num_args: 0,
67602                num_history: 0,
67603                num_tips: 0,
67604                key_specs_num: 0,
67605                key_specs_max: 0,
67606                subcommands_dict: 0 as *const dict as *mut dict,
67607                parent: 0 as *const redisCommand as *mut redisCommand,
67608                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67609            };
67610            init
67611        },
67612        {
67613            let mut init = redisCommand {
67614                declared_name: b"lcs\0" as *const u8 as *const libc::c_char,
67615                summary: b"Find longest common substring\0" as *const u8
67616                    as *const libc::c_char,
67617                complexity: b"O(N*M) where N and M are the lengths of s1 and s2, respectively\0"
67618                    as *const u8 as *const libc::c_char,
67619                since: b"7.0.0\0" as *const u8 as *const libc::c_char,
67620                doc_flags: 0 as libc::c_int,
67621                replaced_by: 0 as *const libc::c_char,
67622                deprecated_since: 0 as *const libc::c_char,
67623                group: COMMAND_GROUP_STRING,
67624                history: 0 as *const commandHistory as *mut commandHistory,
67625                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
67626                proc_0: Some(lcsCommand as unsafe extern "C" fn(*mut client) -> ()),
67627                arity: -(3 as libc::c_int),
67628                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
67629                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67630                    as uint64_t,
67631                key_specs_static: [
67632                    {
67633                        let mut init = keySpec {
67634                            notes: 0 as *const libc::c_char,
67635                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67636                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
67637                            begin_search_type: KSPEC_BS_INDEX,
67638                            bs: C2RustUnnamed_3 {
67639                                index: {
67640                                    let mut init = C2RustUnnamed_5 {
67641                                        pos: 1 as libc::c_int,
67642                                    };
67643                                    init
67644                                },
67645                            },
67646                            find_keys_type: KSPEC_FK_RANGE,
67647                            fk: C2RustUnnamed_0 {
67648                                range: {
67649                                    let mut init = C2RustUnnamed_2 {
67650                                        lastkey: 1 as libc::c_int,
67651                                        keystep: 1 as libc::c_int,
67652                                        limit: 0 as libc::c_int,
67653                                    };
67654                                    init
67655                                },
67656                            },
67657                        };
67658                        init
67659                    },
67660                    keySpec {
67661                        notes: 0 as *const libc::c_char,
67662                        flags: 0,
67663                        begin_search_type: KSPEC_BS_INVALID,
67664                        bs: C2RustUnnamed_3 {
67665                            index: C2RustUnnamed_5 { pos: 0 },
67666                        },
67667                        find_keys_type: KSPEC_FK_INVALID,
67668                        fk: C2RustUnnamed_0 {
67669                            range: C2RustUnnamed_2 {
67670                                lastkey: 0,
67671                                keystep: 0,
67672                                limit: 0,
67673                            },
67674                        },
67675                    },
67676                    keySpec {
67677                        notes: 0 as *const libc::c_char,
67678                        flags: 0,
67679                        begin_search_type: KSPEC_BS_INVALID,
67680                        bs: C2RustUnnamed_3 {
67681                            index: C2RustUnnamed_5 { pos: 0 },
67682                        },
67683                        find_keys_type: KSPEC_FK_INVALID,
67684                        fk: C2RustUnnamed_0 {
67685                            range: C2RustUnnamed_2 {
67686                                lastkey: 0,
67687                                keystep: 0,
67688                                limit: 0,
67689                            },
67690                        },
67691                    },
67692                    keySpec {
67693                        notes: 0 as *const libc::c_char,
67694                        flags: 0,
67695                        begin_search_type: KSPEC_BS_INVALID,
67696                        bs: C2RustUnnamed_3 {
67697                            index: C2RustUnnamed_5 { pos: 0 },
67698                        },
67699                        find_keys_type: KSPEC_FK_INVALID,
67700                        fk: C2RustUnnamed_0 {
67701                            range: C2RustUnnamed_2 {
67702                                lastkey: 0,
67703                                keystep: 0,
67704                                limit: 0,
67705                            },
67706                        },
67707                    },
67708                ],
67709                getkeys_proc: None,
67710                subcommands: 0 as *const redisCommand as *mut redisCommand,
67711                args: LCS_Args.as_ptr() as *mut _,
67712                microseconds: 0,
67713                calls: 0,
67714                rejected_calls: 0,
67715                failed_calls: 0,
67716                id: 0,
67717                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67718                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67719                key_specs: 0 as *const keySpec as *mut keySpec,
67720                legacy_range_key_spec: keySpec {
67721                    notes: 0 as *const libc::c_char,
67722                    flags: 0,
67723                    begin_search_type: KSPEC_BS_INVALID,
67724                    bs: C2RustUnnamed_3 {
67725                        index: C2RustUnnamed_5 { pos: 0 },
67726                    },
67727                    find_keys_type: KSPEC_FK_INVALID,
67728                    fk: C2RustUnnamed_0 {
67729                        range: C2RustUnnamed_2 {
67730                            lastkey: 0,
67731                            keystep: 0,
67732                            limit: 0,
67733                        },
67734                    },
67735                },
67736                num_args: 0,
67737                num_history: 0,
67738                num_tips: 0,
67739                key_specs_num: 0,
67740                key_specs_max: 0,
67741                subcommands_dict: 0 as *const dict as *mut dict,
67742                parent: 0 as *const redisCommand as *mut redisCommand,
67743                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67744            };
67745            init
67746        },
67747        {
67748            let mut init = redisCommand {
67749                declared_name: b"mget\0" as *const u8 as *const libc::c_char,
67750                summary: b"Get the values of all the given keys\0" as *const u8
67751                    as *const libc::c_char,
67752                complexity: b"O(N) where N is the number of keys to retrieve.\0"
67753                    as *const u8 as *const libc::c_char,
67754                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
67755                doc_flags: 0 as libc::c_int,
67756                replaced_by: 0 as *const libc::c_char,
67757                deprecated_since: 0 as *const libc::c_char,
67758                group: COMMAND_GROUP_STRING,
67759                history: 0 as *const commandHistory as *mut commandHistory,
67760                tips: MGET_tips.as_ptr() as *mut _,
67761                proc_0: Some(mgetCommand as unsafe extern "C" fn(*mut client) -> ()),
67762                arity: -(2 as libc::c_int),
67763                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
67764                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
67765                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67766                    as uint64_t,
67767                key_specs_static: [
67768                    {
67769                        let mut init = keySpec {
67770                            notes: 0 as *const libc::c_char,
67771                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67772                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
67773                            begin_search_type: KSPEC_BS_INDEX,
67774                            bs: C2RustUnnamed_3 {
67775                                index: {
67776                                    let mut init = C2RustUnnamed_5 {
67777                                        pos: 1 as libc::c_int,
67778                                    };
67779                                    init
67780                                },
67781                            },
67782                            find_keys_type: KSPEC_FK_RANGE,
67783                            fk: C2RustUnnamed_0 {
67784                                range: {
67785                                    let mut init = C2RustUnnamed_2 {
67786                                        lastkey: -(1 as libc::c_int),
67787                                        keystep: 1 as libc::c_int,
67788                                        limit: 0 as libc::c_int,
67789                                    };
67790                                    init
67791                                },
67792                            },
67793                        };
67794                        init
67795                    },
67796                    keySpec {
67797                        notes: 0 as *const libc::c_char,
67798                        flags: 0,
67799                        begin_search_type: KSPEC_BS_INVALID,
67800                        bs: C2RustUnnamed_3 {
67801                            index: C2RustUnnamed_5 { pos: 0 },
67802                        },
67803                        find_keys_type: KSPEC_FK_INVALID,
67804                        fk: C2RustUnnamed_0 {
67805                            range: C2RustUnnamed_2 {
67806                                lastkey: 0,
67807                                keystep: 0,
67808                                limit: 0,
67809                            },
67810                        },
67811                    },
67812                    keySpec {
67813                        notes: 0 as *const libc::c_char,
67814                        flags: 0,
67815                        begin_search_type: KSPEC_BS_INVALID,
67816                        bs: C2RustUnnamed_3 {
67817                            index: C2RustUnnamed_5 { pos: 0 },
67818                        },
67819                        find_keys_type: KSPEC_FK_INVALID,
67820                        fk: C2RustUnnamed_0 {
67821                            range: C2RustUnnamed_2 {
67822                                lastkey: 0,
67823                                keystep: 0,
67824                                limit: 0,
67825                            },
67826                        },
67827                    },
67828                    keySpec {
67829                        notes: 0 as *const libc::c_char,
67830                        flags: 0,
67831                        begin_search_type: KSPEC_BS_INVALID,
67832                        bs: C2RustUnnamed_3 {
67833                            index: C2RustUnnamed_5 { pos: 0 },
67834                        },
67835                        find_keys_type: KSPEC_FK_INVALID,
67836                        fk: C2RustUnnamed_0 {
67837                            range: C2RustUnnamed_2 {
67838                                lastkey: 0,
67839                                keystep: 0,
67840                                limit: 0,
67841                            },
67842                        },
67843                    },
67844                ],
67845                getkeys_proc: None,
67846                subcommands: 0 as *const redisCommand as *mut redisCommand,
67847                args: MGET_Args.as_ptr() as *mut _,
67848                microseconds: 0,
67849                calls: 0,
67850                rejected_calls: 0,
67851                failed_calls: 0,
67852                id: 0,
67853                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67854                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67855                key_specs: 0 as *const keySpec as *mut keySpec,
67856                legacy_range_key_spec: keySpec {
67857                    notes: 0 as *const libc::c_char,
67858                    flags: 0,
67859                    begin_search_type: KSPEC_BS_INVALID,
67860                    bs: C2RustUnnamed_3 {
67861                        index: C2RustUnnamed_5 { pos: 0 },
67862                    },
67863                    find_keys_type: KSPEC_FK_INVALID,
67864                    fk: C2RustUnnamed_0 {
67865                        range: C2RustUnnamed_2 {
67866                            lastkey: 0,
67867                            keystep: 0,
67868                            limit: 0,
67869                        },
67870                    },
67871                },
67872                num_args: 0,
67873                num_history: 0,
67874                num_tips: 0,
67875                key_specs_num: 0,
67876                key_specs_max: 0,
67877                subcommands_dict: 0 as *const dict as *mut dict,
67878                parent: 0 as *const redisCommand as *mut redisCommand,
67879                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
67880            };
67881            init
67882        },
67883        {
67884            let mut init = redisCommand {
67885                declared_name: b"mset\0" as *const u8 as *const libc::c_char,
67886                summary: b"Set multiple keys to multiple values\0" as *const u8
67887                    as *const libc::c_char,
67888                complexity: b"O(N) where N is the number of keys to set.\0" as *const u8
67889                    as *const libc::c_char,
67890                since: b"1.0.1\0" as *const u8 as *const libc::c_char,
67891                doc_flags: 0 as libc::c_int,
67892                replaced_by: 0 as *const libc::c_char,
67893                deprecated_since: 0 as *const libc::c_char,
67894                group: COMMAND_GROUP_STRING,
67895                history: 0 as *const commandHistory as *mut commandHistory,
67896                tips: MSET_tips.as_ptr() as *mut _,
67897                proc_0: Some(msetCommand as unsafe extern "C" fn(*mut client) -> ()),
67898                arity: -(3 as libc::c_int),
67899                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
67900                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
67901                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
67902                    as uint64_t,
67903                key_specs_static: [
67904                    {
67905                        let mut init = keySpec {
67906                            notes: 0 as *const libc::c_char,
67907                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
67908                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
67909                            begin_search_type: KSPEC_BS_INDEX,
67910                            bs: C2RustUnnamed_3 {
67911                                index: {
67912                                    let mut init = C2RustUnnamed_5 {
67913                                        pos: 1 as libc::c_int,
67914                                    };
67915                                    init
67916                                },
67917                            },
67918                            find_keys_type: KSPEC_FK_RANGE,
67919                            fk: C2RustUnnamed_0 {
67920                                range: {
67921                                    let mut init = C2RustUnnamed_2 {
67922                                        lastkey: -(1 as libc::c_int),
67923                                        keystep: 2 as libc::c_int,
67924                                        limit: 0 as libc::c_int,
67925                                    };
67926                                    init
67927                                },
67928                            },
67929                        };
67930                        init
67931                    },
67932                    keySpec {
67933                        notes: 0 as *const libc::c_char,
67934                        flags: 0,
67935                        begin_search_type: KSPEC_BS_INVALID,
67936                        bs: C2RustUnnamed_3 {
67937                            index: C2RustUnnamed_5 { pos: 0 },
67938                        },
67939                        find_keys_type: KSPEC_FK_INVALID,
67940                        fk: C2RustUnnamed_0 {
67941                            range: C2RustUnnamed_2 {
67942                                lastkey: 0,
67943                                keystep: 0,
67944                                limit: 0,
67945                            },
67946                        },
67947                    },
67948                    keySpec {
67949                        notes: 0 as *const libc::c_char,
67950                        flags: 0,
67951                        begin_search_type: KSPEC_BS_INVALID,
67952                        bs: C2RustUnnamed_3 {
67953                            index: C2RustUnnamed_5 { pos: 0 },
67954                        },
67955                        find_keys_type: KSPEC_FK_INVALID,
67956                        fk: C2RustUnnamed_0 {
67957                            range: C2RustUnnamed_2 {
67958                                lastkey: 0,
67959                                keystep: 0,
67960                                limit: 0,
67961                            },
67962                        },
67963                    },
67964                    keySpec {
67965                        notes: 0 as *const libc::c_char,
67966                        flags: 0,
67967                        begin_search_type: KSPEC_BS_INVALID,
67968                        bs: C2RustUnnamed_3 {
67969                            index: C2RustUnnamed_5 { pos: 0 },
67970                        },
67971                        find_keys_type: KSPEC_FK_INVALID,
67972                        fk: C2RustUnnamed_0 {
67973                            range: C2RustUnnamed_2 {
67974                                lastkey: 0,
67975                                keystep: 0,
67976                                limit: 0,
67977                            },
67978                        },
67979                    },
67980                ],
67981                getkeys_proc: None,
67982                subcommands: 0 as *const redisCommand as *mut redisCommand,
67983                args: MSET_Args.as_ptr() as *mut _,
67984                microseconds: 0,
67985                calls: 0,
67986                rejected_calls: 0,
67987                failed_calls: 0,
67988                id: 0,
67989                fullname: 0 as *const libc::c_char as *mut libc::c_char,
67990                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
67991                key_specs: 0 as *const keySpec as *mut keySpec,
67992                legacy_range_key_spec: keySpec {
67993                    notes: 0 as *const libc::c_char,
67994                    flags: 0,
67995                    begin_search_type: KSPEC_BS_INVALID,
67996                    bs: C2RustUnnamed_3 {
67997                        index: C2RustUnnamed_5 { pos: 0 },
67998                    },
67999                    find_keys_type: KSPEC_FK_INVALID,
68000                    fk: C2RustUnnamed_0 {
68001                        range: C2RustUnnamed_2 {
68002                            lastkey: 0,
68003                            keystep: 0,
68004                            limit: 0,
68005                        },
68006                    },
68007                },
68008                num_args: 0,
68009                num_history: 0,
68010                num_tips: 0,
68011                key_specs_num: 0,
68012                key_specs_max: 0,
68013                subcommands_dict: 0 as *const dict as *mut dict,
68014                parent: 0 as *const redisCommand as *mut redisCommand,
68015                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68016            };
68017            init
68018        },
68019        {
68020            let mut init = redisCommand {
68021                declared_name: b"msetnx\0" as *const u8 as *const libc::c_char,
68022                summary: b"Set multiple keys to multiple values, only if none of the keys exist\0"
68023                    as *const u8 as *const libc::c_char,
68024                complexity: b"O(N) where N is the number of keys to set.\0" as *const u8
68025                    as *const libc::c_char,
68026                since: b"1.0.1\0" as *const u8 as *const libc::c_char,
68027                doc_flags: 0 as libc::c_int,
68028                replaced_by: 0 as *const libc::c_char,
68029                deprecated_since: 0 as *const libc::c_char,
68030                group: COMMAND_GROUP_STRING,
68031                history: 0 as *const commandHistory as *mut commandHistory,
68032                tips: MSETNX_tips.as_ptr() as *mut _,
68033                proc_0: Some(msetnxCommand as unsafe extern "C" fn(*mut client) -> ()),
68034                arity: -(3 as libc::c_int),
68035                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68036                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
68037                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68038                    as uint64_t,
68039                key_specs_static: [
68040                    {
68041                        let mut init = keySpec {
68042                            notes: 0 as *const libc::c_char,
68043                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
68044                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
68045                            begin_search_type: KSPEC_BS_INDEX,
68046                            bs: C2RustUnnamed_3 {
68047                                index: {
68048                                    let mut init = C2RustUnnamed_5 {
68049                                        pos: 1 as libc::c_int,
68050                                    };
68051                                    init
68052                                },
68053                            },
68054                            find_keys_type: KSPEC_FK_RANGE,
68055                            fk: C2RustUnnamed_0 {
68056                                range: {
68057                                    let mut init = C2RustUnnamed_2 {
68058                                        lastkey: -(1 as libc::c_int),
68059                                        keystep: 2 as libc::c_int,
68060                                        limit: 0 as libc::c_int,
68061                                    };
68062                                    init
68063                                },
68064                            },
68065                        };
68066                        init
68067                    },
68068                    keySpec {
68069                        notes: 0 as *const libc::c_char,
68070                        flags: 0,
68071                        begin_search_type: KSPEC_BS_INVALID,
68072                        bs: C2RustUnnamed_3 {
68073                            index: C2RustUnnamed_5 { pos: 0 },
68074                        },
68075                        find_keys_type: KSPEC_FK_INVALID,
68076                        fk: C2RustUnnamed_0 {
68077                            range: C2RustUnnamed_2 {
68078                                lastkey: 0,
68079                                keystep: 0,
68080                                limit: 0,
68081                            },
68082                        },
68083                    },
68084                    keySpec {
68085                        notes: 0 as *const libc::c_char,
68086                        flags: 0,
68087                        begin_search_type: KSPEC_BS_INVALID,
68088                        bs: C2RustUnnamed_3 {
68089                            index: C2RustUnnamed_5 { pos: 0 },
68090                        },
68091                        find_keys_type: KSPEC_FK_INVALID,
68092                        fk: C2RustUnnamed_0 {
68093                            range: C2RustUnnamed_2 {
68094                                lastkey: 0,
68095                                keystep: 0,
68096                                limit: 0,
68097                            },
68098                        },
68099                    },
68100                    keySpec {
68101                        notes: 0 as *const libc::c_char,
68102                        flags: 0,
68103                        begin_search_type: KSPEC_BS_INVALID,
68104                        bs: C2RustUnnamed_3 {
68105                            index: C2RustUnnamed_5 { pos: 0 },
68106                        },
68107                        find_keys_type: KSPEC_FK_INVALID,
68108                        fk: C2RustUnnamed_0 {
68109                            range: C2RustUnnamed_2 {
68110                                lastkey: 0,
68111                                keystep: 0,
68112                                limit: 0,
68113                            },
68114                        },
68115                    },
68116                ],
68117                getkeys_proc: None,
68118                subcommands: 0 as *const redisCommand as *mut redisCommand,
68119                args: MSETNX_Args.as_ptr() as *mut _,
68120                microseconds: 0,
68121                calls: 0,
68122                rejected_calls: 0,
68123                failed_calls: 0,
68124                id: 0,
68125                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68126                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68127                key_specs: 0 as *const keySpec as *mut keySpec,
68128                legacy_range_key_spec: keySpec {
68129                    notes: 0 as *const libc::c_char,
68130                    flags: 0,
68131                    begin_search_type: KSPEC_BS_INVALID,
68132                    bs: C2RustUnnamed_3 {
68133                        index: C2RustUnnamed_5 { pos: 0 },
68134                    },
68135                    find_keys_type: KSPEC_FK_INVALID,
68136                    fk: C2RustUnnamed_0 {
68137                        range: C2RustUnnamed_2 {
68138                            lastkey: 0,
68139                            keystep: 0,
68140                            limit: 0,
68141                        },
68142                    },
68143                },
68144                num_args: 0,
68145                num_history: 0,
68146                num_tips: 0,
68147                key_specs_num: 0,
68148                key_specs_max: 0,
68149                subcommands_dict: 0 as *const dict as *mut dict,
68150                parent: 0 as *const redisCommand as *mut redisCommand,
68151                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68152            };
68153            init
68154        },
68155        {
68156            let mut init = redisCommand {
68157                declared_name: b"psetex\0" as *const u8 as *const libc::c_char,
68158                summary: b"Set the value and expiration in milliseconds of a key\0"
68159                    as *const u8 as *const libc::c_char,
68160                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
68161                since: b"2.6.0\0" as *const u8 as *const libc::c_char,
68162                doc_flags: 0 as libc::c_int,
68163                replaced_by: 0 as *const libc::c_char,
68164                deprecated_since: 0 as *const libc::c_char,
68165                group: COMMAND_GROUP_STRING,
68166                history: 0 as *const commandHistory as *mut commandHistory,
68167                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68168                proc_0: Some(psetexCommand as unsafe extern "C" fn(*mut client) -> ()),
68169                arity: 4 as libc::c_int,
68170                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68171                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
68172                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68173                    as uint64_t,
68174                key_specs_static: [
68175                    {
68176                        let mut init = keySpec {
68177                            notes: 0 as *const libc::c_char,
68178                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
68179                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
68180                            begin_search_type: KSPEC_BS_INDEX,
68181                            bs: C2RustUnnamed_3 {
68182                                index: {
68183                                    let mut init = C2RustUnnamed_5 {
68184                                        pos: 1 as libc::c_int,
68185                                    };
68186                                    init
68187                                },
68188                            },
68189                            find_keys_type: KSPEC_FK_RANGE,
68190                            fk: C2RustUnnamed_0 {
68191                                range: {
68192                                    let mut init = C2RustUnnamed_2 {
68193                                        lastkey: 0 as libc::c_int,
68194                                        keystep: 1 as libc::c_int,
68195                                        limit: 0 as libc::c_int,
68196                                    };
68197                                    init
68198                                },
68199                            },
68200                        };
68201                        init
68202                    },
68203                    keySpec {
68204                        notes: 0 as *const libc::c_char,
68205                        flags: 0,
68206                        begin_search_type: KSPEC_BS_INVALID,
68207                        bs: C2RustUnnamed_3 {
68208                            index: C2RustUnnamed_5 { pos: 0 },
68209                        },
68210                        find_keys_type: KSPEC_FK_INVALID,
68211                        fk: C2RustUnnamed_0 {
68212                            range: C2RustUnnamed_2 {
68213                                lastkey: 0,
68214                                keystep: 0,
68215                                limit: 0,
68216                            },
68217                        },
68218                    },
68219                    keySpec {
68220                        notes: 0 as *const libc::c_char,
68221                        flags: 0,
68222                        begin_search_type: KSPEC_BS_INVALID,
68223                        bs: C2RustUnnamed_3 {
68224                            index: C2RustUnnamed_5 { pos: 0 },
68225                        },
68226                        find_keys_type: KSPEC_FK_INVALID,
68227                        fk: C2RustUnnamed_0 {
68228                            range: C2RustUnnamed_2 {
68229                                lastkey: 0,
68230                                keystep: 0,
68231                                limit: 0,
68232                            },
68233                        },
68234                    },
68235                    keySpec {
68236                        notes: 0 as *const libc::c_char,
68237                        flags: 0,
68238                        begin_search_type: KSPEC_BS_INVALID,
68239                        bs: C2RustUnnamed_3 {
68240                            index: C2RustUnnamed_5 { pos: 0 },
68241                        },
68242                        find_keys_type: KSPEC_FK_INVALID,
68243                        fk: C2RustUnnamed_0 {
68244                            range: C2RustUnnamed_2 {
68245                                lastkey: 0,
68246                                keystep: 0,
68247                                limit: 0,
68248                            },
68249                        },
68250                    },
68251                ],
68252                getkeys_proc: None,
68253                subcommands: 0 as *const redisCommand as *mut redisCommand,
68254                args: PSETEX_Args.as_ptr() as *mut _,
68255                microseconds: 0,
68256                calls: 0,
68257                rejected_calls: 0,
68258                failed_calls: 0,
68259                id: 0,
68260                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68261                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68262                key_specs: 0 as *const keySpec as *mut keySpec,
68263                legacy_range_key_spec: keySpec {
68264                    notes: 0 as *const libc::c_char,
68265                    flags: 0,
68266                    begin_search_type: KSPEC_BS_INVALID,
68267                    bs: C2RustUnnamed_3 {
68268                        index: C2RustUnnamed_5 { pos: 0 },
68269                    },
68270                    find_keys_type: KSPEC_FK_INVALID,
68271                    fk: C2RustUnnamed_0 {
68272                        range: C2RustUnnamed_2 {
68273                            lastkey: 0,
68274                            keystep: 0,
68275                            limit: 0,
68276                        },
68277                    },
68278                },
68279                num_args: 0,
68280                num_history: 0,
68281                num_tips: 0,
68282                key_specs_num: 0,
68283                key_specs_max: 0,
68284                subcommands_dict: 0 as *const dict as *mut dict,
68285                parent: 0 as *const redisCommand as *mut redisCommand,
68286                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68287            };
68288            init
68289        },
68290        {
68291            let mut init = redisCommand {
68292                declared_name: b"set\0" as *const u8 as *const libc::c_char,
68293                summary: b"Set the string value of a key\0" as *const u8
68294                    as *const libc::c_char,
68295                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
68296                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
68297                doc_flags: 0 as libc::c_int,
68298                replaced_by: 0 as *const libc::c_char,
68299                deprecated_since: 0 as *const libc::c_char,
68300                group: COMMAND_GROUP_STRING,
68301                history: SET_History.as_ptr() as *mut _,
68302                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68303                proc_0: Some(setCommand as unsafe extern "C" fn(*mut client) -> ()),
68304                arity: -(3 as libc::c_int),
68305                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68306                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
68307                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68308                    as uint64_t,
68309                key_specs_static: [
68310                    {
68311                        let mut init = keySpec {
68312                            notes: b"RW and ACCESS due to the optional `GET` argument\0"
68313                                as *const u8 as *const libc::c_char,
68314                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
68315                                | (1 as libc::c_ulonglong) << 4 as libc::c_int
68316                                | (1 as libc::c_ulonglong) << 5 as libc::c_int
68317                                | (1 as libc::c_ulonglong) << 10 as libc::c_int)
68318                                as uint64_t,
68319                            begin_search_type: KSPEC_BS_INDEX,
68320                            bs: C2RustUnnamed_3 {
68321                                index: {
68322                                    let mut init = C2RustUnnamed_5 {
68323                                        pos: 1 as libc::c_int,
68324                                    };
68325                                    init
68326                                },
68327                            },
68328                            find_keys_type: KSPEC_FK_RANGE,
68329                            fk: C2RustUnnamed_0 {
68330                                range: {
68331                                    let mut init = C2RustUnnamed_2 {
68332                                        lastkey: 0 as libc::c_int,
68333                                        keystep: 1 as libc::c_int,
68334                                        limit: 0 as libc::c_int,
68335                                    };
68336                                    init
68337                                },
68338                            },
68339                        };
68340                        init
68341                    },
68342                    keySpec {
68343                        notes: 0 as *const libc::c_char,
68344                        flags: 0,
68345                        begin_search_type: KSPEC_BS_INVALID,
68346                        bs: C2RustUnnamed_3 {
68347                            index: C2RustUnnamed_5 { pos: 0 },
68348                        },
68349                        find_keys_type: KSPEC_FK_INVALID,
68350                        fk: C2RustUnnamed_0 {
68351                            range: C2RustUnnamed_2 {
68352                                lastkey: 0,
68353                                keystep: 0,
68354                                limit: 0,
68355                            },
68356                        },
68357                    },
68358                    keySpec {
68359                        notes: 0 as *const libc::c_char,
68360                        flags: 0,
68361                        begin_search_type: KSPEC_BS_INVALID,
68362                        bs: C2RustUnnamed_3 {
68363                            index: C2RustUnnamed_5 { pos: 0 },
68364                        },
68365                        find_keys_type: KSPEC_FK_INVALID,
68366                        fk: C2RustUnnamed_0 {
68367                            range: C2RustUnnamed_2 {
68368                                lastkey: 0,
68369                                keystep: 0,
68370                                limit: 0,
68371                            },
68372                        },
68373                    },
68374                    keySpec {
68375                        notes: 0 as *const libc::c_char,
68376                        flags: 0,
68377                        begin_search_type: KSPEC_BS_INVALID,
68378                        bs: C2RustUnnamed_3 {
68379                            index: C2RustUnnamed_5 { pos: 0 },
68380                        },
68381                        find_keys_type: KSPEC_FK_INVALID,
68382                        fk: C2RustUnnamed_0 {
68383                            range: C2RustUnnamed_2 {
68384                                lastkey: 0,
68385                                keystep: 0,
68386                                limit: 0,
68387                            },
68388                        },
68389                    },
68390                ],
68391                getkeys_proc: Some(
68392                    setGetKeys
68393                        as unsafe extern "C" fn(
68394                            *mut redisCommand,
68395                            *mut *mut robj,
68396                            libc::c_int,
68397                            *mut getKeysResult,
68398                        ) -> libc::c_int,
68399                ),
68400                subcommands: 0 as *const redisCommand as *mut redisCommand,
68401                args: SET_Args.as_ptr() as *mut _,
68402                microseconds: 0,
68403                calls: 0,
68404                rejected_calls: 0,
68405                failed_calls: 0,
68406                id: 0,
68407                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68408                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68409                key_specs: 0 as *const keySpec as *mut keySpec,
68410                legacy_range_key_spec: keySpec {
68411                    notes: 0 as *const libc::c_char,
68412                    flags: 0,
68413                    begin_search_type: KSPEC_BS_INVALID,
68414                    bs: C2RustUnnamed_3 {
68415                        index: C2RustUnnamed_5 { pos: 0 },
68416                    },
68417                    find_keys_type: KSPEC_FK_INVALID,
68418                    fk: C2RustUnnamed_0 {
68419                        range: C2RustUnnamed_2 {
68420                            lastkey: 0,
68421                            keystep: 0,
68422                            limit: 0,
68423                        },
68424                    },
68425                },
68426                num_args: 0,
68427                num_history: 0,
68428                num_tips: 0,
68429                key_specs_num: 0,
68430                key_specs_max: 0,
68431                subcommands_dict: 0 as *const dict as *mut dict,
68432                parent: 0 as *const redisCommand as *mut redisCommand,
68433                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68434            };
68435            init
68436        },
68437        {
68438            let mut init = redisCommand {
68439                declared_name: b"setex\0" as *const u8 as *const libc::c_char,
68440                summary: b"Set the value and expiration of a key\0" as *const u8
68441                    as *const libc::c_char,
68442                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
68443                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
68444                doc_flags: 0 as libc::c_int,
68445                replaced_by: 0 as *const libc::c_char,
68446                deprecated_since: 0 as *const libc::c_char,
68447                group: COMMAND_GROUP_STRING,
68448                history: 0 as *const commandHistory as *mut commandHistory,
68449                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68450                proc_0: Some(setexCommand as unsafe extern "C" fn(*mut client) -> ()),
68451                arity: 4 as libc::c_int,
68452                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68453                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
68454                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68455                    as uint64_t,
68456                key_specs_static: [
68457                    {
68458                        let mut init = keySpec {
68459                            notes: 0 as *const libc::c_char,
68460                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
68461                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
68462                            begin_search_type: KSPEC_BS_INDEX,
68463                            bs: C2RustUnnamed_3 {
68464                                index: {
68465                                    let mut init = C2RustUnnamed_5 {
68466                                        pos: 1 as libc::c_int,
68467                                    };
68468                                    init
68469                                },
68470                            },
68471                            find_keys_type: KSPEC_FK_RANGE,
68472                            fk: C2RustUnnamed_0 {
68473                                range: {
68474                                    let mut init = C2RustUnnamed_2 {
68475                                        lastkey: 0 as libc::c_int,
68476                                        keystep: 1 as libc::c_int,
68477                                        limit: 0 as libc::c_int,
68478                                    };
68479                                    init
68480                                },
68481                            },
68482                        };
68483                        init
68484                    },
68485                    keySpec {
68486                        notes: 0 as *const libc::c_char,
68487                        flags: 0,
68488                        begin_search_type: KSPEC_BS_INVALID,
68489                        bs: C2RustUnnamed_3 {
68490                            index: C2RustUnnamed_5 { pos: 0 },
68491                        },
68492                        find_keys_type: KSPEC_FK_INVALID,
68493                        fk: C2RustUnnamed_0 {
68494                            range: C2RustUnnamed_2 {
68495                                lastkey: 0,
68496                                keystep: 0,
68497                                limit: 0,
68498                            },
68499                        },
68500                    },
68501                    keySpec {
68502                        notes: 0 as *const libc::c_char,
68503                        flags: 0,
68504                        begin_search_type: KSPEC_BS_INVALID,
68505                        bs: C2RustUnnamed_3 {
68506                            index: C2RustUnnamed_5 { pos: 0 },
68507                        },
68508                        find_keys_type: KSPEC_FK_INVALID,
68509                        fk: C2RustUnnamed_0 {
68510                            range: C2RustUnnamed_2 {
68511                                lastkey: 0,
68512                                keystep: 0,
68513                                limit: 0,
68514                            },
68515                        },
68516                    },
68517                    keySpec {
68518                        notes: 0 as *const libc::c_char,
68519                        flags: 0,
68520                        begin_search_type: KSPEC_BS_INVALID,
68521                        bs: C2RustUnnamed_3 {
68522                            index: C2RustUnnamed_5 { pos: 0 },
68523                        },
68524                        find_keys_type: KSPEC_FK_INVALID,
68525                        fk: C2RustUnnamed_0 {
68526                            range: C2RustUnnamed_2 {
68527                                lastkey: 0,
68528                                keystep: 0,
68529                                limit: 0,
68530                            },
68531                        },
68532                    },
68533                ],
68534                getkeys_proc: None,
68535                subcommands: 0 as *const redisCommand as *mut redisCommand,
68536                args: SETEX_Args.as_ptr() as *mut _,
68537                microseconds: 0,
68538                calls: 0,
68539                rejected_calls: 0,
68540                failed_calls: 0,
68541                id: 0,
68542                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68543                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68544                key_specs: 0 as *const keySpec as *mut keySpec,
68545                legacy_range_key_spec: keySpec {
68546                    notes: 0 as *const libc::c_char,
68547                    flags: 0,
68548                    begin_search_type: KSPEC_BS_INVALID,
68549                    bs: C2RustUnnamed_3 {
68550                        index: C2RustUnnamed_5 { pos: 0 },
68551                    },
68552                    find_keys_type: KSPEC_FK_INVALID,
68553                    fk: C2RustUnnamed_0 {
68554                        range: C2RustUnnamed_2 {
68555                            lastkey: 0,
68556                            keystep: 0,
68557                            limit: 0,
68558                        },
68559                    },
68560                },
68561                num_args: 0,
68562                num_history: 0,
68563                num_tips: 0,
68564                key_specs_num: 0,
68565                key_specs_max: 0,
68566                subcommands_dict: 0 as *const dict as *mut dict,
68567                parent: 0 as *const redisCommand as *mut redisCommand,
68568                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68569            };
68570            init
68571        },
68572        {
68573            let mut init = redisCommand {
68574                declared_name: b"setnx\0" as *const u8 as *const libc::c_char,
68575                summary: b"Set the value of a key, only if the key does not exist\0"
68576                    as *const u8 as *const libc::c_char,
68577                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
68578                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
68579                doc_flags: 0 as libc::c_int,
68580                replaced_by: 0 as *const libc::c_char,
68581                deprecated_since: 0 as *const libc::c_char,
68582                group: COMMAND_GROUP_STRING,
68583                history: 0 as *const commandHistory as *mut commandHistory,
68584                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68585                proc_0: Some(setnxCommand as unsafe extern "C" fn(*mut client) -> ()),
68586                arity: 3 as libc::c_int,
68587                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68588                    | (1 as libc::c_ulonglong) << 2 as libc::c_int
68589                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
68590                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68591                    as uint64_t,
68592                key_specs_static: [
68593                    {
68594                        let mut init = keySpec {
68595                            notes: 0 as *const libc::c_char,
68596                            flags: ((1 as libc::c_ulonglong) << 2 as libc::c_int
68597                                | (1 as libc::c_ulonglong) << 6 as libc::c_int) as uint64_t,
68598                            begin_search_type: KSPEC_BS_INDEX,
68599                            bs: C2RustUnnamed_3 {
68600                                index: {
68601                                    let mut init = C2RustUnnamed_5 {
68602                                        pos: 1 as libc::c_int,
68603                                    };
68604                                    init
68605                                },
68606                            },
68607                            find_keys_type: KSPEC_FK_RANGE,
68608                            fk: C2RustUnnamed_0 {
68609                                range: {
68610                                    let mut init = C2RustUnnamed_2 {
68611                                        lastkey: 0 as libc::c_int,
68612                                        keystep: 1 as libc::c_int,
68613                                        limit: 0 as libc::c_int,
68614                                    };
68615                                    init
68616                                },
68617                            },
68618                        };
68619                        init
68620                    },
68621                    keySpec {
68622                        notes: 0 as *const libc::c_char,
68623                        flags: 0,
68624                        begin_search_type: KSPEC_BS_INVALID,
68625                        bs: C2RustUnnamed_3 {
68626                            index: C2RustUnnamed_5 { pos: 0 },
68627                        },
68628                        find_keys_type: KSPEC_FK_INVALID,
68629                        fk: C2RustUnnamed_0 {
68630                            range: C2RustUnnamed_2 {
68631                                lastkey: 0,
68632                                keystep: 0,
68633                                limit: 0,
68634                            },
68635                        },
68636                    },
68637                    keySpec {
68638                        notes: 0 as *const libc::c_char,
68639                        flags: 0,
68640                        begin_search_type: KSPEC_BS_INVALID,
68641                        bs: C2RustUnnamed_3 {
68642                            index: C2RustUnnamed_5 { pos: 0 },
68643                        },
68644                        find_keys_type: KSPEC_FK_INVALID,
68645                        fk: C2RustUnnamed_0 {
68646                            range: C2RustUnnamed_2 {
68647                                lastkey: 0,
68648                                keystep: 0,
68649                                limit: 0,
68650                            },
68651                        },
68652                    },
68653                    keySpec {
68654                        notes: 0 as *const libc::c_char,
68655                        flags: 0,
68656                        begin_search_type: KSPEC_BS_INVALID,
68657                        bs: C2RustUnnamed_3 {
68658                            index: C2RustUnnamed_5 { pos: 0 },
68659                        },
68660                        find_keys_type: KSPEC_FK_INVALID,
68661                        fk: C2RustUnnamed_0 {
68662                            range: C2RustUnnamed_2 {
68663                                lastkey: 0,
68664                                keystep: 0,
68665                                limit: 0,
68666                            },
68667                        },
68668                    },
68669                ],
68670                getkeys_proc: None,
68671                subcommands: 0 as *const redisCommand as *mut redisCommand,
68672                args: SETNX_Args.as_ptr() as *mut _,
68673                microseconds: 0,
68674                calls: 0,
68675                rejected_calls: 0,
68676                failed_calls: 0,
68677                id: 0,
68678                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68679                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68680                key_specs: 0 as *const keySpec as *mut keySpec,
68681                legacy_range_key_spec: keySpec {
68682                    notes: 0 as *const libc::c_char,
68683                    flags: 0,
68684                    begin_search_type: KSPEC_BS_INVALID,
68685                    bs: C2RustUnnamed_3 {
68686                        index: C2RustUnnamed_5 { pos: 0 },
68687                    },
68688                    find_keys_type: KSPEC_FK_INVALID,
68689                    fk: C2RustUnnamed_0 {
68690                        range: C2RustUnnamed_2 {
68691                            lastkey: 0,
68692                            keystep: 0,
68693                            limit: 0,
68694                        },
68695                    },
68696                },
68697                num_args: 0,
68698                num_history: 0,
68699                num_tips: 0,
68700                key_specs_num: 0,
68701                key_specs_max: 0,
68702                subcommands_dict: 0 as *const dict as *mut dict,
68703                parent: 0 as *const redisCommand as *mut redisCommand,
68704                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68705            };
68706            init
68707        },
68708        {
68709            let mut init = redisCommand {
68710                declared_name: b"setrange\0" as *const u8 as *const libc::c_char,
68711                summary: b"Overwrite part of a string at key starting at the specified offset\0"
68712                    as *const u8 as *const libc::c_char,
68713                complexity: b"O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.\0"
68714                    as *const u8 as *const libc::c_char,
68715                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
68716                doc_flags: 0 as libc::c_int,
68717                replaced_by: 0 as *const libc::c_char,
68718                deprecated_since: 0 as *const libc::c_char,
68719                group: COMMAND_GROUP_STRING,
68720                history: 0 as *const commandHistory as *mut commandHistory,
68721                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68722                proc_0: Some(setrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
68723                arity: 4 as libc::c_int,
68724                flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
68725                    | (1 as libc::c_ulonglong) << 2 as libc::c_int) as uint64_t,
68726                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68727                    as uint64_t,
68728                key_specs_static: [
68729                    {
68730                        let mut init = keySpec {
68731                            notes: 0 as *const libc::c_char,
68732                            flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
68733                                | (1 as libc::c_ulonglong) << 5 as libc::c_int) as uint64_t,
68734                            begin_search_type: KSPEC_BS_INDEX,
68735                            bs: C2RustUnnamed_3 {
68736                                index: {
68737                                    let mut init = C2RustUnnamed_5 {
68738                                        pos: 1 as libc::c_int,
68739                                    };
68740                                    init
68741                                },
68742                            },
68743                            find_keys_type: KSPEC_FK_RANGE,
68744                            fk: C2RustUnnamed_0 {
68745                                range: {
68746                                    let mut init = C2RustUnnamed_2 {
68747                                        lastkey: 0 as libc::c_int,
68748                                        keystep: 1 as libc::c_int,
68749                                        limit: 0 as libc::c_int,
68750                                    };
68751                                    init
68752                                },
68753                            },
68754                        };
68755                        init
68756                    },
68757                    keySpec {
68758                        notes: 0 as *const libc::c_char,
68759                        flags: 0,
68760                        begin_search_type: KSPEC_BS_INVALID,
68761                        bs: C2RustUnnamed_3 {
68762                            index: C2RustUnnamed_5 { pos: 0 },
68763                        },
68764                        find_keys_type: KSPEC_FK_INVALID,
68765                        fk: C2RustUnnamed_0 {
68766                            range: C2RustUnnamed_2 {
68767                                lastkey: 0,
68768                                keystep: 0,
68769                                limit: 0,
68770                            },
68771                        },
68772                    },
68773                    keySpec {
68774                        notes: 0 as *const libc::c_char,
68775                        flags: 0,
68776                        begin_search_type: KSPEC_BS_INVALID,
68777                        bs: C2RustUnnamed_3 {
68778                            index: C2RustUnnamed_5 { pos: 0 },
68779                        },
68780                        find_keys_type: KSPEC_FK_INVALID,
68781                        fk: C2RustUnnamed_0 {
68782                            range: C2RustUnnamed_2 {
68783                                lastkey: 0,
68784                                keystep: 0,
68785                                limit: 0,
68786                            },
68787                        },
68788                    },
68789                    keySpec {
68790                        notes: 0 as *const libc::c_char,
68791                        flags: 0,
68792                        begin_search_type: KSPEC_BS_INVALID,
68793                        bs: C2RustUnnamed_3 {
68794                            index: C2RustUnnamed_5 { pos: 0 },
68795                        },
68796                        find_keys_type: KSPEC_FK_INVALID,
68797                        fk: C2RustUnnamed_0 {
68798                            range: C2RustUnnamed_2 {
68799                                lastkey: 0,
68800                                keystep: 0,
68801                                limit: 0,
68802                            },
68803                        },
68804                    },
68805                ],
68806                getkeys_proc: None,
68807                subcommands: 0 as *const redisCommand as *mut redisCommand,
68808                args: SETRANGE_Args.as_ptr() as *mut _,
68809                microseconds: 0,
68810                calls: 0,
68811                rejected_calls: 0,
68812                failed_calls: 0,
68813                id: 0,
68814                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68815                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68816                key_specs: 0 as *const keySpec as *mut keySpec,
68817                legacy_range_key_spec: keySpec {
68818                    notes: 0 as *const libc::c_char,
68819                    flags: 0,
68820                    begin_search_type: KSPEC_BS_INVALID,
68821                    bs: C2RustUnnamed_3 {
68822                        index: C2RustUnnamed_5 { pos: 0 },
68823                    },
68824                    find_keys_type: KSPEC_FK_INVALID,
68825                    fk: C2RustUnnamed_0 {
68826                        range: C2RustUnnamed_2 {
68827                            lastkey: 0,
68828                            keystep: 0,
68829                            limit: 0,
68830                        },
68831                    },
68832                },
68833                num_args: 0,
68834                num_history: 0,
68835                num_tips: 0,
68836                key_specs_num: 0,
68837                key_specs_max: 0,
68838                subcommands_dict: 0 as *const dict as *mut dict,
68839                parent: 0 as *const redisCommand as *mut redisCommand,
68840                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68841            };
68842            init
68843        },
68844        {
68845            let mut init = redisCommand {
68846                declared_name: b"strlen\0" as *const u8 as *const libc::c_char,
68847                summary: b"Get the length of the value stored in a key\0" as *const u8
68848                    as *const libc::c_char,
68849                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
68850                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
68851                doc_flags: 0 as libc::c_int,
68852                replaced_by: 0 as *const libc::c_char,
68853                deprecated_since: 0 as *const libc::c_char,
68854                group: COMMAND_GROUP_STRING,
68855                history: 0 as *const commandHistory as *mut commandHistory,
68856                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68857                proc_0: Some(strlenCommand as unsafe extern "C" fn(*mut client) -> ()),
68858                arity: 2 as libc::c_int,
68859                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int
68860                    | (1 as libc::c_ulonglong) << 14 as libc::c_int) as uint64_t,
68861                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68862                    as uint64_t,
68863                key_specs_static: [
68864                    {
68865                        let mut init = keySpec {
68866                            notes: 0 as *const libc::c_char,
68867                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
68868                                as uint64_t,
68869                            begin_search_type: KSPEC_BS_INDEX,
68870                            bs: C2RustUnnamed_3 {
68871                                index: {
68872                                    let mut init = C2RustUnnamed_5 {
68873                                        pos: 1 as libc::c_int,
68874                                    };
68875                                    init
68876                                },
68877                            },
68878                            find_keys_type: KSPEC_FK_RANGE,
68879                            fk: C2RustUnnamed_0 {
68880                                range: {
68881                                    let mut init = C2RustUnnamed_2 {
68882                                        lastkey: 0 as libc::c_int,
68883                                        keystep: 1 as libc::c_int,
68884                                        limit: 0 as libc::c_int,
68885                                    };
68886                                    init
68887                                },
68888                            },
68889                        };
68890                        init
68891                    },
68892                    keySpec {
68893                        notes: 0 as *const libc::c_char,
68894                        flags: 0,
68895                        begin_search_type: KSPEC_BS_INVALID,
68896                        bs: C2RustUnnamed_3 {
68897                            index: C2RustUnnamed_5 { pos: 0 },
68898                        },
68899                        find_keys_type: KSPEC_FK_INVALID,
68900                        fk: C2RustUnnamed_0 {
68901                            range: C2RustUnnamed_2 {
68902                                lastkey: 0,
68903                                keystep: 0,
68904                                limit: 0,
68905                            },
68906                        },
68907                    },
68908                    keySpec {
68909                        notes: 0 as *const libc::c_char,
68910                        flags: 0,
68911                        begin_search_type: KSPEC_BS_INVALID,
68912                        bs: C2RustUnnamed_3 {
68913                            index: C2RustUnnamed_5 { pos: 0 },
68914                        },
68915                        find_keys_type: KSPEC_FK_INVALID,
68916                        fk: C2RustUnnamed_0 {
68917                            range: C2RustUnnamed_2 {
68918                                lastkey: 0,
68919                                keystep: 0,
68920                                limit: 0,
68921                            },
68922                        },
68923                    },
68924                    keySpec {
68925                        notes: 0 as *const libc::c_char,
68926                        flags: 0,
68927                        begin_search_type: KSPEC_BS_INVALID,
68928                        bs: C2RustUnnamed_3 {
68929                            index: C2RustUnnamed_5 { pos: 0 },
68930                        },
68931                        find_keys_type: KSPEC_FK_INVALID,
68932                        fk: C2RustUnnamed_0 {
68933                            range: C2RustUnnamed_2 {
68934                                lastkey: 0,
68935                                keystep: 0,
68936                                limit: 0,
68937                            },
68938                        },
68939                    },
68940                ],
68941                getkeys_proc: None,
68942                subcommands: 0 as *const redisCommand as *mut redisCommand,
68943                args: STRLEN_Args.as_ptr() as *mut _,
68944                microseconds: 0,
68945                calls: 0,
68946                rejected_calls: 0,
68947                failed_calls: 0,
68948                id: 0,
68949                fullname: 0 as *const libc::c_char as *mut libc::c_char,
68950                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
68951                key_specs: 0 as *const keySpec as *mut keySpec,
68952                legacy_range_key_spec: keySpec {
68953                    notes: 0 as *const libc::c_char,
68954                    flags: 0,
68955                    begin_search_type: KSPEC_BS_INVALID,
68956                    bs: C2RustUnnamed_3 {
68957                        index: C2RustUnnamed_5 { pos: 0 },
68958                    },
68959                    find_keys_type: KSPEC_FK_INVALID,
68960                    fk: C2RustUnnamed_0 {
68961                        range: C2RustUnnamed_2 {
68962                            lastkey: 0,
68963                            keystep: 0,
68964                            limit: 0,
68965                        },
68966                    },
68967                },
68968                num_args: 0,
68969                num_history: 0,
68970                num_tips: 0,
68971                key_specs_num: 0,
68972                key_specs_max: 0,
68973                subcommands_dict: 0 as *const dict as *mut dict,
68974                parent: 0 as *const redisCommand as *mut redisCommand,
68975                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
68976            };
68977            init
68978        },
68979        {
68980            let mut init = redisCommand {
68981                declared_name: b"substr\0" as *const u8 as *const libc::c_char,
68982                summary: b"Get a substring of the string stored at a key\0" as *const u8
68983                    as *const libc::c_char,
68984                complexity: b"O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.\0"
68985                    as *const u8 as *const libc::c_char,
68986                since: b"1.0.0\0" as *const u8 as *const libc::c_char,
68987                doc_flags: (1 as libc::c_int) << 0 as libc::c_int,
68988                replaced_by: b"`GETRANGE`\0" as *const u8 as *const libc::c_char,
68989                deprecated_since: b"2.0.0\0" as *const u8 as *const libc::c_char,
68990                group: COMMAND_GROUP_STRING,
68991                history: 0 as *const commandHistory as *mut commandHistory,
68992                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
68993                proc_0: Some(getrangeCommand as unsafe extern "C" fn(*mut client) -> ()),
68994                arity: 4 as libc::c_int,
68995                flags: ((1 as libc::c_ulonglong) << 1 as libc::c_int) as uint64_t,
68996                acl_categories: ((1 as libc::c_ulonglong) << 7 as libc::c_int)
68997                    as uint64_t,
68998                key_specs_static: [
68999                    {
69000                        let mut init = keySpec {
69001                            notes: 0 as *const libc::c_char,
69002                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int
69003                                | (1 as libc::c_ulonglong) << 4 as libc::c_int) as uint64_t,
69004                            begin_search_type: KSPEC_BS_INDEX,
69005                            bs: C2RustUnnamed_3 {
69006                                index: {
69007                                    let mut init = C2RustUnnamed_5 {
69008                                        pos: 1 as libc::c_int,
69009                                    };
69010                                    init
69011                                },
69012                            },
69013                            find_keys_type: KSPEC_FK_RANGE,
69014                            fk: C2RustUnnamed_0 {
69015                                range: {
69016                                    let mut init = C2RustUnnamed_2 {
69017                                        lastkey: 0 as libc::c_int,
69018                                        keystep: 1 as libc::c_int,
69019                                        limit: 0 as libc::c_int,
69020                                    };
69021                                    init
69022                                },
69023                            },
69024                        };
69025                        init
69026                    },
69027                    keySpec {
69028                        notes: 0 as *const libc::c_char,
69029                        flags: 0,
69030                        begin_search_type: KSPEC_BS_INVALID,
69031                        bs: C2RustUnnamed_3 {
69032                            index: C2RustUnnamed_5 { pos: 0 },
69033                        },
69034                        find_keys_type: KSPEC_FK_INVALID,
69035                        fk: C2RustUnnamed_0 {
69036                            range: C2RustUnnamed_2 {
69037                                lastkey: 0,
69038                                keystep: 0,
69039                                limit: 0,
69040                            },
69041                        },
69042                    },
69043                    keySpec {
69044                        notes: 0 as *const libc::c_char,
69045                        flags: 0,
69046                        begin_search_type: KSPEC_BS_INVALID,
69047                        bs: C2RustUnnamed_3 {
69048                            index: C2RustUnnamed_5 { pos: 0 },
69049                        },
69050                        find_keys_type: KSPEC_FK_INVALID,
69051                        fk: C2RustUnnamed_0 {
69052                            range: C2RustUnnamed_2 {
69053                                lastkey: 0,
69054                                keystep: 0,
69055                                limit: 0,
69056                            },
69057                        },
69058                    },
69059                    keySpec {
69060                        notes: 0 as *const libc::c_char,
69061                        flags: 0,
69062                        begin_search_type: KSPEC_BS_INVALID,
69063                        bs: C2RustUnnamed_3 {
69064                            index: C2RustUnnamed_5 { pos: 0 },
69065                        },
69066                        find_keys_type: KSPEC_FK_INVALID,
69067                        fk: C2RustUnnamed_0 {
69068                            range: C2RustUnnamed_2 {
69069                                lastkey: 0,
69070                                keystep: 0,
69071                                limit: 0,
69072                            },
69073                        },
69074                    },
69075                ],
69076                getkeys_proc: None,
69077                subcommands: 0 as *const redisCommand as *mut redisCommand,
69078                args: SUBSTR_Args.as_ptr() as *mut _,
69079                microseconds: 0,
69080                calls: 0,
69081                rejected_calls: 0,
69082                failed_calls: 0,
69083                id: 0,
69084                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69085                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69086                key_specs: 0 as *const keySpec as *mut keySpec,
69087                legacy_range_key_spec: keySpec {
69088                    notes: 0 as *const libc::c_char,
69089                    flags: 0,
69090                    begin_search_type: KSPEC_BS_INVALID,
69091                    bs: C2RustUnnamed_3 {
69092                        index: C2RustUnnamed_5 { pos: 0 },
69093                    },
69094                    find_keys_type: KSPEC_FK_INVALID,
69095                    fk: C2RustUnnamed_0 {
69096                        range: C2RustUnnamed_2 {
69097                            lastkey: 0,
69098                            keystep: 0,
69099                            limit: 0,
69100                        },
69101                    },
69102                },
69103                num_args: 0,
69104                num_history: 0,
69105                num_tips: 0,
69106                key_specs_num: 0,
69107                key_specs_max: 0,
69108                subcommands_dict: 0 as *const dict as *mut dict,
69109                parent: 0 as *const redisCommand as *mut redisCommand,
69110                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69111            };
69112            init
69113        },
69114        {
69115            let mut init = redisCommand {
69116                declared_name: b"discard\0" as *const u8 as *const libc::c_char,
69117                summary: b"Discard all commands issued after MULTI\0" as *const u8
69118                    as *const libc::c_char,
69119                complexity: b"O(N), when N is the number of queued commands\0"
69120                    as *const u8 as *const libc::c_char,
69121                since: b"2.0.0\0" as *const u8 as *const libc::c_char,
69122                doc_flags: 0 as libc::c_int,
69123                replaced_by: 0 as *const libc::c_char,
69124                deprecated_since: 0 as *const libc::c_char,
69125                group: COMMAND_GROUP_TRANSACTIONS,
69126                history: 0 as *const commandHistory as *mut commandHistory,
69127                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69128                proc_0: Some(discardCommand as unsafe extern "C" fn(*mut client) -> ()),
69129                arity: 1 as libc::c_int,
69130                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
69131                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
69132                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
69133                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
69134                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
69135                acl_categories: ((1 as libc::c_ulonglong) << 19 as libc::c_int)
69136                    as uint64_t,
69137                key_specs_static: [keySpec {
69138                    notes: 0 as *const libc::c_char,
69139                    flags: 0,
69140                    begin_search_type: KSPEC_BS_INVALID,
69141                    bs: C2RustUnnamed_3 {
69142                        index: C2RustUnnamed_5 { pos: 0 },
69143                    },
69144                    find_keys_type: KSPEC_FK_INVALID,
69145                    fk: C2RustUnnamed_0 {
69146                        range: C2RustUnnamed_2 {
69147                            lastkey: 0,
69148                            keystep: 0,
69149                            limit: 0,
69150                        },
69151                    },
69152                }; 4],
69153                getkeys_proc: None,
69154                subcommands: 0 as *const redisCommand as *mut redisCommand,
69155                args: 0 as *const redisCommandArg as *mut redisCommandArg,
69156                microseconds: 0,
69157                calls: 0,
69158                rejected_calls: 0,
69159                failed_calls: 0,
69160                id: 0,
69161                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69162                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69163                key_specs: 0 as *const keySpec as *mut keySpec,
69164                legacy_range_key_spec: keySpec {
69165                    notes: 0 as *const libc::c_char,
69166                    flags: 0,
69167                    begin_search_type: KSPEC_BS_INVALID,
69168                    bs: C2RustUnnamed_3 {
69169                        index: C2RustUnnamed_5 { pos: 0 },
69170                    },
69171                    find_keys_type: KSPEC_FK_INVALID,
69172                    fk: C2RustUnnamed_0 {
69173                        range: C2RustUnnamed_2 {
69174                            lastkey: 0,
69175                            keystep: 0,
69176                            limit: 0,
69177                        },
69178                    },
69179                },
69180                num_args: 0,
69181                num_history: 0,
69182                num_tips: 0,
69183                key_specs_num: 0,
69184                key_specs_max: 0,
69185                subcommands_dict: 0 as *const dict as *mut dict,
69186                parent: 0 as *const redisCommand as *mut redisCommand,
69187                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69188            };
69189            init
69190        },
69191        {
69192            let mut init = redisCommand {
69193                declared_name: b"exec\0" as *const u8 as *const libc::c_char,
69194                summary: b"Execute all commands issued after MULTI\0" as *const u8
69195                    as *const libc::c_char,
69196                complexity: b"Depends on commands in the transaction\0" as *const u8
69197                    as *const libc::c_char,
69198                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
69199                doc_flags: 0 as libc::c_int,
69200                replaced_by: 0 as *const libc::c_char,
69201                deprecated_since: 0 as *const libc::c_char,
69202                group: COMMAND_GROUP_TRANSACTIONS,
69203                history: 0 as *const commandHistory as *mut commandHistory,
69204                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69205                proc_0: Some(execCommand as unsafe extern "C" fn(*mut client) -> ()),
69206                arity: 1 as libc::c_int,
69207                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
69208                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
69209                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
69210                    | (1 as libc::c_ulonglong) << 12 as libc::c_int) as uint64_t,
69211                acl_categories: ((1 as libc::c_ulonglong) << 19 as libc::c_int)
69212                    as uint64_t,
69213                key_specs_static: [keySpec {
69214                    notes: 0 as *const libc::c_char,
69215                    flags: 0,
69216                    begin_search_type: KSPEC_BS_INVALID,
69217                    bs: C2RustUnnamed_3 {
69218                        index: C2RustUnnamed_5 { pos: 0 },
69219                    },
69220                    find_keys_type: KSPEC_FK_INVALID,
69221                    fk: C2RustUnnamed_0 {
69222                        range: C2RustUnnamed_2 {
69223                            lastkey: 0,
69224                            keystep: 0,
69225                            limit: 0,
69226                        },
69227                    },
69228                }; 4],
69229                getkeys_proc: None,
69230                subcommands: 0 as *const redisCommand as *mut redisCommand,
69231                args: 0 as *const redisCommandArg as *mut redisCommandArg,
69232                microseconds: 0,
69233                calls: 0,
69234                rejected_calls: 0,
69235                failed_calls: 0,
69236                id: 0,
69237                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69238                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69239                key_specs: 0 as *const keySpec as *mut keySpec,
69240                legacy_range_key_spec: keySpec {
69241                    notes: 0 as *const libc::c_char,
69242                    flags: 0,
69243                    begin_search_type: KSPEC_BS_INVALID,
69244                    bs: C2RustUnnamed_3 {
69245                        index: C2RustUnnamed_5 { pos: 0 },
69246                    },
69247                    find_keys_type: KSPEC_FK_INVALID,
69248                    fk: C2RustUnnamed_0 {
69249                        range: C2RustUnnamed_2 {
69250                            lastkey: 0,
69251                            keystep: 0,
69252                            limit: 0,
69253                        },
69254                    },
69255                },
69256                num_args: 0,
69257                num_history: 0,
69258                num_tips: 0,
69259                key_specs_num: 0,
69260                key_specs_max: 0,
69261                subcommands_dict: 0 as *const dict as *mut dict,
69262                parent: 0 as *const redisCommand as *mut redisCommand,
69263                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69264            };
69265            init
69266        },
69267        {
69268            let mut init = redisCommand {
69269                declared_name: b"multi\0" as *const u8 as *const libc::c_char,
69270                summary: b"Mark the start of a transaction block\0" as *const u8
69271                    as *const libc::c_char,
69272                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
69273                since: b"1.2.0\0" as *const u8 as *const libc::c_char,
69274                doc_flags: 0 as libc::c_int,
69275                replaced_by: 0 as *const libc::c_char,
69276                deprecated_since: 0 as *const libc::c_char,
69277                group: COMMAND_GROUP_TRANSACTIONS,
69278                history: 0 as *const commandHistory as *mut commandHistory,
69279                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69280                proc_0: Some(multiCommand as unsafe extern "C" fn(*mut client) -> ()),
69281                arity: 1 as libc::c_int,
69282                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
69283                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
69284                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
69285                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
69286                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
69287                acl_categories: ((1 as libc::c_ulonglong) << 19 as libc::c_int)
69288                    as uint64_t,
69289                key_specs_static: [keySpec {
69290                    notes: 0 as *const libc::c_char,
69291                    flags: 0,
69292                    begin_search_type: KSPEC_BS_INVALID,
69293                    bs: C2RustUnnamed_3 {
69294                        index: C2RustUnnamed_5 { pos: 0 },
69295                    },
69296                    find_keys_type: KSPEC_FK_INVALID,
69297                    fk: C2RustUnnamed_0 {
69298                        range: C2RustUnnamed_2 {
69299                            lastkey: 0,
69300                            keystep: 0,
69301                            limit: 0,
69302                        },
69303                    },
69304                }; 4],
69305                getkeys_proc: None,
69306                subcommands: 0 as *const redisCommand as *mut redisCommand,
69307                args: 0 as *const redisCommandArg as *mut redisCommandArg,
69308                microseconds: 0,
69309                calls: 0,
69310                rejected_calls: 0,
69311                failed_calls: 0,
69312                id: 0,
69313                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69314                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69315                key_specs: 0 as *const keySpec as *mut keySpec,
69316                legacy_range_key_spec: keySpec {
69317                    notes: 0 as *const libc::c_char,
69318                    flags: 0,
69319                    begin_search_type: KSPEC_BS_INVALID,
69320                    bs: C2RustUnnamed_3 {
69321                        index: C2RustUnnamed_5 { pos: 0 },
69322                    },
69323                    find_keys_type: KSPEC_FK_INVALID,
69324                    fk: C2RustUnnamed_0 {
69325                        range: C2RustUnnamed_2 {
69326                            lastkey: 0,
69327                            keystep: 0,
69328                            limit: 0,
69329                        },
69330                    },
69331                },
69332                num_args: 0,
69333                num_history: 0,
69334                num_tips: 0,
69335                key_specs_num: 0,
69336                key_specs_max: 0,
69337                subcommands_dict: 0 as *const dict as *mut dict,
69338                parent: 0 as *const redisCommand as *mut redisCommand,
69339                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69340            };
69341            init
69342        },
69343        {
69344            let mut init = redisCommand {
69345                declared_name: b"unwatch\0" as *const u8 as *const libc::c_char,
69346                summary: b"Forget about all watched keys\0" as *const u8
69347                    as *const libc::c_char,
69348                complexity: b"O(1)\0" as *const u8 as *const libc::c_char,
69349                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
69350                doc_flags: 0 as libc::c_int,
69351                replaced_by: 0 as *const libc::c_char,
69352                deprecated_since: 0 as *const libc::c_char,
69353                group: COMMAND_GROUP_TRANSACTIONS,
69354                history: 0 as *const commandHistory as *mut commandHistory,
69355                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69356                proc_0: Some(unwatchCommand as unsafe extern "C" fn(*mut client) -> ()),
69357                arity: 1 as libc::c_int,
69358                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
69359                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
69360                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
69361                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
69362                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
69363                acl_categories: ((1 as libc::c_ulonglong) << 19 as libc::c_int)
69364                    as uint64_t,
69365                key_specs_static: [keySpec {
69366                    notes: 0 as *const libc::c_char,
69367                    flags: 0,
69368                    begin_search_type: KSPEC_BS_INVALID,
69369                    bs: C2RustUnnamed_3 {
69370                        index: C2RustUnnamed_5 { pos: 0 },
69371                    },
69372                    find_keys_type: KSPEC_FK_INVALID,
69373                    fk: C2RustUnnamed_0 {
69374                        range: C2RustUnnamed_2 {
69375                            lastkey: 0,
69376                            keystep: 0,
69377                            limit: 0,
69378                        },
69379                    },
69380                }; 4],
69381                getkeys_proc: None,
69382                subcommands: 0 as *const redisCommand as *mut redisCommand,
69383                args: 0 as *const redisCommandArg as *mut redisCommandArg,
69384                microseconds: 0,
69385                calls: 0,
69386                rejected_calls: 0,
69387                failed_calls: 0,
69388                id: 0,
69389                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69390                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69391                key_specs: 0 as *const keySpec as *mut keySpec,
69392                legacy_range_key_spec: keySpec {
69393                    notes: 0 as *const libc::c_char,
69394                    flags: 0,
69395                    begin_search_type: KSPEC_BS_INVALID,
69396                    bs: C2RustUnnamed_3 {
69397                        index: C2RustUnnamed_5 { pos: 0 },
69398                    },
69399                    find_keys_type: KSPEC_FK_INVALID,
69400                    fk: C2RustUnnamed_0 {
69401                        range: C2RustUnnamed_2 {
69402                            lastkey: 0,
69403                            keystep: 0,
69404                            limit: 0,
69405                        },
69406                    },
69407                },
69408                num_args: 0,
69409                num_history: 0,
69410                num_tips: 0,
69411                key_specs_num: 0,
69412                key_specs_max: 0,
69413                subcommands_dict: 0 as *const dict as *mut dict,
69414                parent: 0 as *const redisCommand as *mut redisCommand,
69415                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69416            };
69417            init
69418        },
69419        {
69420            let mut init = redisCommand {
69421                declared_name: b"watch\0" as *const u8 as *const libc::c_char,
69422                summary: b"Watch the given keys to determine execution of the MULTI/EXEC block\0"
69423                    as *const u8 as *const libc::c_char,
69424                complexity: b"O(1) for every key.\0" as *const u8 as *const libc::c_char,
69425                since: b"2.2.0\0" as *const u8 as *const libc::c_char,
69426                doc_flags: 0 as libc::c_int,
69427                replaced_by: 0 as *const libc::c_char,
69428                deprecated_since: 0 as *const libc::c_char,
69429                group: COMMAND_GROUP_TRANSACTIONS,
69430                history: 0 as *const commandHistory as *mut commandHistory,
69431                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69432                proc_0: Some(watchCommand as unsafe extern "C" fn(*mut client) -> ()),
69433                arity: -(2 as libc::c_int),
69434                flags: ((1 as libc::c_ulonglong) << 6 as libc::c_int
69435                    | (1 as libc::c_ulonglong) << 9 as libc::c_int
69436                    | (1 as libc::c_ulonglong) << 10 as libc::c_int
69437                    | (1 as libc::c_ulonglong) << 14 as libc::c_int
69438                    | (1 as libc::c_ulonglong) << 26 as libc::c_int) as uint64_t,
69439                acl_categories: ((1 as libc::c_ulonglong) << 19 as libc::c_int)
69440                    as uint64_t,
69441                key_specs_static: [
69442                    {
69443                        let mut init = keySpec {
69444                            notes: 0 as *const libc::c_char,
69445                            flags: ((1 as libc::c_ulonglong) << 0 as libc::c_int)
69446                                as uint64_t,
69447                            begin_search_type: KSPEC_BS_INDEX,
69448                            bs: C2RustUnnamed_3 {
69449                                index: {
69450                                    let mut init = C2RustUnnamed_5 {
69451                                        pos: 1 as libc::c_int,
69452                                    };
69453                                    init
69454                                },
69455                            },
69456                            find_keys_type: KSPEC_FK_RANGE,
69457                            fk: C2RustUnnamed_0 {
69458                                range: {
69459                                    let mut init = C2RustUnnamed_2 {
69460                                        lastkey: -(1 as libc::c_int),
69461                                        keystep: 1 as libc::c_int,
69462                                        limit: 0 as libc::c_int,
69463                                    };
69464                                    init
69465                                },
69466                            },
69467                        };
69468                        init
69469                    },
69470                    keySpec {
69471                        notes: 0 as *const libc::c_char,
69472                        flags: 0,
69473                        begin_search_type: KSPEC_BS_INVALID,
69474                        bs: C2RustUnnamed_3 {
69475                            index: C2RustUnnamed_5 { pos: 0 },
69476                        },
69477                        find_keys_type: KSPEC_FK_INVALID,
69478                        fk: C2RustUnnamed_0 {
69479                            range: C2RustUnnamed_2 {
69480                                lastkey: 0,
69481                                keystep: 0,
69482                                limit: 0,
69483                            },
69484                        },
69485                    },
69486                    keySpec {
69487                        notes: 0 as *const libc::c_char,
69488                        flags: 0,
69489                        begin_search_type: KSPEC_BS_INVALID,
69490                        bs: C2RustUnnamed_3 {
69491                            index: C2RustUnnamed_5 { pos: 0 },
69492                        },
69493                        find_keys_type: KSPEC_FK_INVALID,
69494                        fk: C2RustUnnamed_0 {
69495                            range: C2RustUnnamed_2 {
69496                                lastkey: 0,
69497                                keystep: 0,
69498                                limit: 0,
69499                            },
69500                        },
69501                    },
69502                    keySpec {
69503                        notes: 0 as *const libc::c_char,
69504                        flags: 0,
69505                        begin_search_type: KSPEC_BS_INVALID,
69506                        bs: C2RustUnnamed_3 {
69507                            index: C2RustUnnamed_5 { pos: 0 },
69508                        },
69509                        find_keys_type: KSPEC_FK_INVALID,
69510                        fk: C2RustUnnamed_0 {
69511                            range: C2RustUnnamed_2 {
69512                                lastkey: 0,
69513                                keystep: 0,
69514                                limit: 0,
69515                            },
69516                        },
69517                    },
69518                ],
69519                getkeys_proc: None,
69520                subcommands: 0 as *const redisCommand as *mut redisCommand,
69521                args: WATCH_Args.as_ptr() as *mut _,
69522                microseconds: 0,
69523                calls: 0,
69524                rejected_calls: 0,
69525                failed_calls: 0,
69526                id: 0,
69527                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69528                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69529                key_specs: 0 as *const keySpec as *mut keySpec,
69530                legacy_range_key_spec: keySpec {
69531                    notes: 0 as *const libc::c_char,
69532                    flags: 0,
69533                    begin_search_type: KSPEC_BS_INVALID,
69534                    bs: C2RustUnnamed_3 {
69535                        index: C2RustUnnamed_5 { pos: 0 },
69536                    },
69537                    find_keys_type: KSPEC_FK_INVALID,
69538                    fk: C2RustUnnamed_0 {
69539                        range: C2RustUnnamed_2 {
69540                            lastkey: 0,
69541                            keystep: 0,
69542                            limit: 0,
69543                        },
69544                    },
69545                },
69546                num_args: 0,
69547                num_history: 0,
69548                num_tips: 0,
69549                key_specs_num: 0,
69550                key_specs_max: 0,
69551                subcommands_dict: 0 as *const dict as *mut dict,
69552                parent: 0 as *const redisCommand as *mut redisCommand,
69553                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69554            };
69555            init
69556        },
69557        {
69558            let mut init = redisCommand {
69559                declared_name: 0 as *const libc::c_char,
69560                summary: 0 as *const libc::c_char,
69561                complexity: 0 as *const libc::c_char,
69562                since: 0 as *const libc::c_char,
69563                doc_flags: 0,
69564                replaced_by: 0 as *const libc::c_char,
69565                deprecated_since: 0 as *const libc::c_char,
69566                group: COMMAND_GROUP_GENERIC,
69567                history: 0 as *const commandHistory as *mut commandHistory,
69568                tips: 0 as *const *const libc::c_char as *mut *const libc::c_char,
69569                proc_0: None,
69570                arity: 0,
69571                flags: 0,
69572                acl_categories: 0,
69573                key_specs_static: [keySpec {
69574                    notes: 0 as *const libc::c_char,
69575                    flags: 0,
69576                    begin_search_type: KSPEC_BS_INVALID,
69577                    bs: C2RustUnnamed_3 {
69578                        index: C2RustUnnamed_5 { pos: 0 },
69579                    },
69580                    find_keys_type: KSPEC_FK_INVALID,
69581                    fk: C2RustUnnamed_0 {
69582                        range: C2RustUnnamed_2 {
69583                            lastkey: 0,
69584                            keystep: 0,
69585                            limit: 0,
69586                        },
69587                    },
69588                }; 4],
69589                getkeys_proc: None,
69590                subcommands: 0 as *const redisCommand as *mut redisCommand,
69591                args: 0 as *const redisCommandArg as *mut redisCommandArg,
69592                microseconds: 0,
69593                calls: 0,
69594                rejected_calls: 0,
69595                failed_calls: 0,
69596                id: 0,
69597                fullname: 0 as *const libc::c_char as *mut libc::c_char,
69598                latency_histogram: 0 as *const hdr_histogram as *mut hdr_histogram,
69599                key_specs: 0 as *const keySpec as *mut keySpec,
69600                legacy_range_key_spec: keySpec {
69601                    notes: 0 as *const libc::c_char,
69602                    flags: 0,
69603                    begin_search_type: KSPEC_BS_INVALID,
69604                    bs: C2RustUnnamed_3 {
69605                        index: C2RustUnnamed_5 { pos: 0 },
69606                    },
69607                    find_keys_type: KSPEC_FK_INVALID,
69608                    fk: C2RustUnnamed_0 {
69609                        range: C2RustUnnamed_2 {
69610                            lastkey: 0,
69611                            keystep: 0,
69612                            limit: 0,
69613                        },
69614                    },
69615                },
69616                num_args: 0,
69617                num_history: 0,
69618                num_tips: 0,
69619                key_specs_num: 0,
69620                key_specs_max: 0,
69621                subcommands_dict: 0 as *const dict as *mut dict,
69622                parent: 0 as *const redisCommand as *mut redisCommand,
69623                module_cmd: 0 as *const RedisModuleCommand as *mut RedisModuleCommand,
69624            };
69625            init
69626        },
69627    ]
69628};
redrust/commands.rs

redrust/
commands.rs
