t_zset.c

Bug Summary

File:	src/t_zset.c
Warning:	line 180, column 30 The left operand of '==' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name t_zset.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D REDIS_STATIC= -I ../deps/hiredis -I ../deps/linenoise -I ../deps/lua/src -I ../deps/hdr_histogram -D USE_JEMALLOC -I ../deps/jemalloc/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-c11-extensions -Wno-missing-field-initializers -std=c11 -fdebug-compilation-dir /home/netto/Desktop/redis-6.2.1/src -ferror-limit 19 -fmessage-length 0 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-03-14-133648-8817-1 -x c t_zset.c
1/*
* Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
* Copyright (c) 2009-2012, Pieter Noordhuis <pcnoordhuis at gmail dot com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*   * Redistributions of source code must retain the above copyright notice,
*     this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the
*     documentation and/or other materials provided with the distribution.
*   * Neither the name of Redis nor the names of its contributors may be used
*     to endorse or promote products derived from this software without
*     specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

31/*-----------------------------------------------------------------------------
* Sorted set API
*----------------------------------------------------------------------------*/

35/* ZSETs are ordered sets using two data structures to hold the same elements
* in order to get O(log(N)) INSERT and REMOVE operations into a sorted
* data structure.
*
* The elements are added to a hash table mapping Redis objects to scores.
* At the same time the elements are added to a skip list mapping scores
* to Redis objects (so objects are sorted by scores in this "view").
*
* Note that the SDS string representing the element is the same in both
* the hash table and skiplist in order to save memory. What we do in order
* to manage the shared SDS string more easily is to free the SDS string
* only in zslFreeNode(). The dictionary has no value free method set.
* So we should always remove an element from the dictionary, and later from
* the skiplist.
*
* This skiplist implementation is almost a C translation of the original
* algorithm described by William Pugh in "Skip Lists: A Probabilistic
* Alternative to Balanced Trees", modified in three ways:
* a) this implementation allows for repeated scores.
* b) the comparison is not just by key (our 'score') but by satellite data.
* c) there is a back pointer, so it's a doubly linked list with the back
* pointers being only at "level 1". This allows to traverse the list
* from tail to head, useful for ZREVRANGE. */

59#include "server.h"
60#include <math.h>

62/*-----------------------------------------------------------------------------
* Skiplist implementation of the low level API
*----------------------------------------------------------------------------*/

66int zslLexValueGteMin(sds value, zlexrangespec *spec);
67int zslLexValueLteMax(sds value, zlexrangespec *spec);

69/* Create a skiplist node with the specified number of levels.
* The SDS string 'ele' is referenced by the node after the call. */
71zskiplistNode *zslCreateNode(int level, double score, sds ele) {
  zskiplistNode *zn =
      zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
  zn->score = score;
  zn->ele = ele;
  return zn;
77}

79/* Create a new skiplist. */
80zskiplist *zslCreate(void) {
  int j;
  zskiplist *zsl;

  zsl = zmalloc(sizeof(*zsl));
  zsl->level = 1;
  zsl->length = 0;
  zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL32,0,NULL((void*)0));
  for (j = 0; j < ZSKIPLIST_MAXLEVEL32; j++) {
      zsl->header->level[j].forward = NULL((void*)0);
      zsl->header->level[j].span = 0;
  }
  zsl->header->backward = NULL((void*)0);
  zsl->tail = NULL((void*)0);
  return zsl;
95}

97/* Free the specified skiplist node. The referenced SDS string representation
* of the element is freed too, unless node->ele is set to NULL before calling
* this function. */
100void zslFreeNode(zskiplistNode *node) {
  sdsfree(node->ele);
  zfree(node);
103}

105/* Free a whole skiplist. */
106void zslFree(zskiplist *zsl) {
  zskiplistNode *node = zsl->header->level[0].forward, *next;

  zfree(zsl->header);
  while(node) {
      next = node->level[0].forward;
      zslFreeNode(node);
      node = next;
  }
  zfree(zsl);
116}

118/* Returns a random level for the new skiplist node we are going to create.
* The return value of this function is between 1 and ZSKIPLIST_MAXLEVEL
* (both inclusive), with a powerlaw-alike distribution where higher
* levels are less likely to be returned. */
122int zslRandomLevel(void) {
  int level = 1;
  while ((random()&0xFFFF) < (ZSKIPLIST_P0.25 * 0xFFFF))
      level += 1;
  return (level<ZSKIPLIST_MAXLEVEL32) ? level : ZSKIPLIST_MAXLEVEL32;
127}

129/* Insert a new node in the skiplist. Assumes the element does not already
* exist (up to the caller to enforce that). The skiplist takes ownership
* of the passed SDS string 'ele'. */
132zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  unsigned int rank[ZSKIPLIST_MAXLEVEL32];
  int i, level;

  serverAssert(!isnan(score))((!__builtin_isnan (score))?(void)0 : (_serverAssert("!isnan(score)"
,"t_zset.c",137),__builtin_unreachable()));
12
←
Assuming the condition is true→
13
←
'?' condition is true→
  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
14
←
Assuming 'i' is < 0→
15
←
Loop condition is false. Execution continues on line 156→
      /* store rank that is crossed to reach the insert position */
      rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
      while (x->level[i].forward &&
              (x->level[i].forward->score < score ||
                  (x->level[i].forward->score == score &&
                  sdscmp(x->level[i].forward->ele,ele) < 0)))
      {
          rank[i] += x->level[i].span;
          x = x->level[i].forward;
      }
      update[i] = x;
  }
  /* we assume the element is not already inside, since we allow duplicated
   * scores, reinserting the same element should never happen since the
   * caller of zslInsert() should test in the hash table if the element is
   * already inside or not. */
  level = zslRandomLevel();
  if (level > zsl->level) {
16
←
Assuming 'level' is <= field 'level'→
17
←
Taking false branch→
      for (i = zsl->level; i < level; i++) {
          rank[i] = 0;
          update[i] = zsl->header;
          update[i]->level[i].span = zsl->length;
      }
      zsl->level = level;
  }
  x = zslCreateNode(level,score,ele);
  for (i = 0; i < level; i++) {
18
←
Assuming 'i' is >= 'level'→
19
←
Loop condition is false. Execution continues on line 176→
      x->level[i].forward = update[i]->level[i].forward;
      update[i]->level[i].forward = x;

      /* update span covered by update[i] as x is inserted here */
      x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
      update[i]->level[i].span = (rank[0] - rank[i]) + 1;
  }

  /* increment span for untouched levels */
  for (i = level; i < zsl->level; i++) {
20
←
Assuming 'i' is >= field 'level'→
21
←
Loop condition is false. Execution continues on line 180→
      update[i]->level[i].span++;
  }

  x->backward = (update[0] == zsl->header) ? NULL((void*)0) : update[0];
22
←
The left operand of '==' is a garbage value
  if (x->level[0].forward)
      x->level[0].forward->backward = x;
  else
      zsl->tail = x;
  zsl->length++;
  return x;
187}

189/* Internal function used by zslDelete, zslDeleteRangeByScore and
* zslDeleteRangeByRank. */
191void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
  int i;
  for (i = 0; i < zsl->level; i++) {
      if (update[i]->level[i].forward == x) {
          update[i]->level[i].span += x->level[i].span - 1;
          update[i]->level[i].forward = x->level[i].forward;
      } else {
          update[i]->level[i].span -= 1;
      }
  }
  if (x->level[0].forward) {
      x->level[0].forward->backward = x->backward;
  } else {
      zsl->tail = x->backward;
  }
  while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL((void*)0))
      zsl->level--;
  zsl->length--;
209}

211/* Delete an element with matching score/element from the skiplist.
* The function returns 1 if the node was found and deleted, otherwise
* 0 is returned.
*
* If 'node' is NULL the deleted node is freed by zslFreeNode(), otherwise
* it is not freed (but just unlinked) and *node is set to the node pointer,
* so that it is possible for the caller to reuse the node (including the
* referenced SDS string at node->ele). */
219int zslDelete(zskiplist *zsl, double score, sds ele, zskiplistNode **node) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  int i;

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward &&
              (x->level[i].forward->score < score ||
                  (x->level[i].forward->score == score &&
                   sdscmp(x->level[i].forward->ele,ele) < 0)))
      {
          x = x->level[i].forward;
      }
      update[i] = x;
  }
  /* We may have multiple elements with the same score, what we need
   * is to find the element with both the right score and object. */
  x = x->level[0].forward;
  if (x && score == x->score && sdscmp(x->ele,ele) == 0) {
      zslDeleteNode(zsl, x, update);
      if (!node)
          zslFreeNode(x);
      else
          *node = x;
      return 1;
  }
  return 0; /* not found */
246}

248/* Update the score of an element inside the sorted set skiplist.
* Note that the element must exist and must match 'score'.
* This function does not update the score in the hash table side, the
* caller should take care of it.
*
* Note that this function attempts to just update the node, in case after
* the score update, the node would be exactly at the same position.
* Otherwise the skiplist is modified by removing and re-adding a new
* element, which is more costly.
*
* The function returns the updated element skiplist node pointer. */
259zskiplistNode *zslUpdateScore(zskiplist *zsl, double curscore, sds ele, double newscore) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  int i;

  /* We need to seek to element to update to start: this is useful anyway,
   * we'll have to update or remove it. */
  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward &&
              (x->level[i].forward->score < curscore ||
                  (x->level[i].forward->score == curscore &&
                   sdscmp(x->level[i].forward->ele,ele) < 0)))
      {
          x = x->level[i].forward;
      }
      update[i] = x;
  }

  /* Jump to our element: note that this function assumes that the
   * element with the matching score exists. */
  x = x->level[0].forward;
  serverAssert(x && curscore == x->score && sdscmp(x->ele,ele) == 0)((x && curscore == x->score && sdscmp(x->
ele,ele) == 0)?(void)0 : (_serverAssert("x && curscore == x->score && sdscmp(x->ele,ele) == 0"
,"t_zset.c",280),__builtin_unreachable()));

  /* If the node, after the score update, would be still exactly
   * at the same position, we can just update the score without
   * actually removing and re-inserting the element in the skiplist. */
  if ((x->backward == NULL((void*)0) || x->backward->score < newscore) &&
      (x->level[0].forward == NULL((void*)0) || x->level[0].forward->score > newscore))
  {
      x->score = newscore;
      return x;
  }

  /* No way to reuse the old node: we need to remove and insert a new
   * one at a different place. */
  zslDeleteNode(zsl, x, update);
  zskiplistNode *newnode = zslInsert(zsl,newscore,x->ele);
  /* We reused the old node x->ele SDS string, free the node now
   * since zslInsert created a new one. */
  x->ele = NULL((void*)0);
  zslFreeNode(x);
  return newnode;
301}

303int zslValueGteMin(double value, zrangespec *spec) {
  return spec->minex ? (value > spec->min) : (value >= spec->min);
305}

307int zslValueLteMax(double value, zrangespec *spec) {
  return spec->maxex ? (value < spec->max) : (value <= spec->max);
309}

311/* Returns if there is a part of the zset is in range. */
312int zslIsInRange(zskiplist *zsl, zrangespec *range) {
  zskiplistNode *x;

  /* Test for ranges that will always be empty. */
  if (range->min > range->max ||
          (range->min == range->max && (range->minex || range->maxex)))
      return 0;
  x = zsl->tail;
  if (x == NULL((void*)0) || !zslValueGteMin(x->score,range))
      return 0;
  x = zsl->header->level[0].forward;
  if (x == NULL((void*)0) || !zslValueLteMax(x->score,range))
      return 0;
  return 1;
326}

328/* Find the first node that is contained in the specified range.
* Returns NULL when no element is contained in the range. */
330zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
  zskiplistNode *x;
  int i;

  /* If everything is out of range, return early. */
  if (!zslIsInRange(zsl,range)) return NULL((void*)0);

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      /* Go forward while *OUT* of range. */
      while (x->level[i].forward &&
          !zslValueGteMin(x->level[i].forward->score,range))
              x = x->level[i].forward;
  }

  /* This is an inner range, so the next node cannot be NULL. */
  x = x->level[0].forward;
  serverAssert(x != NULL)((x != ((void*)0))?(void)0 : (_serverAssert("x != NULL","t_zset.c"
,347),__builtin_unreachable()));

  /* Check if score <= max. */
  if (!zslValueLteMax(x->score,range)) return NULL((void*)0);
  return x;
352}

354/* Find the last node that is contained in the specified range.
* Returns NULL when no element is contained in the range. */
356zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
  zskiplistNode *x;
  int i;

  /* If everything is out of range, return early. */
  if (!zslIsInRange(zsl,range)) return NULL((void*)0);

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      /* Go forward while *IN* range. */
      while (x->level[i].forward &&
          zslValueLteMax(x->level[i].forward->score,range))
              x = x->level[i].forward;
  }

  /* This is an inner range, so this node cannot be NULL. */
  serverAssert(x != NULL)((x != ((void*)0))?(void)0 : (_serverAssert("x != NULL","t_zset.c"
,372),__builtin_unreachable()));

  /* Check if score >= min. */
  if (!zslValueGteMin(x->score,range)) return NULL((void*)0);
  return x;
377}

379/* Delete all the elements with score between min and max from the skiplist.
* Both min and max can be inclusive or exclusive (see range->minex and
* range->maxex). When inclusive a score >= min && score <= max is deleted.
* Note that this function takes the reference to the hash table view of the
* sorted set, in order to remove the elements from the hash table too. */
384unsigned long zslDeleteRangeByScore(zskiplist *zsl, zrangespec *range, dict *dict) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  unsigned long removed = 0;
  int i;

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward && (range->minex ?
          x->level[i].forward->score <= range->min :
          x->level[i].forward->score < range->min))
              x = x->level[i].forward;
      update[i] = x;
  }

  /* Current node is the last with score < or <= min. */
  x = x->level[0].forward;

  /* Delete nodes while in range. */
  while (x &&
         (range->maxex ? x->score < range->max : x->score <= range->max))
  {
      zskiplistNode *next = x->level[0].forward;
      zslDeleteNode(zsl,x,update);
      dictDelete(dict,x->ele);
      zslFreeNode(x); /* Here is where x->ele is actually released. */
      removed++;
      x = next;
  }
  return removed;
413}

415unsigned long zslDeleteRangeByLex(zskiplist *zsl, zlexrangespec *range, dict *dict) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  unsigned long removed = 0;
  int i;


  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward &&
          !zslLexValueGteMin(x->level[i].forward->ele,range))
              x = x->level[i].forward;
      update[i] = x;
  }

  /* Current node is the last with score < or <= min. */
  x = x->level[0].forward;

  /* Delete nodes while in range. */
  while (x && zslLexValueLteMax(x->ele,range)) {
      zskiplistNode *next = x->level[0].forward;
      zslDeleteNode(zsl,x,update);
      dictDelete(dict,x->ele);
      zslFreeNode(x); /* Here is where x->ele is actually released. */
      removed++;
      x = next;
  }
  return removed;
442}

444/* Delete all the elements with rank between start and end from the skiplist.
* Start and end are inclusive. Note that start and end need to be 1-based */
446unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) {
  zskiplistNode *update[ZSKIPLIST_MAXLEVEL32], *x;
  unsigned long traversed = 0, removed = 0;
  int i;

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward && (traversed + x->level[i].span) < start) {
          traversed += x->level[i].span;
          x = x->level[i].forward;
      }
      update[i] = x;
  }

  traversed++;
  x = x->level[0].forward;
  while (x && traversed <= end) {
      zskiplistNode *next = x->level[0].forward;
      zslDeleteNode(zsl,x,update);
      dictDelete(dict,x->ele);
      zslFreeNode(x);
      removed++;
      traversed++;
      x = next;
  }
  return removed;
472}

474/* Find the rank for an element by both score and key.
* Returns 0 when the element cannot be found, rank otherwise.
* Note that the rank is 1-based due to the span of zsl->header to the
* first element. */
478unsigned long zslGetRank(zskiplist *zsl, double score, sds ele) {
  zskiplistNode *x;
  unsigned long rank = 0;
  int i;

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward &&
          (x->level[i].forward->score < score ||
              (x->level[i].forward->score == score &&
              sdscmp(x->level[i].forward->ele,ele) <= 0))) {
          rank += x->level[i].span;
          x = x->level[i].forward;
      }

      /* x might be equal to zsl->header, so test if obj is non-NULL */
      if (x->ele && sdscmp(x->ele,ele) == 0) {
          return rank;
      }
  }
  return 0;
499}

501/* Finds an element by its rank. The rank argument needs to be 1-based. */
502zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
  zskiplistNode *x;
  unsigned long traversed = 0;
  int i;

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      while (x->level[i].forward && (traversed + x->level[i].span) <= rank)
      {
          traversed += x->level[i].span;
          x = x->level[i].forward;
      }
      if (traversed == rank) {
          return x;
      }
  }
  return NULL((void*)0);
519}

521/* Populate the rangespec according to the objects min and max. */
522static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
  char *eptr;
  spec->minex = spec->maxex = 0;

  /* Parse the min-max interval. If one of the values is prefixed
   * by the "(" character, it's considered "open". For instance
   * ZRANGEBYSCORE zset (1.5 (2.5 will match min < x < max
   * ZRANGEBYSCORE zset 1.5 2.5 will instead match min <= x <= max */
  if (min->encoding == OBJ_ENCODING_INT1) {
      spec->min = (long)min->ptr;
  } else {
      if (((char*)min->ptr)[0] == '(') {
          spec->min = strtod((char*)min->ptr+1,&eptr);
          if (eptr[0] != '\0' || isnan(spec->min)__builtin_isnan (spec->min)) return C_ERR-1;
          spec->minex = 1;
      } else {
          spec->min = strtod((char*)min->ptr,&eptr);
          if (eptr[0] != '\0' || isnan(spec->min)__builtin_isnan (spec->min)) return C_ERR-1;
      }
  }
  if (max->encoding == OBJ_ENCODING_INT1) {
      spec->max = (long)max->ptr;
  } else {
      if (((char*)max->ptr)[0] == '(') {
          spec->max = strtod((char*)max->ptr+1,&eptr);
          if (eptr[0] != '\0' || isnan(spec->max)__builtin_isnan (spec->max)) return C_ERR-1;
          spec->maxex = 1;
      } else {
          spec->max = strtod((char*)max->ptr,&eptr);
          if (eptr[0] != '\0' || isnan(spec->max)__builtin_isnan (spec->max)) return C_ERR-1;
      }
  }

  return C_OK0;
556}

558/* ------------------------ Lexicographic ranges ---------------------------- */

560/* Parse max or min argument of ZRANGEBYLEX.
* (foo means foo (open interval)
* [foo means foo (closed interval)
* - means the min string possible
* + means the max string possible
*
* If the string is valid the *dest pointer is set to the redis object
* that will be used for the comparison, and ex will be set to 0 or 1
* respectively if the item is exclusive or inclusive. C_OK will be
* returned.
*
* If the string is not a valid range C_ERR is returned, and the value
* of *dest and *ex is undefined. */
573int zslParseLexRangeItem(robj *item, sds *dest, int *ex) {
  char *c = item->ptr;

  switch(c[0]) {
  case '+':
      if (c[1] != '\0') return C_ERR-1;
      *ex = 1;
      *dest = shared.maxstring;
      return C_OK0;
  case '-':
      if (c[1] != '\0') return C_ERR-1;
      *ex = 1;
      *dest = shared.minstring;
      return C_OK0;
  case '(':
      *ex = 1;
      *dest = sdsnewlen(c+1,sdslen(c)-1);
      return C_OK0;
  case '[':
      *ex = 0;
      *dest = sdsnewlen(c+1,sdslen(c)-1);
      return C_OK0;
  default:
      return C_ERR-1;
  }
598}

600/* Free a lex range structure, must be called only after zelParseLexRange()
* populated the structure with success (C_OK returned). */
602void zslFreeLexRange(zlexrangespec *spec) {
  if (spec->min != shared.minstring &&
      spec->min != shared.maxstring) sdsfree(spec->min);
  if (spec->max != shared.minstring &&
      spec->max != shared.maxstring) sdsfree(spec->max);
607}

609/* Populate the lex rangespec according to the objects min and max.
*
* Return C_OK on success. On error C_ERR is returned.
* When OK is returned the structure must be freed with zslFreeLexRange(),
* otherwise no release is needed. */
614int zslParseLexRange(robj *min, robj *max, zlexrangespec *spec) {
  /* The range can't be valid if objects are integer encoded.
   * Every item must start with ( or [. */
  if (min->encoding == OBJ_ENCODING_INT1 ||
      max->encoding == OBJ_ENCODING_INT1) return C_ERR-1;

  spec->min = spec->max = NULL((void*)0);
  if (zslParseLexRangeItem(min, &spec->min, &spec->minex) == C_ERR-1 ||
      zslParseLexRangeItem(max, &spec->max, &spec->maxex) == C_ERR-1) {
      zslFreeLexRange(spec);
      return C_ERR-1;
  } else {
      return C_OK0;
  }
628}

630/* This is just a wrapper to sdscmp() that is able to
* handle shared.minstring and shared.maxstring as the equivalent of
* -inf and +inf for strings */
633int sdscmplex(sds a, sds b) {
  if (a == b) return 0;
  if (a == shared.minstring || b == shared.maxstring) return -1;
  if (a == shared.maxstring || b == shared.minstring) return 1;
  return sdscmp(a,b);
638}

640int zslLexValueGteMin(sds value, zlexrangespec *spec) {
  return spec->minex ?
      (sdscmplex(value,spec->min) > 0) :
      (sdscmplex(value,spec->min) >= 0);
644}

646int zslLexValueLteMax(sds value, zlexrangespec *spec) {
  return spec->maxex ?
      (sdscmplex(value,spec->max) < 0) :
      (sdscmplex(value,spec->max) <= 0);
650}

652/* Returns if there is a part of the zset is in the lex range. */
653int zslIsInLexRange(zskiplist *zsl, zlexrangespec *range) {
  zskiplistNode *x;

  /* Test for ranges that will always be empty. */
  int cmp = sdscmplex(range->min,range->max);
  if (cmp > 0 || (cmp == 0 && (range->minex || range->maxex)))
      return 0;
  x = zsl->tail;
  if (x == NULL((void*)0) || !zslLexValueGteMin(x->ele,range))
      return 0;
  x = zsl->header->level[0].forward;
  if (x == NULL((void*)0) || !zslLexValueLteMax(x->ele,range))
      return 0;
  return 1;
667}

669/* Find the first node that is contained in the specified lex range.
* Returns NULL when no element is contained in the range. */
671zskiplistNode *zslFirstInLexRange(zskiplist *zsl, zlexrangespec *range) {
  zskiplistNode *x;
  int i;

  /* If everything is out of range, return early. */
  if (!zslIsInLexRange(zsl,range)) return NULL((void*)0);

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      /* Go forward while *OUT* of range. */
      while (x->level[i].forward &&
          !zslLexValueGteMin(x->level[i].forward->ele,range))
              x = x->level[i].forward;
  }

  /* This is an inner range, so the next node cannot be NULL. */
  x = x->level[0].forward;
  serverAssert(x != NULL)((x != ((void*)0))?(void)0 : (_serverAssert("x != NULL","t_zset.c"
,688),__builtin_unreachable()));

  /* Check if score <= max. */
  if (!zslLexValueLteMax(x->ele,range)) return NULL((void*)0);
  return x;
693}

695/* Find the last node that is contained in the specified range.
* Returns NULL when no element is contained in the range. */
697zskiplistNode *zslLastInLexRange(zskiplist *zsl, zlexrangespec *range) {
  zskiplistNode *x;
  int i;

  /* If everything is out of range, return early. */
  if (!zslIsInLexRange(zsl,range)) return NULL((void*)0);

  x = zsl->header;
  for (i = zsl->level-1; i >= 0; i--) {
      /* Go forward while *IN* range. */
      while (x->level[i].forward &&
          zslLexValueLteMax(x->level[i].forward->ele,range))
              x = x->level[i].forward;
  }

  /* This is an inner range, so this node cannot be NULL. */
  serverAssert(x != NULL)((x != ((void*)0))?(void)0 : (_serverAssert("x != NULL","t_zset.c"
,713),__builtin_unreachable()));

  /* Check if score >= min. */
  if (!zslLexValueGteMin(x->ele,range)) return NULL((void*)0);
  return x;
718}

720/*-----------------------------------------------------------------------------
* Ziplist-backed sorted set API
*----------------------------------------------------------------------------*/

724double zzlStrtod(unsigned char *vstr, unsigned int vlen) {
  char buf[128];
  if (vlen > sizeof(buf))
      vlen = sizeof(buf);
  memcpy(buf,vstr,vlen);
  buf[vlen] = '\0';
  return strtod(buf,NULL((void*)0));
}

733double zzlGetScore(unsigned char *sptr) {
  unsigned char *vstr;
  unsigned int vlen;
  long long vlong;
  double score;

  serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",739),__builtin_unreachable()));
  serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong))((ziplistGet(sptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssert("ziplistGet(sptr,&vstr,&vlen,&vlong)"
,"t_zset.c",740),__builtin_unreachable()));

  if (vstr) {
      score = zzlStrtod(vstr,vlen);
  } else {
      score = vlong;
  }

  return score;
749}

751/* Return a ziplist element as an SDS string. */
752sds ziplistGetObject(unsigned char *sptr) {
  unsigned char *vstr;
  unsigned int vlen;
  long long vlong;

  serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",757),__builtin_unreachable()));
  serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong))((ziplistGet(sptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssert("ziplistGet(sptr,&vstr,&vlen,&vlong)"
,"t_zset.c",758),__builtin_unreachable()));

  if (vstr) {
      return sdsnewlen((char*)vstr,vlen);
  } else {
      return sdsfromlonglong(vlong);
  }
765}

767/* Compare element in sorted set with given element. */
768int zzlCompareElements(unsigned char *eptr, unsigned char *cstr, unsigned int clen) {
  unsigned char *vstr;
  unsigned int vlen;
  long long vlong;
  unsigned char vbuf[32];
  int minlen, cmp;

  serverAssert(ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssert("ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",775),__builtin_unreachable()));
  if (vstr == NULL((void*)0)) {
      /* Store string representation of long long in buf. */
      vlen = ll2string((char*)vbuf,sizeof(vbuf),vlong);
      vstr = vbuf;
  }

  minlen = (vlen < clen) ? vlen : clen;
  cmp = memcmp(vstr,cstr,minlen);
  if (cmp == 0) return vlen-clen;
  return cmp;
786}

788unsigned int zzlLength(unsigned char *zl) {
  return ziplistLen(zl)/2;
790}

792/* Move to next entry based on the values in eptr and sptr. Both are set to
* NULL when there is no next entry. */
794void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
  unsigned char *_eptr, *_sptr;
  serverAssert(*eptr != NULL && *sptr != NULL)((*eptr != ((void*)0) && *sptr != ((void*)0))?(void)0
 : (_serverAssert("*eptr != NULL && *sptr != NULL","t_zset.c"
,796),__builtin_unreachable()));

  _eptr = ziplistNext(zl,*sptr);
  if (_eptr != NULL((void*)0)) {
      _sptr = ziplistNext(zl,_eptr);
      serverAssert(_sptr != NULL)((_sptr != ((void*)0))?(void)0 : (_serverAssert("_sptr != NULL"
,"t_zset.c",801),__builtin_unreachable()));
  } else {
      /* No next entry. */
      _sptr = NULL((void*)0);
  }

  *eptr = _eptr;
  *sptr = _sptr;
809}

811/* Move to the previous entry based on the values in eptr and sptr. Both are
* set to NULL when there is no next entry. */
813void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
  unsigned char *_eptr, *_sptr;
  serverAssert(*eptr != NULL && *sptr != NULL)((*eptr != ((void*)0) && *sptr != ((void*)0))?(void)0
 : (_serverAssert("*eptr != NULL && *sptr != NULL","t_zset.c"
,815),__builtin_unreachable()));

  _sptr = ziplistPrev(zl,*eptr);
  if (_sptr != NULL((void*)0)) {
      _eptr = ziplistPrev(zl,_sptr);
      serverAssert(_eptr != NULL)((_eptr != ((void*)0))?(void)0 : (_serverAssert("_eptr != NULL"
,"t_zset.c",820),__builtin_unreachable()));
  } else {
      /* No previous entry. */
      _eptr = NULL((void*)0);
  }

  *eptr = _eptr;
  *sptr = _sptr;
828}

830/* Returns if there is a part of the zset is in range. Should only be used
* internally by zzlFirstInRange and zzlLastInRange. */
832int zzlIsInRange(unsigned char *zl, zrangespec *range) {
  unsigned char *p;
  double score;

  /* Test for ranges that will always be empty. */
  if (range->min > range->max ||
          (range->min == range->max && (range->minex || range->maxex)))
      return 0;

  p = ziplistIndex(zl,-1); /* Last score. */
  if (p == NULL((void*)0)) return 0; /* Empty sorted set */
  score = zzlGetScore(p);
  if (!zslValueGteMin(score,range))
      return 0;

  p = ziplistIndex(zl,1); /* First score. */
  serverAssert(p != NULL)((p != ((void*)0))?(void)0 : (_serverAssert("p != NULL","t_zset.c"
,848),__builtin_unreachable()));
  score = zzlGetScore(p);
  if (!zslValueLteMax(score,range))
      return 0;

  return 1;
854}

856/* Find pointer to the first element contained in the specified range.
* Returns NULL when no element is contained in the range. */
858unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range) {
  unsigned char *eptr = ziplistIndex(zl,0), *sptr;
  double score;

  /* If everything is out of range, return early. */
  if (!zzlIsInRange(zl,range)) return NULL((void*)0);

  while (eptr != NULL((void*)0)) {
      sptr = ziplistNext(zl,eptr);
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",867),__builtin_unreachable()));

      score = zzlGetScore(sptr);
      if (zslValueGteMin(score,range)) {
          /* Check if score <= max. */
          if (zslValueLteMax(score,range))
              return eptr;
          return NULL((void*)0);
      }

      /* Move to next element. */
      eptr = ziplistNext(zl,sptr);
  }

  return NULL((void*)0);
882}

884/* Find pointer to the last element contained in the specified range.
* Returns NULL when no element is contained in the range. */
886unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range) {
  unsigned char *eptr = ziplistIndex(zl,-2), *sptr;
  double score;

  /* If everything is out of range, return early. */
  if (!zzlIsInRange(zl,range)) return NULL((void*)0);

  while (eptr != NULL((void*)0)) {
      sptr = ziplistNext(zl,eptr);
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",895),__builtin_unreachable()));

      score = zzlGetScore(sptr);
      if (zslValueLteMax(score,range)) {
          /* Check if score >= min. */
          if (zslValueGteMin(score,range))
              return eptr;
          return NULL((void*)0);
      }

      /* Move to previous element by moving to the score of previous element.
       * When this returns NULL, we know there also is no element. */
      sptr = ziplistPrev(zl,eptr);
      if (sptr != NULL((void*)0))
          serverAssert((eptr = ziplistPrev(zl,sptr)) != NULL)(((eptr = ziplistPrev(zl,sptr)) != ((void*)0))?(void)0 : (_serverAssert
("(eptr = ziplistPrev(zl,sptr)) != NULL","t_zset.c",909),__builtin_unreachable
()));
      else
          eptr = NULL((void*)0);
  }

  return NULL((void*)0);
915}

917int zzlLexValueGteMin(unsigned char *p, zlexrangespec *spec) {
  sds value = ziplistGetObject(p);
  int res = zslLexValueGteMin(value,spec);
  sdsfree(value);
  return res;
922}

924int zzlLexValueLteMax(unsigned char *p, zlexrangespec *spec) {
  sds value = ziplistGetObject(p);
  int res = zslLexValueLteMax(value,spec);
  sdsfree(value);
  return res;
929}

931/* Returns if there is a part of the zset is in range. Should only be used
* internally by zzlFirstInRange and zzlLastInRange. */
933int zzlIsInLexRange(unsigned char *zl, zlexrangespec *range) {
  unsigned char *p;

  /* Test for ranges that will always be empty. */
  int cmp = sdscmplex(range->min,range->max);
  if (cmp > 0 || (cmp == 0 && (range->minex || range->maxex)))
      return 0;

  p = ziplistIndex(zl,-2); /* Last element. */
  if (p == NULL((void*)0)) return 0;
  if (!zzlLexValueGteMin(p,range))
      return 0;

  p = ziplistIndex(zl,0); /* First element. */
  serverAssert(p != NULL)((p != ((void*)0))?(void)0 : (_serverAssert("p != NULL","t_zset.c"
,947),__builtin_unreachable()));
  if (!zzlLexValueLteMax(p,range))
      return 0;

  return 1;
952}

954/* Find pointer to the first element contained in the specified lex range.
* Returns NULL when no element is contained in the range. */
956unsigned char *zzlFirstInLexRange(unsigned char *zl, zlexrangespec *range) {
  unsigned char *eptr = ziplistIndex(zl,0), *sptr;

  /* If everything is out of range, return early. */
  if (!zzlIsInLexRange(zl,range)) return NULL((void*)0);

  while (eptr != NULL((void*)0)) {
      if (zzlLexValueGteMin(eptr,range)) {
          /* Check if score <= max. */
          if (zzlLexValueLteMax(eptr,range))
              return eptr;
          return NULL((void*)0);
      }

      /* Move to next element. */
      sptr = ziplistNext(zl,eptr); /* This element score. Skip it. */
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",972),__builtin_unreachable()));
      eptr = ziplistNext(zl,sptr); /* Next element. */
  }

  return NULL((void*)0);
977}

979/* Find pointer to the last element contained in the specified lex range.
* Returns NULL when no element is contained in the range. */
981unsigned char *zzlLastInLexRange(unsigned char *zl, zlexrangespec *range) {
  unsigned char *eptr = ziplistIndex(zl,-2), *sptr;

  /* If everything is out of range, return early. */
  if (!zzlIsInLexRange(zl,range)) return NULL((void*)0);

  while (eptr != NULL((void*)0)) {
      if (zzlLexValueLteMax(eptr,range)) {
          /* Check if score >= min. */
          if (zzlLexValueGteMin(eptr,range))
              return eptr;
          return NULL((void*)0);
      }

      /* Move to previous element by moving to the score of previous element.
       * When this returns NULL, we know there also is no element. */
      sptr = ziplistPrev(zl,eptr);
      if (sptr != NULL((void*)0))
          serverAssert((eptr = ziplistPrev(zl,sptr)) != NULL)(((eptr = ziplistPrev(zl,sptr)) != ((void*)0))?(void)0 : (_serverAssert
("(eptr = ziplistPrev(zl,sptr)) != NULL","t_zset.c",999),__builtin_unreachable
()));
      else
          eptr = NULL((void*)0);
  }

  return NULL((void*)0);
1005}

1007unsigned char *zzlFind(unsigned char *zl, sds ele, double *score) {
  unsigned char *eptr = ziplistIndex(zl,0), *sptr;

  while (eptr != NULL((void*)0)) {
      sptr = ziplistNext(zl,eptr);
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",1012),__builtin_unreachable()));

      if (ziplistCompare(eptr,(unsigned char*)ele,sdslen(ele))) {
          /* Matching element, pull out score. */
          if (score != NULL((void*)0)) *score = zzlGetScore(sptr);
          return eptr;
      }

      /* Move to next element. */
      eptr = ziplistNext(zl,sptr);
  }
  return NULL((void*)0);
1024}

1026/* Delete (element,score) pair from ziplist. Use local copy of eptr because we
* don't want to modify the one given as argument. */
1028unsigned char *zzlDelete(unsigned char *zl, unsigned char *eptr) {
  unsigned char *p = eptr;

  /* TODO: add function to ziplist API to delete N elements from offset. */
  zl = ziplistDelete(zl,&p);
  zl = ziplistDelete(zl,&p);
  return zl;
1035}

1037unsigned char *zzlInsertAt(unsigned char *zl, unsigned char *eptr, sds ele, double score) {
  unsigned char *sptr;
  char scorebuf[128];
  int scorelen;
  size_t offset;

  scorelen = d2string(scorebuf,sizeof(scorebuf),score);
  if (eptr == NULL((void*)0)) {
      zl = ziplistPush(zl,(unsigned char*)ele,sdslen(ele),ZIPLIST_TAIL1);
      zl = ziplistPush(zl,(unsigned char*)scorebuf,scorelen,ZIPLIST_TAIL1);
  } else {
      /* Keep offset relative to zl, as it might be re-allocated. */
      offset = eptr-zl;
      zl = ziplistInsert(zl,eptr,(unsigned char*)ele,sdslen(ele));
      eptr = zl+offset;

      /* Insert score after the element. */
      serverAssert((sptr = ziplistNext(zl,eptr)) != NULL)(((sptr = ziplistNext(zl,eptr)) != ((void*)0))?(void)0 : (_serverAssert
("(sptr = ziplistNext(zl,eptr)) != NULL","t_zset.c",1054),__builtin_unreachable
()));
      zl = ziplistInsert(zl,sptr,(unsigned char*)scorebuf,scorelen);
  }
  return zl;
1058}

1060/* Insert (element,score) pair in ziplist. This function assumes the element is
* not yet present in the list. */
1062unsigned char *zzlInsert(unsigned char *zl, sds ele, double score) {
  unsigned char *eptr = ziplistIndex(zl,0), *sptr;
  double s;

  while (eptr != NULL((void*)0)) {
      sptr = ziplistNext(zl,eptr);
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",1068),__builtin_unreachable()));
      s = zzlGetScore(sptr);

      if (s > score) {
          /* First element with score larger than score for element to be
           * inserted. This means we should take its spot in the list to
           * maintain ordering. */
          zl = zzlInsertAt(zl,eptr,ele,score);
          break;
      } else if (s == score) {
          /* Ensure lexicographical ordering for elements. */
          if (zzlCompareElements(eptr,(unsigned char*)ele,sdslen(ele)) > 0) {
              zl = zzlInsertAt(zl,eptr,ele,score);
              break;
          }
      }

      /* Move to next element. */
      eptr = ziplistNext(zl,sptr);
  }

  /* Push on tail of list when it was not yet inserted. */
  if (eptr == NULL((void*)0))
      zl = zzlInsertAt(zl,NULL((void*)0),ele,score);
  return zl;
1093}

1095unsigned char *zzlDeleteRangeByScore(unsigned char *zl, zrangespec *range, unsigned long *deleted) {
  unsigned char *eptr, *sptr;
  double score;
  unsigned long num = 0;

  if (deleted != NULL((void*)0)) *deleted = 0;

  eptr = zzlFirstInRange(zl,range);
  if (eptr == NULL((void*)0)) return zl;

  /* When the tail of the ziplist is deleted, eptr will point to the sentinel
   * byte and ziplistNext will return NULL. */
  while ((sptr = ziplistNext(zl,eptr)) != NULL((void*)0)) {
      score = zzlGetScore(sptr);
      if (zslValueLteMax(score,range)) {
          /* Delete both the element and the score. */
          zl = ziplistDelete(zl,&eptr);
          zl = ziplistDelete(zl,&eptr);
          num++;
      } else {
          /* No longer in range. */
          break;
      }
  }

  if (deleted != NULL((void*)0)) *deleted = num;
  return zl;
1122}

1124unsigned char *zzlDeleteRangeByLex(unsigned char *zl, zlexrangespec *range, unsigned long *deleted) {
  unsigned char *eptr, *sptr;
  unsigned long num = 0;

  if (deleted != NULL((void*)0)) *deleted = 0;

  eptr = zzlFirstInLexRange(zl,range);
  if (eptr == NULL((void*)0)) return zl;

  /* When the tail of the ziplist is deleted, eptr will point to the sentinel
   * byte and ziplistNext will return NULL. */
  while ((sptr = ziplistNext(zl,eptr)) != NULL((void*)0)) {
      if (zzlLexValueLteMax(eptr,range)) {
          /* Delete both the element and the score. */
          zl = ziplistDelete(zl,&eptr);
          zl = ziplistDelete(zl,&eptr);
          num++;
      } else {
          /* No longer in range. */
          break;
      }
  }

  if (deleted != NULL((void*)0)) *deleted = num;
  return zl;
1149}

1151/* Delete all the elements with rank between start and end from the skiplist.
* Start and end are inclusive. Note that start and end need to be 1-based */
1153unsigned char *zzlDeleteRangeByRank(unsigned char *zl, unsigned int start, unsigned int end, unsigned long *deleted) {
  unsigned int num = (end-start)+1;
  if (deleted) *deleted = num;
  zl = ziplistDeleteRange(zl,2*(start-1),2*num);
  return zl;
1158}

1160/*-----------------------------------------------------------------------------
* Common sorted set API
*----------------------------------------------------------------------------*/

1164unsigned long zsetLength(const robj *zobj) {
  unsigned long length = 0;
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      length = zzlLength(zobj->ptr);
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      length = ((const zset*)zobj->ptr)->zsl->length;
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1171,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
  return length;
1174}

1176void zsetConvert(robj *zobj, int encoding) {
  zset *zs;
  zskiplistNode *node, *next;
  sds ele;
  double score;

  if (zobj->encoding == encoding) return;
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;
      unsigned char *vstr;
      unsigned int vlen;
      long long vlong;

      if (encoding != OBJ_ENCODING_SKIPLIST7)
          serverPanic("Unknown target encoding")_serverPanic("t_zset.c",1191,"Unknown target encoding"),__builtin_unreachable
();

      zs = zmalloc(sizeof(*zs));
      zs->dict = dictCreate(&zsetDictType,NULL((void*)0));
      zs->zsl = zslCreate();

      eptr = ziplistIndex(zl,0);
      serverAssertWithInfo(NULL,zobj,eptr != NULL)((eptr != ((void*)0))?(void)0 : (_serverAssertWithInfo(((void
*)0),zobj,"eptr != NULL","t_zset.c",1198),__builtin_unreachable
()));
      sptr = ziplistNext(zl,eptr);
      serverAssertWithInfo(NULL,zobj,sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssertWithInfo(((void
*)0),zobj,"sptr != NULL","t_zset.c",1200),__builtin_unreachable
()));

      while (eptr != NULL((void*)0)) {
          score = zzlGetScore(sptr);
          serverAssertWithInfo(NULL,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssertWithInfo(((void*)0),zobj,"ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",1204),__builtin_unreachable()));
          if (vstr == NULL((void*)0))
              ele = sdsfromlonglong(vlong);
          else
              ele = sdsnewlen((char*)vstr,vlen);

          node = zslInsert(zs->zsl,score,ele);
          serverAssert(dictAdd(zs->dict,ele,&node->score) == DICT_OK)((dictAdd(zs->dict,ele,&node->score) == 0)?(void)0 :
 (_serverAssert("dictAdd(zs->dict,ele,&node->score) == DICT_OK"
,"t_zset.c",1211),__builtin_unreachable()));
          zzlNext(zl,&eptr,&sptr);
      }

      zfree(zobj->ptr);
      zobj->ptr = zs;
      zobj->encoding = OBJ_ENCODING_SKIPLIST7;
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      unsigned char *zl = ziplistNew();

      if (encoding != OBJ_ENCODING_ZIPLIST5)
          serverPanic("Unknown target encoding")_serverPanic("t_zset.c",1222,"Unknown target encoding"),__builtin_unreachable
();

      /* Approach similar to zslFree(), since we want to free the skiplist at
       * the same time as creating the ziplist. */
      zs = zobj->ptr;
      dictRelease(zs->dict);
      node = zs->zsl->header->level[0].forward;
      zfree(zs->zsl->header);
      zfree(zs->zsl);

      while (node) {
          zl = zzlInsertAt(zl,NULL((void*)0),node->ele,node->score);
          next = node->level[0].forward;
          zslFreeNode(node);
          node = next;
      }

      zfree(zs);
      zobj->ptr = zl;
      zobj->encoding = OBJ_ENCODING_ZIPLIST5;
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1243,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
1245}

1247/* Convert the sorted set object into a ziplist if it is not already a ziplist
* and if the number of elements and the maximum element size is within the
* expected ranges. */
1250void zsetConvertToZiplistIfNeeded(robj *zobj, size_t maxelelen) {
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) return;
  zset *zset = zobj->ptr;

  if (zset->zsl->length <= server.zset_max_ziplist_entries &&
      maxelelen <= server.zset_max_ziplist_value)
          zsetConvert(zobj,OBJ_ENCODING_ZIPLIST5);
1257}

1259/* Return (by reference) the score of the specified member of the sorted set
* storing it into *score. If the element does not exist C_ERR is returned
* otherwise C_OK is returned and *score is correctly populated.
* If 'zobj' or 'member' is NULL, C_ERR is returned. */
1263int zsetScore(robj *zobj, sds member, double *score) {
  if (!zobj || !member) return C_ERR-1;

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      if (zzlFind(zobj->ptr, member, score) == NULL((void*)0)) return C_ERR-1;
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      dictEntry *de = dictFind(zs->dict, member);
      if (de == NULL((void*)0)) return C_ERR-1;
      *score = *(double*)dictGetVal(de)((de)->v.val);
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1274,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
  return C_OK0;
1277}

1279/* Add a new element or update the score of an existing element in a sorted
* set, regardless of its encoding.
*
* The set of flags change the command behavior. They are passed with an integer
* pointer since the function will clear the flags and populate them with
* other flags to indicate different conditions.
*
* The input flags are the following:
*
* ZADD_INCR: Increment the current element score by 'score' instead of updating
*            the current element score. If the element does not exist, we
*            assume 0 as previous score.
* ZADD_NX:   Perform the operation only if the element does not exist.
* ZADD_XX:   Perform the operation only if the element already exist.
* ZADD_GT:   Perform the operation on existing elements only if the new score is 
*            greater than the current score.
* ZADD_LT:   Perform the operation on existing elements only if the new score is 
*            less than the current score.
*
* When ZADD_INCR is used, the new score of the element is stored in
* '*newscore' if 'newscore' is not NULL.
*
* The returned flags are the following:
*
* ZADD_NAN:     The resulting score is not a number.
* ZADD_ADDED:   The element was added (not present before the call).
* ZADD_UPDATED: The element score was updated.
* ZADD_NOP:     No operation was performed because of NX or XX.
*
* Return value:
*
* The function returns 1 on success, and sets the appropriate flags
* ADDED or UPDATED to signal what happened during the operation (note that
* none could be set if we re-added an element using the same score it used
* to have, or in the case a zero increment is used).
*
* The function returns 0 on error, currently only when the increment
* produces a NAN condition, or when the 'score' value is NAN since the
* start.
*
* The command as a side effect of adding a new element may convert the sorted
* set internal encoding from ziplist to hashtable+skiplist.
*
* Memory management of 'ele':
*
* The function does not take ownership of the 'ele' SDS string, but copies
* it if needed. */
1326int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
  /* Turn options into simple to check vars. */
  int incr = (*flags & ZADD_INCR(1<<0)) != 0;
  int nx = (*flags & ZADD_NX(1<<1)) != 0;
  int xx = (*flags & ZADD_XX(1<<2)) != 0;
  int gt = (*flags & ZADD_GT(1<<7)) != 0;
  int lt = (*flags & ZADD_LT(1<<8)) != 0;
  *flags = 0; /* We'll return our response flags. */
  double curscore;

  /* NaN as input is an error regardless of all the other parameters. */
  if (isnan(score)__builtin_isnan (score)) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
      *flags = ZADD_NAN(1<<4);
      return 0;
  }

  /* Update the sorted set according to its encoding. */
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
4
←
Assuming field 'encoding' is not equal to OBJ_ENCODING_ZIPLIST→
5
←
Taking false branch→
      unsigned char *eptr;

      if ((eptr = zzlFind(zobj->ptr,ele,&curscore)) != NULL((void*)0)) {
          /* NX? Return, same element already exists. */
          if (nx) {
              *flags |= ZADD_NOP(1<<3);
              return 1;
          }

          /* Prepare the score for the increment if needed. */
          if (incr) {
              score += curscore;
              if (isnan(score)__builtin_isnan (score)) {
                  *flags |= ZADD_NAN(1<<4);
                  return 0;
              }
              if (newscore) *newscore = score;
          }

          /* Remove and re-insert when score changed. */
          if (score != curscore &&  
              /* LT? Only update if score is less than current. */
              (!lt || score < curscore) &&
              /* GT? Only update if score is greater than current. */
              (!gt || score > curscore)) 
          {
              zobj->ptr = zzlDelete(zobj->ptr,eptr);
              zobj->ptr = zzlInsert(zobj->ptr,ele,score);
              *flags |= ZADD_UPDATED(1<<6);
          }
          return 1;
      } else if (!xx) {
          /* Optimize: check if the element is too large or the list
           * becomes too long *before* executing zzlInsert. */
          zobj->ptr = zzlInsert(zobj->ptr,ele,score);
          if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries ||
              sdslen(ele) > server.zset_max_ziplist_value)
              zsetConvert(zobj,OBJ_ENCODING_SKIPLIST7);
          if (newscore) *newscore = score;
          *flags |= ZADD_ADDED(1<<5);
          return 1;
      } else {
          *flags |= ZADD_NOP(1<<3);
          return 1;
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
6
←
Assuming field 'encoding' is equal to OBJ_ENCODING_SKIPLIST→
7
←
Taking true branch→
      zset *zs = zobj->ptr;
      zskiplistNode *znode;
      dictEntry *de;

      de = dictFind(zs->dict,ele);
      if (de != NULL((void*)0)) {
8
←
Assuming 'de' is equal to NULL→
9
←
Taking false branch→
          /* NX? Return, same element already exists. */
          if (nx) {
              *flags |= ZADD_NOP(1<<3);
              return 1;
          }
          curscore = *(double*)dictGetVal(de)((de)->v.val);

          /* Prepare the score for the increment if needed. */
          if (incr) {
              score += curscore;
              if (isnan(score)__builtin_isnan (score)) {
                  *flags |= ZADD_NAN(1<<4);
                  return 0;
              }
              if (newscore) *newscore = score;
          }

          /* Remove and re-insert when score changes. */
          if (score != curscore &&  
              /* LT? Only update if score is less than current. */
              (!lt || score < curscore) &&
              /* GT? Only update if score is greater than current. */
              (!gt || score > curscore)) 
          {
              znode = zslUpdateScore(zs->zsl,curscore,ele,score);
              /* Note that we did not removed the original element from
               * the hash table representing the sorted set, so we just
               * update the score. */
              dictGetVal(de)((de)->v.val) = &znode->score; /* Update score ptr. */
              *flags |= ZADD_UPDATED(1<<6);
          }
          return 1;
      } else if (!xx9.1
'xx' is 0
) {
10
←
Taking true branch→
          ele = sdsdup(ele);
          znode = zslInsert(zs->zsl,score,ele);
11
←
Calling 'zslInsert'→
          serverAssert(dictAdd(zs->dict,ele,&znode->score) == DICT_OK)((dictAdd(zs->dict,ele,&znode->score) == 0)?(void)0
 : (_serverAssert("dictAdd(zs->dict,ele,&znode->score) == DICT_OK"
,"t_zset.c",1431),__builtin_unreachable()));
          *flags |= ZADD_ADDED(1<<5);
          if (newscore) *newscore = score;
          return 1;
      } else {
          *flags |= ZADD_NOP(1<<3);
          return 1;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1440,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
  return 0; /* Never reached. */
1443}

1445/* Deletes the element 'ele' from the sorted set encoded as a skiplist+dict,
* returning 1 if the element existed and was deleted, 0 otherwise (the
* element was not there). It does not resize the dict after deleting the
* element. */
1449static int zsetRemoveFromSkiplist(zset *zs, sds ele) {
  dictEntry *de;
  double score;

  de = dictUnlink(zs->dict,ele);
  if (de != NULL((void*)0)) {
      /* Get the score in order to delete from the skiplist later. */
      score = *(double*)dictGetVal(de)((de)->v.val);

      /* Delete from the hash table and later from the skiplist.
       * Note that the order is important: deleting from the skiplist
       * actually releases the SDS string representing the element,
       * which is shared between the skiplist and the hash table, so
       * we need to delete from the skiplist as the final step. */
      dictFreeUnlinkedEntry(zs->dict,de);

      /* Delete from skiplist. */
      int retval = zslDelete(zs->zsl,score,ele,NULL((void*)0));
      serverAssert(retval)((retval)?(void)0 : (_serverAssert("retval","t_zset.c",1467),
__builtin_unreachable()));

      return 1;
  }

  return 0;
1473}

1475/* Delete the element 'ele' from the sorted set, returning 1 if the element
* existed and was deleted, 0 otherwise (the element was not there). */
1477int zsetDel(robj *zobj, sds ele) {
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *eptr;

      if ((eptr = zzlFind(zobj->ptr,ele,NULL((void*)0))) != NULL((void*)0)) {
          zobj->ptr = zzlDelete(zobj->ptr,eptr);
          return 1;
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      if (zsetRemoveFromSkiplist(zs, ele)) {
          if (htNeedsResize(zs->dict)) dictResize(zs->dict);
          return 1;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1492,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
  return 0; /* No such element found. */
1495}

1497/* Given a sorted set object returns the 0-based rank of the object or
* -1 if the object does not exist.
*
* For rank we mean the position of the element in the sorted collection
* of elements. So the first element has rank 0, the second rank 1, and so
* forth up to length-1 elements.
*
* If 'reverse' is false, the rank is returned considering as first element
* the one with the lowest score. Otherwise if 'reverse' is non-zero
* the rank is computed considering as element with rank 0 the one with
* the highest score. */
1508long zsetRank(robj *zobj, sds ele, int reverse) {
  unsigned long llen;
  unsigned long rank;

  llen = zsetLength(zobj);

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;

      eptr = ziplistIndex(zl,0);
      serverAssert(eptr != NULL)((eptr != ((void*)0))?(void)0 : (_serverAssert("eptr != NULL"
,"t_zset.c",1519),__builtin_unreachable()));
      sptr = ziplistNext(zl,eptr);
      serverAssert(sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssert("sptr != NULL"
,"t_zset.c",1521),__builtin_unreachable()));

      rank = 1;
      while(eptr != NULL((void*)0)) {
          if (ziplistCompare(eptr,(unsigned char*)ele,sdslen(ele)))
              break;
          rank++;
          zzlNext(zl,&eptr,&sptr);
      }

      if (eptr != NULL((void*)0)) {
          if (reverse)
              return llen-rank;
          else
              return rank-1;
      } else {
          return -1;
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      dictEntry *de;
      double score;

      de = dictFind(zs->dict,ele);
      if (de != NULL((void*)0)) {
          score = *(double*)dictGetVal(de)((de)->v.val);
          rank = zslGetRank(zsl,score,ele);
          /* Existing elements always have a rank. */
          serverAssert(rank != 0)((rank != 0)?(void)0 : (_serverAssert("rank != 0","t_zset.c",
1550),__builtin_unreachable()));
          if (reverse)
              return llen-rank;
          else
              return rank-1;
      } else {
          return -1;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1559,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
1561}

1563/* This is a helper function for the COPY command.
* Duplicate a sorted set object, with the guarantee that the returned object
* has the same encoding as the original one.
*
* The resulting object always has refcount set to 1 */
1568robj *zsetDup(robj *o) {
  robj *zobj;
  zset *zs;
  zset *new_zs;

  serverAssert(o->type == OBJ_ZSET)((o->type == 3)?(void)0 : (_serverAssert("o->type == OBJ_ZSET"
,"t_zset.c",1573),__builtin_unreachable()));

  /* Create a new sorted set object that have the same encoding as the original object's encoding */
  if (o->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = o->ptr;
      size_t sz = ziplistBlobLen(zl);
      unsigned char *new_zl = zmalloc(sz);
      memcpy(new_zl, zl, sz);
      zobj = createObject(OBJ_ZSET3, new_zl);
      zobj->encoding = OBJ_ENCODING_ZIPLIST5;
  } else if (o->encoding == OBJ_ENCODING_SKIPLIST7) {
      zobj = createZsetObject();
      zs = o->ptr;
      new_zs = zobj->ptr;
      dictExpand(new_zs->dict,dictSize(zs->dict)((zs->dict)->ht[0].used+(zs->dict)->ht[1].used));
      zskiplist *zsl = zs->zsl;
      zskiplistNode *ln;
      sds ele;
      long llen = zsetLength(o);

      /* We copy the skiplist elements from the greatest to the
       * smallest (that's trivial since the elements are already ordered in
       * the skiplist): this improves the load process, since the next loaded
       * element will always be the smaller, so adding to the skiplist
       * will always immediately stop at the head, making the insertion
       * O(1) instead of O(log(N)). */
      ln = zsl->tail;
      while (llen--) {
          ele = ln->ele;
          sds new_ele = sdsdup(ele);
          zskiplistNode *znode = zslInsert(new_zs->zsl,ln->score,new_ele);
          dictAdd(new_zs->dict,new_ele,&znode->score);
          ln = ln->backward;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1608,"Unknown sorted set encoding"),__builtin_unreachable
();
  }
  return zobj;
1611}

1613/* callback for to check the ziplist doesn't have duplicate recoreds */
1614static int _zsetZiplistValidateIntegrity(unsigned char *p, void *userdata) {
  struct {
      long count;
      dict *fields;
  } *data = userdata;

  /* Even records are field names, add to dict and check that's not a dup */
  if (((data->count) & 1) == 0) {
      unsigned char *str;
      unsigned int slen;
      long long vll;
      if (!ziplistGet(p, &str, &slen, &vll))
          return 0;
      sds field = str? sdsnewlen(str, slen): sdsfromlonglong(vll);;
      if (dictAdd(data->fields, field, NULL((void*)0)) != DICT_OK0) {
          /* Duplicate, return an error */
          sdsfree(field);
          return 0;
      }
  }

  (data->count)++;
  return 1;
1637}

1639/* Validate the integrity of the data stracture.
* when `deep` is 0, only the integrity of the header is validated.
* when `deep` is 1, we scan all the entries one by one. */
1642int zsetZiplistValidateIntegrity(unsigned char *zl, size_t size, int deep) {
  if (!deep)
      return ziplistValidateIntegrity(zl, size, 0, NULL((void*)0), NULL((void*)0));

  /* Keep track of the field names to locate duplicate ones */
  struct {
      long count;
      dict *fields;
  } data = {0, dictCreate(&hashDictType, NULL((void*)0))};

  int ret = ziplistValidateIntegrity(zl, size, 1, _zsetZiplistValidateIntegrity, &data);

  /* make sure we have an even number of records. */
  if (data.count & 1)
      ret = 0;

  dictRelease(data.fields);
  return ret;
1660}

1662/* Create a new sds string from the ziplist entry. */
1663sds zsetSdsFromZiplistEntry(ziplistEntry *e) {
  return e->sval ? sdsnewlen(e->sval, e->slen) : sdsfromlonglong(e->lval);
1665}

1667/* Reply with bulk string from the ziplist entry. */
1668void zsetReplyFromZiplistEntry(client *c, ziplistEntry *e) {
  if (e->sval)
      addReplyBulkCBuffer(c, e->sval, e->slen);
  else
      addReplyBulkLongLong(c, e->lval);
1673}


1676/* Return random element from a non empty zset.
* 'key' and 'val' will be set to hold the element.
* The memory in `key` is not to be freed or modified by the caller.
* 'score' can be NULL in which case it's not extracted. */
1680void zsetTypeRandomElement(robj *zsetobj, unsigned long zsetsize, ziplistEntry *key, double *score) {
  if (zsetobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zsetobj->ptr;
      dictEntry *de = dictGetFairRandomKey(zs->dict);
      sds s = dictGetKey(de)((de)->key);
      key->sval = (unsigned char*)s;
      key->slen = sdslen(s);
      if (score)
          *score = *(double*)dictGetVal(de)((de)->v.val);
  } else if (zsetobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      ziplistEntry val;
      ziplistRandomPair(zsetobj->ptr, zsetsize, key, &val);
      if (score) {
          if (val.sval) {
              *score = zzlStrtod(val.sval,val.slen);
          } else {
              *score = (double)val.lval;
          }
      }
  } else {
      serverPanic("Unknown zset encoding")_serverPanic("t_zset.c",1700,"Unknown zset encoding"),__builtin_unreachable
();
  }
1702}

1704/*-----------------------------------------------------------------------------
* Sorted set commands
*----------------------------------------------------------------------------*/

1708/* This generic command implements both ZADD and ZINCRBY. */
1709void zaddGenericCommand(client *c, int flags) {
  static char *nanerr = "resulting score is not a number (NaN)";
  robj *key = c->argv[1];
  robj *zobj;
  sds ele;
  double score = 0, *scores = NULL((void*)0);
  int j, elements;
  int scoreidx = 0;
  /* The following vars are used in order to track what the command actually
   * did during the execution, to reply to the client and to trigger the
   * notification of keyspace change. */
  int added = 0;      /* Number of new elements added. */
  int updated = 0;    /* Number of elements with updated score. */
  int processed = 0;  /* Number of elements processed, may remain zero with
                         options like XX. */

  /* Parse options. At the end 'scoreidx' is set to the argument position
   * of the score of the first score-element pair. */
  scoreidx = 2;
  while(scoreidx < c->argc) {
      char *opt = c->argv[scoreidx]->ptr;
      if (!strcasecmp(opt,"nx")) flags |= ZADD_NX(1<<1);
      else if (!strcasecmp(opt,"xx")) flags |= ZADD_XX(1<<2);
      else if (!strcasecmp(opt,"ch")) flags |= ZADD_CH(1<<16);
      else if (!strcasecmp(opt,"incr")) flags |= ZADD_INCR(1<<0);
      else if (!strcasecmp(opt,"gt")) flags |= ZADD_GT(1<<7);
      else if (!strcasecmp(opt,"lt")) flags |= ZADD_LT(1<<8);
      else break;
      scoreidx++;
  }

  /* Turn options into simple to check vars. */
  int incr = (flags & ZADD_INCR(1<<0)) != 0;
  int nx = (flags & ZADD_NX(1<<1)) != 0;
  int xx = (flags & ZADD_XX(1<<2)) != 0;
  int ch = (flags & ZADD_CH(1<<16)) != 0;
  int gt = (flags & ZADD_GT(1<<7)) != 0;
  int lt = (flags & ZADD_LT(1<<8)) != 0;

  /* After the options, we expect to have an even number of args, since
   * we expect any number of score-element pairs. */
  elements = c->argc-scoreidx;
  if (elements % 2 || !elements) {
      addReplyErrorObject(c,shared.syntaxerr);
      return;
  }
  elements /= 2; /* Now this holds the number of score-element pairs. */

  /* Check for incompatible options. */
  if (nx && xx) {
      addReplyError(c,
          "XX and NX options at the same time are not compatible");
      return;
  }
  
  if ((gt && nx) || (lt && nx) || (gt && lt)) {
      addReplyError(c,
          "GT, LT, and/or NX options at the same time are not compatible");
      return;
  }
  /* Note that XX is compatible with either GT or LT */

  if (incr && elements > 1) {
      addReplyError(c,
          "INCR option supports a single increment-element pair");
      return;
  }

  /* Start parsing all the scores, we need to emit any syntax error
   * before executing additions to the sorted set, as the command should
   * either execute fully or nothing at all. */
  scores = zmalloc(sizeof(double)*elements);
  for (j = 0; j < elements; j++) {
      if (getDoubleFromObjectOrReply(c,c->argv[scoreidx+j*2],&scores[j],NULL((void*)0))
          != C_OK0) goto cleanup;
  }

  /* Lookup the key and create the sorted set if does not exist. */
  zobj = lookupKeyWrite(c->db,key);
  if (checkType(c,zobj,OBJ_ZSET3)) goto cleanup;
  if (zobj == NULL((void*)0)) {
      if (xx) goto reply_to_client; /* No key + XX option: nothing to do. */
      if (server.zset_max_ziplist_entries == 0 ||
          server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+1]->ptr))
      {
          zobj = createZsetObject();
      } else {
          zobj = createZsetZiplistObject();
      }
      dbAdd(c->db,key,zobj);
  }

  for (j = 0; j < elements; j++) {
      double newscore;
      score = scores[j];
      int retflags = flags;

      ele = c->argv[scoreidx+1+j*2]->ptr;
      int retval = zsetAdd(zobj, score, ele, &retflags, &newscore);
      if (retval == 0) {
          addReplyError(c,nanerr);
          goto cleanup;
      }
      if (retflags & ZADD_ADDED(1<<5)) added++;
      if (retflags & ZADD_UPDATED(1<<6)) updated++;
      if (!(retflags & ZADD_NOP(1<<3))) processed++;
      score = newscore;
  }
  server.dirty += (added+updated);

1819reply_to_client:
  if (incr) { /* ZINCRBY or INCR option. */
      if (processed)
          addReplyDouble(c,score);
      else
          addReplyNull(c);
  } else { /* ZADD. */
      addReplyLongLong(c,ch ? added+updated : added);
  }

1829cleanup:
  zfree(scores);
  if (added || updated) {
      signalModifiedKey(c,c->db,key);
      notifyKeyspaceEvent(NOTIFY_ZSET(1<<7),
          incr ? "zincr" : "zadd", key, c->db->id);
  }
1836}

1838void zaddCommand(client *c) {
  zaddGenericCommand(c,ZADD_NONE0);
1840}

1842void zincrbyCommand(client *c) {
  zaddGenericCommand(c,ZADD_INCR(1<<0));
1844}

1846void zremCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;
  int deleted = 0, keyremoved = 0, j;

  if ((zobj = lookupKeyWriteOrReply(c,key,shared.czero)) == NULL((void*)0) ||
      checkType(c,zobj,OBJ_ZSET3)) return;

  for (j = 2; j < c->argc; j++) {
      if (zsetDel(zobj,c->argv[j]->ptr)) deleted++;
      if (zsetLength(zobj) == 0) {
          dbDelete(c->db,key);
          keyremoved = 1;
          break;
      }
  }

  if (deleted) {
      notifyKeyspaceEvent(NOTIFY_ZSET(1<<7),"zrem",key,c->db->id);
      if (keyremoved)
          notifyKeyspaceEvent(NOTIFY_GENERIC(1<<2),"del",key,c->db->id);
      signalModifiedKey(c,c->db,key);
      server.dirty += deleted;
  }
  addReplyLongLong(c,deleted);
1871}

1873typedef enum {
  ZRANGE_AUTO = 0,
  ZRANGE_RANK,
  ZRANGE_SCORE,
  ZRANGE_LEX,
1878} zrange_type;

1880/* Implements ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZREMRANGEBYLEX commands. */
1881void zremrangeGenericCommand(client *c, zrange_type rangetype) {
  robj *key = c->argv[1];
  robj *zobj;
  int keyremoved = 0;
  unsigned long deleted = 0;
  zrangespec range;
  zlexrangespec lexrange;
  long start, end, llen;
  char *notify_type = NULL((void*)0);

  /* Step 1: Parse the range. */
  if (rangetype == ZRANGE_RANK) {
      notify_type = "zremrangebyrank";
      if ((getLongFromObjectOrReply(c,c->argv[2],&start,NULL((void*)0)) != C_OK0) ||
          (getLongFromObjectOrReply(c,c->argv[3],&end,NULL((void*)0)) != C_OK0))
          return;
  } else if (rangetype == ZRANGE_SCORE) {
      notify_type = "zremrangebyscore";
      if (zslParseRange(c->argv[2],c->argv[3],&range) != C_OK0) {
          addReplyError(c,"min or max is not a float");
          return;
      }
  } else if (rangetype == ZRANGE_LEX) {
      notify_type = "zremrangebylex";
      if (zslParseLexRange(c->argv[2],c->argv[3],&lexrange) != C_OK0) {
          addReplyError(c,"min or max not valid string range item");
          return;
      }
  } else {
      serverPanic("unknown rangetype %d", (int)rangetype)_serverPanic("t_zset.c",1910,"unknown rangetype %d", (int)rangetype
),__builtin_unreachable();
  }

  /* Step 2: Lookup & range sanity checks if needed. */
  if ((zobj = lookupKeyWriteOrReply(c,key,shared.czero)) == NULL((void*)0) ||
      checkType(c,zobj,OBJ_ZSET3)) goto cleanup;

  if (rangetype == ZRANGE_RANK) {
      /* Sanitize indexes. */
      llen = zsetLength(zobj);
      if (start < 0) start = llen+start;
      if (end < 0) end = llen+end;
      if (start < 0) start = 0;

      /* Invariant: start >= 0, so this test will be true when end < 0.
       * The range is empty when start > end or start >= length. */
      if (start > end || start >= llen) {
          addReply(c,shared.czero);
          goto cleanup;
      }
      if (end >= llen) end = llen-1;
  }

  /* Step 3: Perform the range deletion operation. */
  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      switch(rangetype) {
      case ZRANGE_AUTO:
      case ZRANGE_RANK:
          zobj->ptr = zzlDeleteRangeByRank(zobj->ptr,start+1,end+1,&deleted);
          break;
      case ZRANGE_SCORE:
          zobj->ptr = zzlDeleteRangeByScore(zobj->ptr,&range,&deleted);
          break;
      case ZRANGE_LEX:
          zobj->ptr = zzlDeleteRangeByLex(zobj->ptr,&lexrange,&deleted);
          break;
      }
      if (zzlLength(zobj->ptr) == 0) {
          dbDelete(c->db,key);
          keyremoved = 1;
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      switch(rangetype) {
      case ZRANGE_AUTO:
      case ZRANGE_RANK:
          deleted = zslDeleteRangeByRank(zs->zsl,start+1,end+1,zs->dict);
          break;
      case ZRANGE_SCORE:
          deleted = zslDeleteRangeByScore(zs->zsl,&range,zs->dict);
          break;
      case ZRANGE_LEX:
          deleted = zslDeleteRangeByLex(zs->zsl,&lexrange,zs->dict);
          break;
      }
      if (htNeedsResize(zs->dict)) dictResize(zs->dict);
      if (dictSize(zs->dict)((zs->dict)->ht[0].used+(zs->dict)->ht[1].used) == 0) {
          dbDelete(c->db,key);
          keyremoved = 1;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",1971,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  /* Step 4: Notifications and reply. */
  if (deleted) {
      signalModifiedKey(c,c->db,key);
      notifyKeyspaceEvent(NOTIFY_ZSET(1<<7),notify_type,key,c->db->id);
      if (keyremoved)
          notifyKeyspaceEvent(NOTIFY_GENERIC(1<<2),"del",key,c->db->id);
  }
  server.dirty += deleted;
  addReplyLongLong(c,deleted);

1984cleanup:
  if (rangetype == ZRANGE_LEX) zslFreeLexRange(&lexrange);
1986}

1988void zremrangebyrankCommand(client *c) {
  zremrangeGenericCommand(c,ZRANGE_RANK);
1990}

1992void zremrangebyscoreCommand(client *c) {
  zremrangeGenericCommand(c,ZRANGE_SCORE);
1994}

1996void zremrangebylexCommand(client *c) {
  zremrangeGenericCommand(c,ZRANGE_LEX);
1998}

2000typedef struct {
  robj *subject;
  int type; /* Set, sorted set */
  int encoding;
  double weight;

  union {
      /* Set iterators. */
      union _iterset {
          struct {
              intset *is;
              int ii;
          } is;
          struct {
              dict *dict;
              dictIterator *di;
              dictEntry *de;
          } ht;
      } set;

      /* Sorted set iterators. */
      union _iterzset {
          struct {
              unsigned char *zl;
              unsigned char *eptr, *sptr;
          } zl;
          struct {
              zset *zs;
              zskiplistNode *node;
          } sl;
      } zset;
  } iter;
2032} zsetopsrc;


2035/* Use dirty flags for pointers that need to be cleaned up in the next
* iteration over the zsetopval. The dirty flag for the long long value is
* special, since long long values don't need cleanup. Instead, it means that
* we already checked that "ell" holds a long long, or tried to convert another
* representation into a long long value. When this was successful,
* OPVAL_VALID_LL is set as well. */
2041#define OPVAL_DIRTY_SDS1 1
2042#define OPVAL_DIRTY_LL2 2
2043#define OPVAL_VALID_LL4 4

2045/* Store value retrieved from the iterator. */
2046typedef struct {
  int flags;
  unsigned char _buf[32]; /* Private buffer. */
  sds ele;
  unsigned char *estr;
  unsigned int elen;
  long long ell;
  double score;
2054} zsetopval;

2056typedef union _iterset iterset;
2057typedef union _iterzset iterzset;

2059void zuiInitIterator(zsetopsrc *op) {
  if (op->subject == NULL((void*)0))
      return;

  if (op->type == OBJ_SET2) {
      iterset *it = &op->iter.set;
      if (op->encoding == OBJ_ENCODING_INTSET6) {
          it->is.is = op->subject->ptr;
          it->is.ii = 0;
      } else if (op->encoding == OBJ_ENCODING_HT2) {
          it->ht.dict = op->subject->ptr;
          it->ht.di = dictGetIterator(op->subject->ptr);
          it->ht.de = dictNext(it->ht.di);
      } else {
          serverPanic("Unknown set encoding")_serverPanic("t_zset.c",2073,"Unknown set encoding"),__builtin_unreachable
();
      }
  } else if (op->type == OBJ_ZSET3) {
      /* Sorted sets are traversed in reverse order to optimize for
       * the insertion of the elements in a new list as in
       * ZDIFF/ZINTER/ZUNION */
      iterzset *it = &op->iter.zset;
      if (op->encoding == OBJ_ENCODING_ZIPLIST5) {
          it->zl.zl = op->subject->ptr;
          it->zl.eptr = ziplistIndex(it->zl.zl,-2);
          if (it->zl.eptr != NULL((void*)0)) {
              it->zl.sptr = ziplistNext(it->zl.zl,it->zl.eptr);
              serverAssert(it->zl.sptr != NULL)((it->zl.sptr != ((void*)0))?(void)0 : (_serverAssert("it->zl.sptr != NULL"
,"t_zset.c",2085),__builtin_unreachable()));
          }
      } else if (op->encoding == OBJ_ENCODING_SKIPLIST7) {
          it->sl.zs = op->subject->ptr;
          it->sl.node = it->sl.zs->zsl->tail;
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",2091,"Unknown sorted set encoding"),__builtin_unreachable
();
      }
  } else {
      serverPanic("Unsupported type")_serverPanic("t_zset.c",2094,"Unsupported type"),__builtin_unreachable
();
  }
2096}

2098void zuiClearIterator(zsetopsrc *op) {
  if (op->subject == NULL((void*)0))
      return;

  if (op->type == OBJ_SET2) {
      iterset *it = &op->iter.set;
      if (op->encoding == OBJ_ENCODING_INTSET6) {
          UNUSED(it)((void) it); /* skip */
      } else if (op->encoding == OBJ_ENCODING_HT2) {
          dictReleaseIterator(it->ht.di);
      } else {
          serverPanic("Unknown set encoding")_serverPanic("t_zset.c",2109,"Unknown set encoding"),__builtin_unreachable
();
      }
  } else if (op->type == OBJ_ZSET3) {
      iterzset *it = &op->iter.zset;
      if (op->encoding == OBJ_ENCODING_ZIPLIST5) {
          UNUSED(it)((void) it); /* skip */
      } else if (op->encoding == OBJ_ENCODING_SKIPLIST7) {
          UNUSED(it)((void) it); /* skip */
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",2118,"Unknown sorted set encoding"),__builtin_unreachable
();
      }
  } else {
      serverPanic("Unsupported type")_serverPanic("t_zset.c",2121,"Unsupported type"),__builtin_unreachable
();
  }
2123}

2125unsigned long zuiLength(zsetopsrc *op) {
  if (op->subject == NULL((void*)0))
      return 0;

  if (op->type == OBJ_SET2) {
      if (op->encoding == OBJ_ENCODING_INTSET6) {
          return intsetLen(op->subject->ptr);
      } else if (op->encoding == OBJ_ENCODING_HT2) {
          dict *ht = op->subject->ptr;
          return dictSize(ht)((ht)->ht[0].used+(ht)->ht[1].used);
      } else {
          serverPanic("Unknown set encoding")_serverPanic("t_zset.c",2136,"Unknown set encoding"),__builtin_unreachable
();
      }
  } else if (op->type == OBJ_ZSET3) {
      if (op->encoding == OBJ_ENCODING_ZIPLIST5) {
          return zzlLength(op->subject->ptr);
      } else if (op->encoding == OBJ_ENCODING_SKIPLIST7) {
          zset *zs = op->subject->ptr;
          return zs->zsl->length;
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",2145,"Unknown sorted set encoding"),__builtin_unreachable
();
      }
  } else {
      serverPanic("Unsupported type")_serverPanic("t_zset.c",2148,"Unsupported type"),__builtin_unreachable
();
  }
2150}

2152/* Check if the current value is valid. If so, store it in the passed structure
* and move to the next element. If not valid, this means we have reached the
* end of the structure and can abort. */
2155int zuiNext(zsetopsrc *op, zsetopval *val) {
  if (op->subject == NULL((void*)0))
      return 0;

  if (val->flags & OPVAL_DIRTY_SDS1)
      sdsfree(val->ele);

  memset(val,0,sizeof(zsetopval));

  if (op->type == OBJ_SET2) {
      iterset *it = &op->iter.set;
      if (op->encoding == OBJ_ENCODING_INTSET6) {
          int64_t ell;

          if (!intsetGet(it->is.is,it->is.ii,&ell))
              return 0;
          val->ell = ell;
          val->score = 1.0;

          /* Move to next element. */
          it->is.ii++;
      } else if (op->encoding == OBJ_ENCODING_HT2) {
          if (it->ht.de == NULL((void*)0))
              return 0;
          val->ele = dictGetKey(it->ht.de)((it->ht.de)->key);
          val->score = 1.0;

          /* Move to next element. */
          it->ht.de = dictNext(it->ht.di);
      } else {
          serverPanic("Unknown set encoding")_serverPanic("t_zset.c",2185,"Unknown set encoding"),__builtin_unreachable
();
      }
  } else if (op->type == OBJ_ZSET3) {
      iterzset *it = &op->iter.zset;
      if (op->encoding == OBJ_ENCODING_ZIPLIST5) {
          /* No need to check both, but better be explicit. */
          if (it->zl.eptr == NULL((void*)0) || it->zl.sptr == NULL((void*)0))
              return 0;
          serverAssert(ziplistGet(it->zl.eptr,&val->estr,&val->elen,&val->ell))((ziplistGet(it->zl.eptr,&val->estr,&val->elen
,&val->ell))?(void)0 : (_serverAssert("ziplistGet(it->zl.eptr,&val->estr,&val->elen,&val->ell)"
,"t_zset.c",2193),__builtin_unreachable()));
          val->score = zzlGetScore(it->zl.sptr);

          /* Move to next element (going backwards, see zuiInitIterator). */
          zzlPrev(it->zl.zl,&it->zl.eptr,&it->zl.sptr);
      } else if (op->encoding == OBJ_ENCODING_SKIPLIST7) {
          if (it->sl.node == NULL((void*)0))
              return 0;
          val->ele = it->sl.node->ele;
          val->score = it->sl.node->score;

          /* Move to next element. (going backwards, see zuiInitIterator) */
          it->sl.node = it->sl.node->backward;
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",2207,"Unknown sorted set encoding"),__builtin_unreachable
();
      }
  } else {
      serverPanic("Unsupported type")_serverPanic("t_zset.c",2210,"Unsupported type"),__builtin_unreachable
();
  }
  return 1;
2213}

2215int zuiLongLongFromValue(zsetopval *val) {
  if (!(val->flags & OPVAL_DIRTY_LL2)) {
      val->flags |= OPVAL_DIRTY_LL2;

      if (val->ele != NULL((void*)0)) {
          if (string2ll(val->ele,sdslen(val->ele),&val->ell))
              val->flags |= OPVAL_VALID_LL4;
      } else if (val->estr != NULL((void*)0)) {
          if (string2ll((char*)val->estr,val->elen,&val->ell))
              val->flags |= OPVAL_VALID_LL4;
      } else {
          /* The long long was already set, flag as valid. */
          val->flags |= OPVAL_VALID_LL4;
      }
  }
  return val->flags & OPVAL_VALID_LL4;
2231}

2233sds zuiSdsFromValue(zsetopval *val) {
  if (val->ele == NULL((void*)0)) {
      if (val->estr != NULL((void*)0)) {
          val->ele = sdsnewlen((char*)val->estr,val->elen);
      } else {
          val->ele = sdsfromlonglong(val->ell);
      }
      val->flags |= OPVAL_DIRTY_SDS1;
  }
  return val->ele;
2243}

2245/* This is different from zuiSdsFromValue since returns a new SDS string
* which is up to the caller to free. */
2247sds zuiNewSdsFromValue(zsetopval *val) {
  if (val->flags & OPVAL_DIRTY_SDS1) {
      /* We have already one to return! */
      sds ele = val->ele;
      val->flags &= ~OPVAL_DIRTY_SDS1;
      val->ele = NULL((void*)0);
      return ele;
  } else if (val->ele) {
      return sdsdup(val->ele);
  } else if (val->estr) {
      return sdsnewlen((char*)val->estr,val->elen);
  } else {
      return sdsfromlonglong(val->ell);
  }
2261}

2263int zuiBufferFromValue(zsetopval *val) {
  if (val->estr == NULL((void*)0)) {
      if (val->ele != NULL((void*)0)) {
          val->elen = sdslen(val->ele);
          val->estr = (unsigned char*)val->ele;
      } else {
          val->elen = ll2string((char*)val->_buf,sizeof(val->_buf),val->ell);
          val->estr = val->_buf;
      }
  }
  return 1;
2274}

2276/* Find value pointed to by val in the source pointer to by op. When found,
* return 1 and store its score in target. Return 0 otherwise. */
2278int zuiFind(zsetopsrc *op, zsetopval *val, double *score) {
  if (op->subject == NULL((void*)0))
      return 0;

  if (op->type == OBJ_SET2) {
      if (op->encoding == OBJ_ENCODING_INTSET6) {
          if (zuiLongLongFromValue(val) &&
              intsetFind(op->subject->ptr,val->ell))
          {
              *score = 1.0;
              return 1;
          } else {
              return 0;
          }
      } else if (op->encoding == OBJ_ENCODING_HT2) {
          dict *ht = op->subject->ptr;
          zuiSdsFromValue(val);
          if (dictFind(ht,val->ele) != NULL((void*)0)) {
              *score = 1.0;
              return 1;
          } else {
              return 0;
          }
      } else {
          serverPanic("Unknown set encoding")_serverPanic("t_zset.c",2302,"Unknown set encoding"),__builtin_unreachable
();
      }
  } else if (op->type == OBJ_ZSET3) {
      zuiSdsFromValue(val);

      if (op->encoding == OBJ_ENCODING_ZIPLIST5) {
          if (zzlFind(op->subject->ptr,val->ele,score) != NULL((void*)0)) {
              /* Score is already set by zzlFind. */
              return 1;
          } else {
              return 0;
          }
      } else if (op->encoding == OBJ_ENCODING_SKIPLIST7) {
          zset *zs = op->subject->ptr;
          dictEntry *de;
          if ((de = dictFind(zs->dict,val->ele)) != NULL((void*)0)) {
              *score = *(double*)dictGetVal(de)((de)->v.val);
              return 1;
          } else {
              return 0;
          }
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",2324,"Unknown sorted set encoding"),__builtin_unreachable
();
      }
  } else {
      serverPanic("Unsupported type")_serverPanic("t_zset.c",2327,"Unsupported type"),__builtin_unreachable
();
  }
2329}

2331int zuiCompareByCardinality(const void *s1, const void *s2) {
  unsigned long first = zuiLength((zsetopsrc*)s1);
  unsigned long second = zuiLength((zsetopsrc*)s2);
  if (first > second) return 1;
  if (first < second) return -1;
  return 0;
2337}

2339static int zuiCompareByRevCardinality(const void *s1, const void *s2) {
  return zuiCompareByCardinality(s1, s2) * -1;
2341}

2343#define REDIS_AGGR_SUM1 1
2344#define REDIS_AGGR_MIN2 2
2345#define REDIS_AGGR_MAX3 3
2346#define zunionInterDictValue(_e)(((_e)->v.val) == ((void*)0) ? 1.0 : *(double*)((_e)->v
.val)) (dictGetVal(_e)((_e)->v.val) == NULL((void*)0) ? 1.0 : *(double*)dictGetVal(_e)((_e)->v.val))

2348inline static void zunionInterAggregate(double *target, double val, int aggregate) {
  if (aggregate == REDIS_AGGR_SUM1) {
      *target = *target + val;
      /* The result of adding two doubles is NaN when one variable
       * is +inf and the other is -inf. When these numbers are added,
       * we maintain the convention of the result being 0.0. */
      if (isnan(*target)__builtin_isnan (*target)) *target = 0.0;
  } else if (aggregate == REDIS_AGGR_MIN2) {
      *target = val < *target ? val : *target;
  } else if (aggregate == REDIS_AGGR_MAX3) {
      *target = val > *target ? val : *target;
  } else {
      /* safety net */
      serverPanic("Unknown ZUNION/INTER aggregate type")_serverPanic("t_zset.c",2361,"Unknown ZUNION/INTER aggregate type"
),__builtin_unreachable();
  }
2363}

2365static int zsetDictGetMaxElementLength(dict *d) {
  dictIterator *di;
  dictEntry *de;
  size_t maxelelen = 0;

  di = dictGetIterator(d);

  while((de = dictNext(di)) != NULL((void*)0)) {
      sds ele = dictGetKey(de)((de)->key);
      if (sdslen(ele) > maxelelen) maxelelen = sdslen(ele);
  }

  dictReleaseIterator(di);

  return maxelelen;
2380}

2382static void zdiffAlgorithm1(zsetopsrc *src, long setnum, zset *dstzset, size_t *maxelelen) {
  /* DIFF Algorithm 1:
   *
   * We perform the diff by iterating all the elements of the first set,
   * and only adding it to the target set if the element does not exist
   * into all the other sets.
   *
   * This way we perform at max N*M operations, where N is the size of
   * the first set, and M the number of sets.
   *
   * There is also a O(K*log(K)) cost for adding the resulting elements
   * to the target set, where K is the final size of the target set.
   *
   * The final complexity of this algorithm is O(N*M + K*log(K)). */
  int j;
  zsetopval zval;
  zskiplistNode *znode;
  sds tmp;

  /* With algorithm 1 it is better to order the sets to subtract
   * by decreasing size, so that we are more likely to find
   * duplicated elements ASAP. */
  qsort(src+1,setnum-1,sizeof(zsetopsrc),zuiCompareByRevCardinality);

  memset(&zval, 0, sizeof(zval));
  zuiInitIterator(&src[0]);
  while (zuiNext(&src[0],&zval)) {
      double value;
      int exists = 0;

      for (j = 1; j < setnum; j++) {
          /* It is not safe to access the zset we are
           * iterating, so explicitly check for equal object.
           * This check isn't really needed anymore since we already
           * check for a duplicate set in the zsetChooseDiffAlgorithm
           * function, but we're leaving it for future-proofing. */
          if (src[j].subject == src[0].subject ||
              zuiFind(&src[j],&zval,&value)) {
              exists = 1;
              break;
          }
      }

      if (!exists) {
          tmp = zuiNewSdsFromValue(&zval);
          znode = zslInsert(dstzset->zsl,zval.score,tmp);
          dictAdd(dstzset->dict,tmp,&znode->score);
          if (sdslen(tmp) > *maxelelen) *maxelelen = sdslen(tmp);
      }
  }
  zuiClearIterator(&src[0]);
2433}


2436static void zdiffAlgorithm2(zsetopsrc *src, long setnum, zset *dstzset, size_t *maxelelen) {
  /* DIFF Algorithm 2:
   *
   * Add all the elements of the first set to the auxiliary set.
   * Then remove all the elements of all the next sets from it.
   *

   * This is O(L + (N-K)log(N)) where L is the sum of all the elements in every
   * set, N is the size of the first set, and K is the size of the result set.
   *
   * Note that from the (L-N) dict searches, (N-K) got to the zsetRemoveFromSkiplist
   * which costs log(N)
   *
   * There is also a O(K) cost at the end for finding the largest element
   * size, but this doesn't change the algorithm complexity since K < L, and
   * O(2L) is the same as O(L). */
  int j;
  int cardinality = 0;
  zsetopval zval;
  zskiplistNode *znode;
  sds tmp;

  for (j = 0; j < setnum; j++) {
      if (zuiLength(&src[j]) == 0) continue;

      memset(&zval, 0, sizeof(zval));
      zuiInitIterator(&src[j]);
      while (zuiNext(&src[j],&zval)) {
          if (j == 0) {
              tmp = zuiNewSdsFromValue(&zval);
              znode = zslInsert(dstzset->zsl,zval.score,tmp);
              dictAdd(dstzset->dict,tmp,&znode->score);
              cardinality++;
          } else {
              tmp = zuiSdsFromValue(&zval);
              if (zsetRemoveFromSkiplist(dstzset, tmp)) {
                  cardinality--;
              }
          }

          /* Exit if result set is empty as any additional removal
              * of elements will have no effect. */
          if (cardinality == 0) break;
      }
      zuiClearIterator(&src[j]);

      if (cardinality == 0) break;
  }

  /* Redize dict if needed after removing multiple elements */
  if (htNeedsResize(dstzset->dict)) dictResize(dstzset->dict);

  /* Using this algorithm, we can't calculate the max element as we go,
   * we have to iterate through all elements to find the max one after. */
  *maxelelen = zsetDictGetMaxElementLength(dstzset->dict);
2491}

2493static int zsetChooseDiffAlgorithm(zsetopsrc *src, long setnum) {
  int j;

  /* Select what DIFF algorithm to use.
   *
   * Algorithm 1 is O(N*M + K*log(K)) where N is the size of the
   * first set, M the total number of sets, and K is the size of the
   * result set.
   *
   * Algorithm 2 is O(L + (N-K)log(N)) 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.
   *
   * We compute what is the best bet with the current input here. */
  long long algo_one_work = 0;
  long long algo_two_work = 0;

  for (j = 0; j < setnum; j++) {
      /* If any other set is equal to the first set, there is nothing to be
       * done, since we would remove all elements anyway. */
      if (j > 0 && src[0].subject == src[j].subject) {
          return 0;
      }

      algo_one_work += zuiLength(&src[0]);
      algo_two_work += zuiLength(&src[j]);
  }

  /* Algorithm 1 has better constant times and performs less operations
   * if there are elements in common. Give it some advantage. */
  algo_one_work /= 2;
  return (algo_one_work <= algo_two_work) ? 1 : 2;
2525}

2527static void zdiff(zsetopsrc *src, long setnum, zset *dstzset, size_t *maxelelen) {
  /* Skip everything if the smallest input is empty. */
  if (zuiLength(&src[0]) > 0) {
      int diff_algo = zsetChooseDiffAlgorithm(src, setnum);
      if (diff_algo == 1) {
          zdiffAlgorithm1(src, setnum, dstzset, maxelelen);
      } else if (diff_algo == 2) {
          zdiffAlgorithm2(src, setnum, dstzset, maxelelen);
      } else if (diff_algo != 0) {
          serverPanic("Unknown algorithm")_serverPanic("t_zset.c",2536,"Unknown algorithm"),__builtin_unreachable
();
      }
  }
2539}

2541uint64_t dictSdsHash(const void *key);
2542int dictSdsKeyCompare(void *privdata, const void *key1, const void *key2);

2544dictType setAccumulatorDictType = {
  dictSdsHash,               /* hash function */
  NULL((void*)0),                      /* key dup */
  NULL((void*)0),                      /* val dup */
  dictSdsKeyCompare,         /* key compare */
  NULL((void*)0),                      /* key destructor */
  NULL((void*)0),                      /* val destructor */
  NULL((void*)0)                       /* allow to expand */
2552};

2554/* The zunionInterDiffGenericCommand() function is called in order to implement the
* following commands: ZUNION, ZINTER, ZDIFF, ZUNIONSTORE, ZINTERSTORE, ZDIFFSTORE.
*
* 'numkeysIndex' parameter position of key number. for ZUNION/ZINTER/ZDIFF command,
* this value is 1, for ZUNIONSTORE/ZINTERSTORE/ZDIFFSTORE command, this value is 2.
*
* 'op' SET_OP_INTER, SET_OP_UNION or SET_OP_DIFF.
*/
2562void zunionInterDiffGenericCommand(client *c, robj *dstkey, int numkeysIndex, int op) {
  int i, j;
  long setnum;
  int aggregate = REDIS_AGGR_SUM1;
  zsetopsrc *src;
  zsetopval zval;
  sds tmp;
  size_t maxelelen = 0;
  robj *dstobj;
  zset *dstzset;
  zskiplistNode *znode;
  int withscores = 0;

  /* expect setnum input keys to be given */
  if ((getLongFromObjectOrReply(c, c->argv[numkeysIndex], &setnum, NULL((void*)0)) != C_OK0))
      return;

  if (setnum < 1) {
      addReplyError(c,
          "at least 1 input key is needed for ZUNIONSTORE/ZINTERSTORE/ZDIFFSTORE");
      return;
  }

  /* test if the expected number of keys would overflow */
  if (setnum > (c->argc-(numkeysIndex+1))) {
      addReplyErrorObject(c,shared.syntaxerr);
      return;
  }

  /* read keys to be used for input */
  src = zcalloc(sizeof(zsetopsrc) * setnum);
  for (i = 0, j = numkeysIndex+1; i < setnum; i++, j++) {
      robj *obj = dstkey ?
          lookupKeyWrite(c->db,c->argv[j]) :
          lookupKeyRead(c->db,c->argv[j]);
      if (obj != NULL((void*)0)) {
          if (obj->type != OBJ_ZSET3 && obj->type != OBJ_SET2) {
              zfree(src);
              addReplyErrorObject(c,shared.wrongtypeerr);
              return;
          }

          src[i].subject = obj;
          src[i].type = obj->type;
          src[i].encoding = obj->encoding;
      } else {
          src[i].subject = NULL((void*)0);
      }

      /* Default all weights to 1. */
      src[i].weight = 1.0;
  }

  /* parse optional extra arguments */
  if (j < c->argc) {
      int remaining = c->argc - j;

      while (remaining) {
          if (op != SET_OP_DIFF1 &&
              remaining >= (setnum + 1) &&
              !strcasecmp(c->argv[j]->ptr,"weights"))
          {
              j++; remaining--;
              for (i = 0; i < setnum; i++, j++, remaining--) {
                  if (getDoubleFromObjectOrReply(c,c->argv[j],&src[i].weight,
                          "weight value is not a float") != C_OK0)
                  {
                      zfree(src);
                      return;
                  }
              }
          } else if (op != SET_OP_DIFF1 &&
                     remaining >= 2 &&
                     !strcasecmp(c->argv[j]->ptr,"aggregate"))
          {
              j++; remaining--;
              if (!strcasecmp(c->argv[j]->ptr,"sum")) {
                  aggregate = REDIS_AGGR_SUM1;
              } else if (!strcasecmp(c->argv[j]->ptr,"min")) {
                  aggregate = REDIS_AGGR_MIN2;
              } else if (!strcasecmp(c->argv[j]->ptr,"max")) {
                  aggregate = REDIS_AGGR_MAX3;
              } else {
                  zfree(src);
                  addReplyErrorObject(c,shared.syntaxerr);
                  return;
              }
              j++; remaining--;
          } else if (remaining >= 1 &&
                     !dstkey &&
                     !strcasecmp(c->argv[j]->ptr,"withscores"))
          {
              j++; remaining--;
              withscores = 1;
          } else {
              zfree(src);
              addReplyErrorObject(c,shared.syntaxerr);
              return;
          }
      }
  }

  if (op != SET_OP_DIFF1) {
      /* sort sets from the smallest to largest, this will improve our
      * algorithm's performance */
      qsort(src,setnum,sizeof(zsetopsrc),zuiCompareByCardinality);
  }

  dstobj = createZsetObject();
  dstzset = dstobj->ptr;
  memset(&zval, 0, sizeof(zval));

  if (op == SET_OP_INTER2) {
      /* Skip everything if the smallest input is empty. */
      if (zuiLength(&src[0]) > 0) {
          /* Precondition: as src[0] is non-empty and the inputs are ordered
           * by size, all src[i > 0] are non-empty too. */
          zuiInitIterator(&src[0]);
          while (zuiNext(&src[0],&zval)) {
              double score, value;

              score = src[0].weight * zval.score;
              if (isnan(score)__builtin_isnan (score)) score = 0;

              for (j = 1; j < setnum; j++) {
                  /* It is not safe to access the zset we are
                   * iterating, so explicitly check for equal object. */
                  if (src[j].subject == src[0].subject) {
                      value = zval.score*src[j].weight;
                      zunionInterAggregate(&score,value,aggregate);
                  } else if (zuiFind(&src[j],&zval,&value)) {
                      value *= src[j].weight;
                      zunionInterAggregate(&score,value,aggregate);
                  } else {
                      break;
                  }
              }

              /* Only continue when present in every input. */
              if (j == setnum) {
                  tmp = zuiNewSdsFromValue(&zval);
                  znode = zslInsert(dstzset->zsl,score,tmp);
                  dictAdd(dstzset->dict,tmp,&znode->score);
                  if (sdslen(tmp) > maxelelen) maxelelen = sdslen(tmp);
              }
          }
          zuiClearIterator(&src[0]);
      }
  } else if (op == SET_OP_UNION0) {
      dict *accumulator = dictCreate(&setAccumulatorDictType,NULL((void*)0));
      dictIterator *di;
      dictEntry *de, *existing;
      double score;

      if (setnum) {
          /* Our union is at least as large as the largest set.
           * Resize the dictionary ASAP to avoid useless rehashing. */
          dictExpand(accumulator,zuiLength(&src[setnum-1]));
      }

      /* Step 1: Create a dictionary of elements -> aggregated-scores
       * by iterating one sorted set after the other. */
      for (i = 0; i < setnum; i++) {
          if (zuiLength(&src[i]) == 0) continue;

          zuiInitIterator(&src[i]);
          while (zuiNext(&src[i],&zval)) {
              /* Initialize value */
              score = src[i].weight * zval.score;
              if (isnan(score)__builtin_isnan (score)) score = 0;

              /* Search for this element in the accumulating dictionary. */
              de = dictAddRaw(accumulator,zuiSdsFromValue(&zval),&existing);
              /* If we don't have it, we need to create a new entry. */
              if (!existing) {
                  tmp = zuiNewSdsFromValue(&zval);
                  /* Remember the longest single element encountered,
                   * to understand if it's possible to convert to ziplist
                   * at the end. */
                   if (sdslen(tmp) > maxelelen) maxelelen = sdslen(tmp);
                  /* Update the element with its initial score. */
                  dictSetKey(accumulator, de, tmp)do { if ((accumulator)->type->keyDup) (de)->key = (accumulator
)->type->keyDup((accumulator)->privdata, tmp); else (
de)->key = (tmp); } while(0);
                  dictSetDoubleVal(de,score)do { (de)->v.d = score; } while(0);
              } else {
                  /* Update the score with the score of the new instance
                   * of the element found in the current sorted set.
                   *
                   * Here we access directly the dictEntry double
                   * value inside the union as it is a big speedup
                   * compared to using the getDouble/setDouble API. */
                  zunionInterAggregate(&existing->v.d,score,aggregate);
              }
          }
          zuiClearIterator(&src[i]);
      }

      /* Step 2: convert the dictionary into the final sorted set. */
      di = dictGetIterator(accumulator);

      /* We now are aware of the final size of the resulting sorted set,
       * let's resize the dictionary embedded inside the sorted set to the
       * right size, in order to save rehashing time. */
      dictExpand(dstzset->dict,dictSize(accumulator)((accumulator)->ht[0].used+(accumulator)->ht[1].used));

      while((de = dictNext(di)) != NULL((void*)0)) {
          sds ele = dictGetKey(de)((de)->key);
          score = dictGetDoubleVal(de)((de)->v.d);
          znode = zslInsert(dstzset->zsl,score,ele);
          dictAdd(dstzset->dict,ele,&znode->score);
      }
      dictReleaseIterator(di);
      dictRelease(accumulator);
  } else if (op == SET_OP_DIFF1) {
      zdiff(src, setnum, dstzset, &maxelelen);
  } else {
      serverPanic("Unknown operator")_serverPanic("t_zset.c",2777,"Unknown operator"),__builtin_unreachable
();
  }

  if (dstkey) {
      if (dstzset->zsl->length) {
          zsetConvertToZiplistIfNeeded(dstobj, maxelelen);
          setKey(c, c->db, dstkey, dstobj);
          addReplyLongLong(c, zsetLength(dstobj));
          notifyKeyspaceEvent(NOTIFY_ZSET(1<<7),
                              (op == SET_OP_UNION0) ? "zunionstore" :
                                  (op == SET_OP_INTER2 ? "zinterstore" : "zdiffstore"),
                              dstkey, c->db->id);
          server.dirty++;
      } else {
          addReply(c, shared.czero);
          if (dbDelete(c->db, dstkey)) {
              signalModifiedKey(c, c->db, dstkey);
              notifyKeyspaceEvent(NOTIFY_GENERIC(1<<2), "del", dstkey, c->db->id);
              server.dirty++;
          }
      }
  } else {
      unsigned long length = dstzset->zsl->length;
      zskiplist *zsl = dstzset->zsl;
      zskiplistNode *zn = zsl->header->level[0].forward;
      /* In case of WITHSCORES, respond with a single array in RESP2, and
       * nested arrays in RESP3. We can't use a map response type since the
       * client library needs to know to respect the order. */
      if (withscores && c->resp == 2)
          addReplyArrayLen(c, length*2);
      else
          addReplyArrayLen(c, length);

      while (zn != NULL((void*)0)) {
          if (withscores && c->resp > 2) addReplyArrayLen(c,2);
          addReplyBulkCBuffer(c,zn->ele,sdslen(zn->ele));
          if (withscores) addReplyDouble(c,zn->score);
          zn = zn->level[0].forward;
      }
  }
  decrRefCount(dstobj);
  zfree(src);
2819}

2821void zunionstoreCommand(client *c) {
  zunionInterDiffGenericCommand(c, c->argv[1], 2, SET_OP_UNION0);
2823}

2825void zinterstoreCommand(client *c) {
  zunionInterDiffGenericCommand(c, c->argv[1], 2, SET_OP_INTER2);
2827}

2829void zdiffstoreCommand(client *c) {
  zunionInterDiffGenericCommand(c, c->argv[1], 2, SET_OP_DIFF1);
2831}

2833void zunionCommand(client *c) {
  zunionInterDiffGenericCommand(c, NULL((void*)0), 1, SET_OP_UNION0);
2835}

2837void zinterCommand(client *c) {
  zunionInterDiffGenericCommand(c, NULL((void*)0), 1, SET_OP_INTER2);
2839}

2841void zdiffCommand(client *c) {
  zunionInterDiffGenericCommand(c, NULL((void*)0), 1, SET_OP_DIFF1);
2843}

2845typedef enum {
  ZRANGE_DIRECTION_AUTO = 0,
  ZRANGE_DIRECTION_FORWARD,
  ZRANGE_DIRECTION_REVERSE
2849} zrange_direction;

2851typedef enum {
  ZRANGE_CONSUMER_TYPE_CLIENT = 0,
  ZRANGE_CONSUMER_TYPE_INTERNAL
2854} zrange_consumer_type;

2856typedef struct zrange_result_handler zrange_result_handler;

2858typedef void (*zrangeResultBeginFunction)(zrange_result_handler *c);
2859typedef void (*zrangeResultFinalizeFunction)(
  zrange_result_handler *c, size_t result_count);
2861typedef void (*zrangeResultEmitCBufferFunction)(
  zrange_result_handler *c, const void *p, size_t len, double score);
2863typedef void (*zrangeResultEmitLongLongFunction)(
  zrange_result_handler *c, long long ll, double score);

2866void zrangeGenericCommand (zrange_result_handler *handler, int argc_start, int store,
                         zrange_type rangetype, zrange_direction direction);

2869/* Interface struct for ZRANGE/ZRANGESTORE generic implementation.
* There is one implementation of this interface that sends a RESP reply to clients.
* and one implementation that stores the range result into a zset object. */
2872struct zrange_result_handler {
  zrange_consumer_type                 type;
  client                              *client;
  robj                                *dstkey;
  robj                                *dstobj;
  void                                *userdata;
  int                                  withscores;
  int                                  should_emit_array_length;
  zrangeResultBeginFunction            beginResultEmission;
  zrangeResultFinalizeFunction         finalizeResultEmission;
  zrangeResultEmitCBufferFunction      emitResultFromCBuffer;
  zrangeResultEmitLongLongFunction     emitResultFromLongLong;
2884};

2886/* Result handler methods for responding the ZRANGE to clients. */
2887static void zrangeResultBeginClient(zrange_result_handler *handler) {
  handler->userdata = addReplyDeferredLen(handler->client);
2889}

2891static void zrangeResultEmitCBufferToClient(zrange_result_handler *handler,
  const void *value, size_t value_length_in_bytes, double score)
2893{
  if (handler->should_emit_array_length) {
      addReplyArrayLen(handler->client, 2);
  }

  addReplyBulkCBuffer(handler->client, value, value_length_in_bytes);

  if (handler->withscores) {
      addReplyDouble(handler->client, score);
  }
2903}

2905static void zrangeResultEmitLongLongToClient(zrange_result_handler *handler,
  long long value, double score)
2907{
  if (handler->should_emit_array_length) {
      addReplyArrayLen(handler->client, 2);
  }

  addReplyBulkLongLong(handler->client, value);

  if (handler->withscores) {
      addReplyDouble(handler->client, score);
  }
2917}

2919static void zrangeResultFinalizeClient(zrange_result_handler *handler,
  size_t result_count)
2921{
  /* In case of WITHSCORES, respond with a single array in RESP2, and
   * nested arrays in RESP3. We can't use a map response type since the
   * client library needs to know to respect the order. */
  if (handler->withscores && (handler->client->resp == 2)) {
      result_count *= 2;
  }

  setDeferredArrayLen(handler->client, handler->userdata, result_count);
2930}

2932/* Result handler methods for storing the ZRANGESTORE to a zset. */
2933static void zrangeResultBeginStore(zrange_result_handler *handler)
2934{
  handler->dstobj = createZsetZiplistObject();
2936}

2938static void zrangeResultEmitCBufferForStore(zrange_result_handler *handler,
  const void *value, size_t value_length_in_bytes, double score)
2940{
  double newscore;
  int retflags = 0;
  sds ele = sdsnewlen(value, value_length_in_bytes);
  int retval = zsetAdd(handler->dstobj, score, ele, &retflags, &newscore);
  sdsfree(ele);
  serverAssert(retval)((retval)?(void)0 : (_serverAssert("retval","t_zset.c",2946),
__builtin_unreachable()));
2947}

2949static void zrangeResultEmitLongLongForStore(zrange_result_handler *handler,
  long long value, double score)
2951{
  double newscore;
  int retflags = 0;
  sds ele = sdsfromlonglong(value);
  int retval = zsetAdd(handler->dstobj, score, ele, &retflags, &newscore);
1
Calling 'zsetAdd'→
  sdsfree(ele);
  serverAssert(retval)((retval)?(void)0 : (_serverAssert("retval","t_zset.c",2957),
__builtin_unreachable()));
2958}

2960static void zrangeResultFinalizeStore(zrange_result_handler *handler, size_t result_count)
2961{
  if (result_count) {
      setKey(handler->client, handler->client->db, handler->dstkey, handler->dstobj);
      addReplyLongLong(handler->client, result_count);
      notifyKeyspaceEvent(NOTIFY_ZSET(1<<7), "zrangestore", handler->dstkey, handler->client->db->id);
      server.dirty++;
  } else {
      addReply(handler->client, shared.czero);
      if (dbDelete(handler->client->db, handler->dstkey)) {
          signalModifiedKey(handler->client, handler->client->db, handler->dstkey);
          notifyKeyspaceEvent(NOTIFY_GENERIC(1<<2), "del", handler->dstkey, handler->client->db->id);
          server.dirty++;
      }
  }
  decrRefCount(handler->dstobj);
2976}

2978/* Initialize the consumer interface type with the requested type. */
2979static void zrangeResultHandlerInit(zrange_result_handler *handler,
  client *client, zrange_consumer_type type)
2981{
  memset(handler, 0, sizeof(*handler));

  handler->client = client;

  switch (type) {
  case ZRANGE_CONSUMER_TYPE_CLIENT:
      handler->beginResultEmission = zrangeResultBeginClient;
      handler->finalizeResultEmission = zrangeResultFinalizeClient;
      handler->emitResultFromCBuffer = zrangeResultEmitCBufferToClient;
      handler->emitResultFromLongLong = zrangeResultEmitLongLongToClient;
      break;

  case ZRANGE_CONSUMER_TYPE_INTERNAL:
      handler->beginResultEmission = zrangeResultBeginStore;
      handler->finalizeResultEmission = zrangeResultFinalizeStore;
      handler->emitResultFromCBuffer = zrangeResultEmitCBufferForStore;
      handler->emitResultFromLongLong = zrangeResultEmitLongLongForStore;
      break;
  }
3001}

3003static void zrangeResultHandlerScoreEmissionEnable(zrange_result_handler *handler) {
  handler->withscores = 1;
  handler->should_emit_array_length = (handler->client->resp > 2);
3006}

3008static void zrangeResultHandlerDestinationKeySet (zrange_result_handler *handler,
  robj *dstkey)
3010{
  handler->dstkey = dstkey;
3012}

3014/* This command implements ZRANGE, ZREVRANGE. */
3015void genericZrangebyrankCommand(zrange_result_handler *handler,
  robj *zobj, long start, long end, int withscores, int reverse) {

  client *c = handler->client;
  long llen;
  long rangelen;
  size_t result_cardinality;

  /* Sanitize indexes. */
  llen = zsetLength(zobj);
  if (start < 0) start = llen+start;
  if (end < 0) end = llen+end;
  if (start < 0) start = 0;

  handler->beginResultEmission(handler);

  /* Invariant: start >= 0, so this test will be true when end < 0.
   * The range is empty when start > end or start >= length. */
  if (start > end || start >= llen) {
      handler->finalizeResultEmission(handler, 0);
      return;
  }
  if (end >= llen) end = llen-1;
  rangelen = (end-start)+1;
  result_cardinality = rangelen;

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;
      unsigned char *vstr;
      unsigned int vlen;
      long long vlong;
      double score = 0.0;

      if (reverse)
          eptr = ziplistIndex(zl,-2-(2*start));
      else
          eptr = ziplistIndex(zl,2*start);

      serverAssertWithInfo(c,zobj,eptr != NULL)((eptr != ((void*)0))?(void)0 : (_serverAssertWithInfo(c,zobj
,"eptr != NULL","t_zset.c",3054),__builtin_unreachable()));
      sptr = ziplistNext(zl,eptr);

      while (rangelen--) {
          serverAssertWithInfo(c,zobj,eptr != NULL && sptr != NULL)((eptr != ((void*)0) && sptr != ((void*)0))?(void)0 :
 (_serverAssertWithInfo(c,zobj,"eptr != NULL && sptr != NULL"
,"t_zset.c",3058),__builtin_unreachable()));
          serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssertWithInfo(c,zobj,"ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",3059),__builtin_unreachable()));

          if (withscores) /* don't bother to extract the score if it's gonna be ignored. */
              score = zzlGetScore(sptr);

          if (vstr == NULL((void*)0)) {
              handler->emitResultFromLongLong(handler, vlong, score);
          } else {
              handler->emitResultFromCBuffer(handler, vstr, vlen, score);
          }

          if (reverse)
              zzlPrev(zl,&eptr,&sptr);
          else
              zzlNext(zl,&eptr,&sptr);
      }

  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      zskiplistNode *ln;

      /* Check if starting point is trivial, before doing log(N) lookup. */
      if (reverse) {
          ln = zsl->tail;
          if (start > 0)
              ln = zslGetElementByRank(zsl,llen-start);
      } else {
          ln = zsl->header->level[0].forward;
          if (start > 0)
              ln = zslGetElementByRank(zsl,start+1);
      }

      while(rangelen--) {
          serverAssertWithInfo(c,zobj,ln != NULL)((ln != ((void*)0))?(void)0 : (_serverAssertWithInfo(c,zobj,"ln != NULL"
,"t_zset.c",3093),__builtin_unreachable()));
          sds ele = ln->ele;
          handler->emitResultFromCBuffer(handler, ele, sdslen(ele), ln->score);
          ln = reverse ? ln->backward : ln->level[0].forward;
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3099,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  handler->finalizeResultEmission(handler, result_cardinality);
3103}

3105/* ZRANGESTORE <dst> <src> <min> <max> [BYSCORE | BYLEX] [REV] [LIMIT offset count] */
3106void zrangestoreCommand (client *c) {
  robj *dstkey = c->argv[1];
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_INTERNAL);
  zrangeResultHandlerDestinationKeySet(&handler, dstkey);
  zrangeGenericCommand(&handler, 2, 1, ZRANGE_AUTO, ZRANGE_DIRECTION_AUTO);
3112}

3114/* ZRANGE <key> <min> <max> [BYSCORE | BYLEX] [REV] [WITHSCORES] [LIMIT offset count] */
3115void zrangeCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_AUTO, ZRANGE_DIRECTION_AUTO);
3119}

3121/* ZREVRANGE <key> <min> <max> [WITHSCORES] */
3122void zrevrangeCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_RANK, ZRANGE_DIRECTION_REVERSE);
3126}

3128/* This command implements ZRANGEBYSCORE, ZREVRANGEBYSCORE. */
3129void genericZrangebyscoreCommand(zrange_result_handler *handler,
  zrangespec *range, robj *zobj, long offset, long limit, 
  int reverse) {

  client *c = handler->client;
  unsigned long rangelen = 0;

  handler->beginResultEmission(handler);

  /* For invalid offset, return directly. */
  if (offset > 0 && offset >= (long)zsetLength(zobj)) {
      handler->finalizeResultEmission(handler, 0);
      return;
  }

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;
      unsigned char *vstr;
      unsigned int vlen;
      long long vlong;

      /* If reversed, get the last node in range as starting point. */
      if (reverse) {
          eptr = zzlLastInRange(zl,range);
      } else {
          eptr = zzlFirstInRange(zl,range);
      }

      /* Get score pointer for the first element. */
      if (eptr)
          sptr = ziplistNext(zl,eptr);

      /* If there is an offset, just traverse the number of elements without
       * checking the score because that is done in the next loop. */
      while (eptr && offset--) {
          if (reverse) {
              zzlPrev(zl,&eptr,&sptr);
          } else {
              zzlNext(zl,&eptr,&sptr);
          }
      }

      while (eptr && limit--) {
          double score = zzlGetScore(sptr);

          /* Abort when the node is no longer in range. */
          if (reverse) {
              if (!zslValueGteMin(score,range)) break;
          } else {
              if (!zslValueLteMax(score,range)) break;
          }

          /* We know the element exists, so ziplistGet should always
           * succeed */
          serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssertWithInfo(c,zobj,"ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",3184),__builtin_unreachable()));

          rangelen++;
          if (vstr == NULL((void*)0)) {
              handler->emitResultFromLongLong(handler, vlong, score);
          } else {
              handler->emitResultFromCBuffer(handler, vstr, vlen, score);
          }

          /* Move to next node */
          if (reverse) {
              zzlPrev(zl,&eptr,&sptr);
          } else {
              zzlNext(zl,&eptr,&sptr);
          }
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      zskiplistNode *ln;

      /* If reversed, get the last node in range as starting point. */
      if (reverse) {
          ln = zslLastInRange(zsl,range);
      } else {
          ln = zslFirstInRange(zsl,range);
      }

      /* If there is an offset, just traverse the number of elements without
       * checking the score because that is done in the next loop. */
      while (ln && offset--) {
          if (reverse) {
              ln = ln->backward;
          } else {
              ln = ln->level[0].forward;
          }
      }

      while (ln && limit--) {
          /* Abort when the node is no longer in range. */
          if (reverse) {
              if (!zslValueGteMin(ln->score,range)) break;
          } else {
              if (!zslValueLteMax(ln->score,range)) break;
          }

          rangelen++;
          handler->emitResultFromCBuffer(handler, ln->ele, sdslen(ln->ele), ln->score);

          /* Move to next node */
          if (reverse) {
              ln = ln->backward;
          } else {
              ln = ln->level[0].forward;
          }
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3241,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  handler->finalizeResultEmission(handler, rangelen);
3245}

3247/* ZRANGEBYSCORE <key> <min> <max> [WITHSCORES] [LIMIT offset count] */
3248void zrangebyscoreCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_SCORE, ZRANGE_DIRECTION_FORWARD);
3252}

3254/* ZREVRANGEBYSCORE <key> <min> <max> [WITHSCORES] [LIMIT offset count] */
3255void zrevrangebyscoreCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_SCORE, ZRANGE_DIRECTION_REVERSE);
3259}

3261void zcountCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;
  zrangespec range;
  unsigned long count = 0;

  /* Parse the range arguments */
  if (zslParseRange(c->argv[2],c->argv[3],&range) != C_OK0) {
      addReplyError(c,"min or max is not a float");
      return;
  }

  /* Lookup the sorted set */
  if ((zobj = lookupKeyReadOrReply(c, key, shared.czero)) == NULL((void*)0) ||
      checkType(c, zobj, OBJ_ZSET3)) return;

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;
      double score;

      /* Use the first element in range as the starting point */
      eptr = zzlFirstInRange(zl,&range);

      /* No "first" element */
      if (eptr == NULL((void*)0)) {
          addReply(c, shared.czero);
          return;
      }

      /* First element is in range */
      sptr = ziplistNext(zl,eptr);
      score = zzlGetScore(sptr);
      serverAssertWithInfo(c,zobj,zslValueLteMax(score,&range))((zslValueLteMax(score,&range))?(void)0 : (_serverAssertWithInfo
(c,zobj,"zslValueLteMax(score,&range)","t_zset.c",3294),__builtin_unreachable
()));

      /* Iterate over elements in range */
      while (eptr) {
          score = zzlGetScore(sptr);

          /* Abort when the node is no longer in range. */
          if (!zslValueLteMax(score,&range)) {
              break;
          } else {
              count++;
              zzlNext(zl,&eptr,&sptr);
          }
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      zskiplistNode *zn;
      unsigned long rank;

      /* Find first element in range */
      zn = zslFirstInRange(zsl, &range);

      /* Use rank of first element, if any, to determine preliminary count */
      if (zn != NULL((void*)0)) {
          rank = zslGetRank(zsl, zn->score, zn->ele);
          count = (zsl->length - (rank - 1));

          /* Find last element in range */
          zn = zslLastInRange(zsl, &range);

          /* Use rank of last element, if any, to determine the actual count */
          if (zn != NULL((void*)0)) {
              rank = zslGetRank(zsl, zn->score, zn->ele);
              count -= (zsl->length - rank);
          }
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3332,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  addReplyLongLong(c, count);
3336}

3338void zlexcountCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;
  zlexrangespec range;
  unsigned long count = 0;

  /* Parse the range arguments */
  if (zslParseLexRange(c->argv[2],c->argv[3],&range) != C_OK0) {
      addReplyError(c,"min or max not valid string range item");
      return;
  }

  /* Lookup the sorted set */
  if ((zobj = lookupKeyReadOrReply(c, key, shared.czero)) == NULL((void*)0) ||
      checkType(c, zobj, OBJ_ZSET3))
  {
      zslFreeLexRange(&range);
      return;
  }

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;

      /* Use the first element in range as the starting point */
      eptr = zzlFirstInLexRange(zl,&range);

      /* No "first" element */
      if (eptr == NULL((void*)0)) {
          zslFreeLexRange(&range);
          addReply(c, shared.czero);
          return;
      }

      /* First element is in range */
      sptr = ziplistNext(zl,eptr);
      serverAssertWithInfo(c,zobj,zzlLexValueLteMax(eptr,&range))((zzlLexValueLteMax(eptr,&range))?(void)0 : (_serverAssertWithInfo
(c,zobj,"zzlLexValueLteMax(eptr,&range)","t_zset.c",3374)
,__builtin_unreachable()));

      /* Iterate over elements in range */
      while (eptr) {
          /* Abort when the node is no longer in range. */
          if (!zzlLexValueLteMax(eptr,&range)) {
              break;
          } else {
              count++;
              zzlNext(zl,&eptr,&sptr);
          }
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      zskiplistNode *zn;
      unsigned long rank;

      /* Find first element in range */
      zn = zslFirstInLexRange(zsl, &range);

      /* Use rank of first element, if any, to determine preliminary count */
      if (zn != NULL((void*)0)) {
          rank = zslGetRank(zsl, zn->score, zn->ele);
          count = (zsl->length - (rank - 1));

          /* Find last element in range */
          zn = zslLastInLexRange(zsl, &range);

          /* Use rank of last element, if any, to determine the actual count */
          if (zn != NULL((void*)0)) {
              rank = zslGetRank(zsl, zn->score, zn->ele);
              count -= (zsl->length - rank);
          }
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3410,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  zslFreeLexRange(&range);
  addReplyLongLong(c, count);
3415}

3417/* This command implements ZRANGEBYLEX, ZREVRANGEBYLEX. */
3418void genericZrangebylexCommand(zrange_result_handler *handler,
  zlexrangespec *range, robj *zobj, int withscores, long offset, long limit,
  int reverse)
3421{
  client *c = handler->client;
  unsigned long rangelen = 0;

  handler->beginResultEmission(handler);

  if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
      unsigned char *zl = zobj->ptr;
      unsigned char *eptr, *sptr;
      unsigned char *vstr;
      unsigned int vlen;
      long long vlong;

      /* If reversed, get the last node in range as starting point. */
      if (reverse) {
          eptr = zzlLastInLexRange(zl,range);
      } else {
          eptr = zzlFirstInLexRange(zl,range);
      }

      /* Get score pointer for the first element. */
      if (eptr)
          sptr = ziplistNext(zl,eptr);

      /* If there is an offset, just traverse the number of elements without
       * checking the score because that is done in the next loop. */
      while (eptr && offset--) {
          if (reverse) {
              zzlPrev(zl,&eptr,&sptr);
          } else {
              zzlNext(zl,&eptr,&sptr);
          }
      }

      while (eptr && limit--) {
          double score = 0;
          if (withscores) /* don't bother to extract the score if it's gonna be ignored. */
              score = zzlGetScore(sptr);

          /* Abort when the node is no longer in range. */
          if (reverse) {
              if (!zzlLexValueGteMin(eptr,range)) break;
          } else {
              if (!zzlLexValueLteMax(eptr,range)) break;
          }

          /* We know the element exists, so ziplistGet should always
           * succeed. */
          serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssertWithInfo(c,zobj,"ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",3469),__builtin_unreachable()));

          rangelen++;
          if (vstr == NULL((void*)0)) {
              handler->emitResultFromLongLong(handler, vlong, score);
          } else {
              handler->emitResultFromCBuffer(handler, vstr, vlen, score);
          }

          /* Move to next node */
          if (reverse) {
              zzlPrev(zl,&eptr,&sptr);
          } else {
              zzlNext(zl,&eptr,&sptr);
          }
      }
  } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
      zset *zs = zobj->ptr;
      zskiplist *zsl = zs->zsl;
      zskiplistNode *ln;

      /* If reversed, get the last node in range as starting point. */
      if (reverse) {
          ln = zslLastInLexRange(zsl,range);
      } else {
          ln = zslFirstInLexRange(zsl,range);
      }

      /* If there is an offset, just traverse the number of elements without
       * checking the score because that is done in the next loop. */
      while (ln && offset--) {
          if (reverse) {
              ln = ln->backward;
          } else {
              ln = ln->level[0].forward;
          }
      }

      while (ln && limit--) {
          /* Abort when the node is no longer in range. */
          if (reverse) {
              if (!zslLexValueGteMin(ln->ele,range)) break;
          } else {
              if (!zslLexValueLteMax(ln->ele,range)) break;
          }

          rangelen++;
          handler->emitResultFromCBuffer(handler, ln->ele, sdslen(ln->ele), ln->score);

          /* Move to next node */
          if (reverse) {
              ln = ln->backward;
          } else {
              ln = ln->level[0].forward;
          }
      }
  } else {
      serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3526,"Unknown sorted set encoding"),__builtin_unreachable
();
  }

  handler->finalizeResultEmission(handler, rangelen);
3530}

3532/* ZRANGEBYLEX <key> <min> <max> [LIMIT offset count] */
3533void zrangebylexCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_LEX, ZRANGE_DIRECTION_FORWARD);
3537}

3539/* ZREVRANGEBYLEX <key> <min> <max> [LIMIT offset count] */
3540void zrevrangebylexCommand(client *c) {
  zrange_result_handler handler;
  zrangeResultHandlerInit(&handler, c, ZRANGE_CONSUMER_TYPE_CLIENT);
  zrangeGenericCommand(&handler, 1, 0, ZRANGE_LEX, ZRANGE_DIRECTION_REVERSE);
3544}

3546/**
* This function handles ZRANGE and ZRANGESTORE, and also the deprecated
* Z[REV]RANGE[BYPOS|BYLEX] commands.
*
* The simple ZRANGE and ZRANGESTORE can take _AUTO in rangetype and direction,
* other command pass explicit value.
*
* The argc_start points to the src key argument, so following syntax is like:
* <src> <min> <max> [BYSCORE | BYLEX] [REV] [WITHSCORES] [LIMIT offset count]
*/
3556void zrangeGenericCommand(zrange_result_handler *handler, int argc_start, int store,
                        zrange_type rangetype, zrange_direction direction)
3558{
  client *c = handler->client;
  robj *key = c->argv[argc_start];
  robj *zobj;
  zrangespec range;
  zlexrangespec lexrange;
  int minidx = argc_start + 1;
  int maxidx = argc_start + 2;

  /* Options common to all */
  long opt_start = 0;
  long opt_end = 0;
  int opt_withscores = 0;
  long opt_offset = 0;
  long opt_limit = -1;

  /* Step 1: Skip the <src> <min> <max> args and parse remaining optional arguments. */
  for (int j=argc_start + 3; j < c->argc; j++) {
      int leftargs = c->argc-j-1;
      if (!store && !strcasecmp(c->argv[j]->ptr,"withscores")) {
          opt_withscores = 1;
      } else if (!strcasecmp(c->argv[j]->ptr,"limit") && leftargs >= 2) {
          if ((getLongFromObjectOrReply(c, c->argv[j+1], &opt_offset, NULL((void*)0)) != C_OK0) ||
              (getLongFromObjectOrReply(c, c->argv[j+2], &opt_limit, NULL((void*)0)) != C_OK0))
          {
              return;
          }
          j += 2;
      } else if (direction == ZRANGE_DIRECTION_AUTO &&
                 !strcasecmp(c->argv[j]->ptr,"rev"))
      {
          direction = ZRANGE_DIRECTION_REVERSE;
      } else if (rangetype == ZRANGE_AUTO &&
                 !strcasecmp(c->argv[j]->ptr,"bylex"))
      {
          rangetype = ZRANGE_LEX;
      } else if (rangetype == ZRANGE_AUTO &&
                 !strcasecmp(c->argv[j]->ptr,"byscore"))
      {
          rangetype = ZRANGE_SCORE;
      } else {
          addReplyErrorObject(c,shared.syntaxerr);
          return;
      }
  }

  /* Use defaults if not overriden by arguments. */
  if (direction == ZRANGE_DIRECTION_AUTO)
      direction = ZRANGE_DIRECTION_FORWARD;
  if (rangetype == ZRANGE_AUTO)
      rangetype = ZRANGE_RANK;

  /* Check for conflicting arguments. */
  if (opt_limit != -1 && rangetype == ZRANGE_RANK) {
      addReplyError(c,"syntax error, LIMIT is only supported in combination with either BYSCORE or BYLEX");
      return;
  }
  if (opt_withscores && rangetype == ZRANGE_LEX) {
      addReplyError(c,"syntax error, WITHSCORES not supported in combination with BYLEX");
      return;
  }

  if (direction == ZRANGE_DIRECTION_REVERSE &&
      ((ZRANGE_SCORE == rangetype) || (ZRANGE_LEX == rangetype)))
  {
      /* Range is given as [max,min] */
      int tmp = maxidx;
      maxidx = minidx;
      minidx = tmp;
  }

  /* Step 2: Parse the range. */
  switch (rangetype) {
  case ZRANGE_AUTO:
  case ZRANGE_RANK:
      /* Z[REV]RANGE, ZRANGESTORE [REV]RANGE */
      if ((getLongFromObjectOrReply(c, c->argv[minidx], &opt_start,NULL((void*)0)) != C_OK0) ||
          (getLongFromObjectOrReply(c, c->argv[maxidx], &opt_end,NULL((void*)0)) != C_OK0))
      {
          return;
      }
      break;

  case ZRANGE_SCORE:
      /* Z[REV]RANGEBYSCORE, ZRANGESTORE [REV]RANGEBYSCORE */
      if (zslParseRange(c->argv[minidx], c->argv[maxidx], &range) != C_OK0) {
          addReplyError(c, "min or max is not a float");
          return;
      }
      break;

  case ZRANGE_LEX:
      /* Z[REV]RANGEBYLEX, ZRANGESTORE [REV]RANGEBYLEX */
      if (zslParseLexRange(c->argv[minidx], c->argv[maxidx], &lexrange) != C_OK0) {
          addReplyError(c, "min or max not valid string range item");
          return;
      }
      break;
  }

  if (opt_withscores || store) {
      zrangeResultHandlerScoreEmissionEnable(handler);
  }

  /* Step 3: Lookup the key and get the range. */
  zobj = handler->dstkey ?
      lookupKeyWrite(c->db,key) :
      lookupKeyRead(c->db,key);
  if (zobj == NULL((void*)0)) {
      addReply(c,shared.emptyarray);
      goto cleanup;
  }

  if (checkType(c,zobj,OBJ_ZSET3)) goto cleanup;

  /* Step 4: Pass this to the command-specific handler. */
  switch (rangetype) {
  case ZRANGE_AUTO:
  case ZRANGE_RANK:
      genericZrangebyrankCommand(handler, zobj, opt_start, opt_end,
          opt_withscores || store, direction == ZRANGE_DIRECTION_REVERSE);
      break;

  case ZRANGE_SCORE:
      genericZrangebyscoreCommand(handler, &range, zobj, opt_offset,
          opt_limit, direction == ZRANGE_DIRECTION_REVERSE);
      break;

  case ZRANGE_LEX:
      genericZrangebylexCommand(handler, &lexrange, zobj, opt_withscores || store,
          opt_offset, opt_limit, direction == ZRANGE_DIRECTION_REVERSE);
      break;
  }

  /* Instead of returning here, we'll just fall-through the clean-up. */

3694cleanup:

  if (rangetype == ZRANGE_LEX) {
      zslFreeLexRange(&lexrange);
  }
3699}

3701void zcardCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;

  if ((zobj = lookupKeyReadOrReply(c,key,shared.czero)) == NULL((void*)0) ||
      checkType(c,zobj,OBJ_ZSET3)) return;

  addReplyLongLong(c,zsetLength(zobj));
3709}

3711void zscoreCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;
  double score;

  if ((zobj = lookupKeyReadOrReply(c,key,shared.null[c->resp])) == NULL((void*)0) ||
      checkType(c,zobj,OBJ_ZSET3)) return;

  if (zsetScore(zobj,c->argv[2]->ptr,&score) == C_ERR-1) {
      addReplyNull(c);
  } else {
      addReplyDouble(c,score);
  }
3724}

3726void zmscoreCommand(client *c) {
  robj *key = c->argv[1];
  robj *zobj;
  double score;
  zobj = lookupKeyRead(c->db,key);
  if (checkType(c,zobj,OBJ_ZSET3)) return;

  addReplyArrayLen(c,c->argc - 2);
  for (int j = 2; j < c->argc; j++) {
      /* Treat a missing set the same way as an empty set */
      if (zobj == NULL((void*)0) || zsetScore(zobj,c->argv[j]->ptr,&score) == C_ERR-1) {
          addReplyNull(c);
      } else {
          addReplyDouble(c,score);
      }
  }
3742}

3744void zrankGenericCommand(client *c, int reverse) {
  robj *key = c->argv[1];
  robj *ele = c->argv[2];
  robj *zobj;
  long rank;

  if ((zobj = lookupKeyReadOrReply(c,key,shared.null[c->resp])) == NULL((void*)0) ||
      checkType(c,zobj,OBJ_ZSET3)) return;

  serverAssertWithInfo(c,ele,sdsEncodedObject(ele))(((ele->encoding == 0 || ele->encoding == 8))?(void)0 :
 (_serverAssertWithInfo(c,ele,"sdsEncodedObject(ele)","t_zset.c"
,3753),__builtin_unreachable()));
  rank = zsetRank(zobj,ele->ptr,reverse);
  if (rank >= 0) {
      addReplyLongLong(c,rank);
  } else {
      addReplyNull(c);
  }
3760}

3762void zrankCommand(client *c) {
  zrankGenericCommand(c, 0);
3764}

3766void zrevrankCommand(client *c) {
  zrankGenericCommand(c, 1);
3768}

3770void zscanCommand(client *c) {
  robj *o;
  unsigned long cursor;

  if (parseScanCursorOrReply(c,c->argv[2],&cursor) == C_ERR-1) return;
  if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptyscan)) == NULL((void*)0) ||
      checkType(c,o,OBJ_ZSET3)) return;
  scanGenericCommand(c,o,cursor);
3778}

3780/* This command implements the generic zpop operation, used by:
* ZPOPMIN, ZPOPMAX, BZPOPMIN and BZPOPMAX. This function is also used
* inside blocked.c in the unblocking stage of BZPOPMIN and BZPOPMAX.
*
* If 'emitkey' is true also the key name is emitted, useful for the blocking
* behavior of BZPOP[MIN|MAX], since we can block into multiple keys.
*
* The synchronous version instead does not need to emit the key, but may
* use the 'count' argument to return multiple items if available. */
3789void genericZpopCommand(client *c, robj **keyv, int keyc, int where, int emitkey, robj *countarg) {
  int idx;
  robj *key = NULL((void*)0);
  robj *zobj = NULL((void*)0);
  sds ele;
  double score;
  long count = 1;

  /* If a count argument as passed, parse it or return an error. */
  if (countarg) {
      if (getLongFromObjectOrReply(c,countarg,&count,NULL((void*)0)) != C_OK0)
          return;
      if (count <= 0) {
          addReply(c,shared.emptyarray);
          return;
      }
  }

  /* Check type and break on the first error, otherwise identify candidate. */
  idx = 0;
  while (idx < keyc) {
      key = keyv[idx++];
      zobj = lookupKeyWrite(c->db,key);
      if (!zobj) continue;
      if (checkType(c,zobj,OBJ_ZSET3)) return;
      break;
  }

  /* No candidate for zpopping, return empty. */
  if (!zobj) {
      addReply(c,shared.emptyarray);
      return;
  }

  void *arraylen_ptr = addReplyDeferredLen(c);
  long arraylen = 0;

  /* We emit the key only for the blocking variant. */
  if (emitkey) addReplyBulk(c,key);

  /* Remove the element. */
  do {
      if (zobj->encoding == OBJ_ENCODING_ZIPLIST5) {
          unsigned char *zl = zobj->ptr;
          unsigned char *eptr, *sptr;
          unsigned char *vstr;
          unsigned int vlen;
          long long vlong;

          /* Get the first or last element in the sorted set. */
          eptr = ziplistIndex(zl,where == ZSET_MAX1 ? -2 : 0);
          serverAssertWithInfo(c,zobj,eptr != NULL)((eptr != ((void*)0))?(void)0 : (_serverAssertWithInfo(c,zobj
,"eptr != NULL","t_zset.c",3840),__builtin_unreachable()));
          serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong))((ziplistGet(eptr,&vstr,&vlen,&vlong))?(void)0 : (
_serverAssertWithInfo(c,zobj,"ziplistGet(eptr,&vstr,&vlen,&vlong)"
,"t_zset.c",3841),__builtin_unreachable()));
          if (vstr == NULL((void*)0))
              ele = sdsfromlonglong(vlong);
          else
              ele = sdsnewlen(vstr,vlen);

          /* Get the score. */
          sptr = ziplistNext(zl,eptr);
          serverAssertWithInfo(c,zobj,sptr != NULL)((sptr != ((void*)0))?(void)0 : (_serverAssertWithInfo(c,zobj
,"sptr != NULL","t_zset.c",3849),__builtin_unreachable()));
          score = zzlGetScore(sptr);
      } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST7) {
          zset *zs = zobj->ptr;
          zskiplist *zsl = zs->zsl;
          zskiplistNode *zln;

          /* Get the first or last element in the sorted set. */
          zln = (where == ZSET_MAX1 ? zsl->tail :
                                     zsl->header->level[0].forward);

          /* There must be an element in the sorted set. */
          serverAssertWithInfo(c,zobj,zln != NULL)((zln != ((void*)0))?(void)0 : (_serverAssertWithInfo(c,zobj,
"zln != NULL","t_zset.c",3861),__builtin_unreachable()));
          ele = sdsdup(zln->ele);
          score = zln->score;
      } else {
          serverPanic("Unknown sorted set encoding")_serverPanic("t_zset.c",3865,"Unknown sorted set encoding"),__builtin_unreachable
();
      }

      serverAssertWithInfo(c,zobj,zsetDel(zobj,ele))((zsetDel(zobj,ele))?(void)0 : (_serverAssertWithInfo(c,zobj,
"zsetDel(zobj,ele)","t_zset.c",3868),__builtin_unreachable())
);
      server.dirty++;

      if (arraylen == 0) { /* Do this only for the first iteration. */
          char *events[2] = {"zpopmin","zpopmax"};
          notifyKeyspaceEvent(NOTIFY_ZSET(1<<7),events[where],key,c->db->id);
          signalModifiedKey(c,c->db,key);
      }

      addReplyBulkCBuffer(c,ele,sdslen(ele));
      addReplyDouble(c,score);
      sdsfree(ele);
      arraylen += 2;

      /* Remove the key, if indeed needed. */
      if (zsetLength(zobj) == 0) {
          dbDelete(c->db,key);
          notifyKeyspaceEvent(NOTIFY_GENERIC(1<<2),"del",key,c->db->id);
          break;
      }
  } while(--count);

  setDeferredArrayLen(c,arraylen_ptr,arraylen + (emitkey != 0));
3891}

3893/* ZPOPMIN key [<count>] */
3894void zpopminCommand(client *c) {
  if (c->argc > 3) {
      addReplyErrorObject(c,shared.syntaxerr);
      return;
  }
  genericZpopCommand(c,&c->argv[1],1,ZSET_MIN0,0,
      c->argc == 3 ? c->argv[2] : NULL((void*)0));
3901}

3903/* ZMAXPOP key [<count>] */
3904void zpopmaxCommand(client *c) {
  if (c->argc > 3) {
      addReplyErrorObject(c,shared.syntaxerr);
      return;
  }
  genericZpopCommand(c,&c->argv[1],1,ZSET_MAX1,0,
      c->argc == 3 ? c->argv[2] : NULL((void*)0));
3911}

3913/* BZPOPMIN / BZPOPMAX actual implementation. */
3914void blockingGenericZpopCommand(client *c, int where) {
  robj *o;
  mstime_t timeout;
  int j;

  if (getTimeoutFromObjectOrReply(c,c->argv[c->argc-1],&timeout,UNIT_SECONDS0)
      != C_OK0) return;

  for (j = 1; j < c->argc-1; j++) {
      o = lookupKeyWrite(c->db,c->argv[j]);
      if (checkType(c,o,OBJ_ZSET3)) return;
      if (o != NULL((void*)0)) {
          if (zsetLength(o) != 0) {
              /* Non empty zset, this is like a normal ZPOP[MIN|MAX]. */
              genericZpopCommand(c,&c->argv[j],1,where,1,NULL((void*)0));
              /* Replicate it as an ZPOP[MIN|MAX] instead of BZPOP[MIN|MAX]. */
              rewriteClientCommandVector(c,2,
                  where == ZSET_MAX1 ? shared.zpopmax : shared.zpopmin,
                  c->argv[j]);
              return;
          }
      }
  }

  /* If we are not allowed to block the client and the zset is empty the only thing
   * we can do is treating it as a timeout (even with timeout 0). */
  if (c->flags & CLIENT_DENY_BLOCKING(1ULL<<41)) {
      addReplyNullArray(c);
      return;
  }

  /* If the keys do not exist we must block */
  blockForKeys(c,BLOCKED_ZSET5,c->argv + 1,c->argc - 2,timeout,NULL((void*)0),NULL((void*)0),NULL((void*)0));
3947}

3949// BZPOPMIN key [key ...] timeout
3950void bzpopminCommand(client *c) {
  blockingGenericZpopCommand(c,ZSET_MIN0);
3952}

3954// BZPOPMAX key [key ...] timeout
3955void bzpopmaxCommand(client *c) {
  blockingGenericZpopCommand(c,ZSET_MAX1);
3957}

3959static void zarndmemberReplyWithZiplist(client *c, unsigned int count, ziplistEntry *keys, ziplistEntry *vals) {
  for (unsigned long i = 0; i < count; i++) {
      if (vals && c->resp > 2)
          addReplyArrayLen(c,2);
      if (keys[i].sval)
          addReplyBulkCBuffer(c, keys[i].sval, keys[i].slen);
      else
          addReplyBulkLongLong(c, keys[i].lval);
      if (vals) {
          if (vals[i].sval) {
              addReplyDouble(c, zzlStrtod(vals[i].sval,vals[i].slen));
          } else
              addReplyDouble(c, vals[i].lval);
      }
  }
3974}

3976/* How many times bigger should be the zset compared to the requested size
* for us to not use the "remove elements" strategy? Read later in the
* implementation for more info. */
3979#define ZRANDMEMBER_SUB_STRATEGY_MUL3 3

3981/* If client is trying to ask for a very large number of random elements,
* queuing may consume an unlimited amount of memory, so we want to limit
* the number of randoms per time. */
3984#define ZRANDMEMBER_RANDOM_SAMPLE_LIMIT1000 1000

3986void zrandmemberWithCountCommand(client *c, long l, int withscores) {
  unsigned long count, size;
  int uniq = 1;
  robj *zsetobj;

  if ((zsetobj = lookupKeyReadOrReply(c, c->argv[1], shared.null[c->resp]))
      == NULL((void*)0) || checkType(c, zsetobj, OBJ_ZSET3)) return;
  size = zsetLength(zsetobj);

  if(l >= 0) {
      count = (unsigned long) l;
  } else {
      count = -l;
      uniq = 0;
  }

  /* If count is zero, serve it ASAP to avoid special cases later. */
  if (count == 0) {
      addReply(c,shared.emptyarray);
      return;
  }

  /* CASE 1: The count was negative, so the extraction method is just:
   * "return N random elements" sampling the whole set every time.
   * This case is trivial and can be served without auxiliary data
   * structures. This case is the only one that also needs to return the
   * elements in random order. */
  if (!uniq || count == 1) {
      if (withscores && c->resp == 2)
          addReplyArrayLen(c, count*2);
      else
          addReplyArrayLen(c, count);
      if (zsetobj->encoding == OBJ_ENCODING_SKIPLIST7) {
          zset *zs = zsetobj->ptr;
          while (count--) {
              dictEntry *de = dictGetFairRandomKey(zs->dict);
              sds key = dictGetKey(de)((de)->key);
              if (withscores && c->resp > 2)
                  addReplyArrayLen(c,2);
              addReplyBulkCBuffer(c, key, sdslen(key));
              if (withscores)
                  addReplyDouble(c, dictGetDoubleVal(de)((de)->v.d));
          }
      } else if (zsetobj->encoding == OBJ_ENCODING_ZIPLIST5) {
          ziplistEntry *keys, *vals = NULL((void*)0);
          unsigned long limit, sample_count;
          limit = count > ZRANDMEMBER_RANDOM_SAMPLE_LIMIT1000 ? ZRANDMEMBER_RANDOM_SAMPLE_LIMIT1000 : count;
          keys = zmalloc(sizeof(ziplistEntry)*limit);
          if (withscores)
              vals = zmalloc(sizeof(ziplistEntry)*limit);
          while (count) {
              sample_count = count > limit ? limit : count;
              count -= sample_count;
              ziplistRandomPairs(zsetobj->ptr, sample_count, keys, vals);
              zarndmemberReplyWithZiplist(c, sample_count, keys, vals);
          }
          zfree(keys);
          zfree(vals);
      }
      return;
  }

  zsetopsrc src;
  zsetopval zval;
  src.subject = zsetobj;
  src.type = zsetobj->type;
  src.encoding = zsetobj->encoding;
  zuiInitIterator(&src);
  memset(&zval, 0, sizeof(zval));

  /* Initiate reply count, RESP3 responds with nested array, RESP2 with flat one. */
  long reply_size = count < size ? count : size;
  if (withscores && c->resp == 2)
      addReplyArrayLen(c, reply_size*2);
  else
      addReplyArrayLen(c, reply_size);

  /* CASE 2:
  * The number of requested elements is greater than the number of
  * elements inside the zset: simply return the whole zset. */
  if (count >= size) {
      while (zuiNext(&src, &zval)) {
          if (withscores && c->resp > 2)
              addReplyArrayLen(c,2);
          addReplyBulkSds(c, zuiNewSdsFromValue(&zval));
          if (withscores)
              addReplyDouble(c, zval.score);
      }
      return;
  }

  /* CASE 3:
   * The number of elements inside the zset is not greater than
   * ZRANDMEMBER_SUB_STRATEGY_MUL times the number of requested elements.
   * In this case we create a dict from scratch with all the elements, and
   * subtract random elements to reach the requested number of elements.
   *
   * This is done because if the number of requested elements is just
   * a bit less than the number of elements in the set, the natural approach
   * used into CASE 4 is highly inefficient. */
  if (count*ZRANDMEMBER_SUB_STRATEGY_MUL3 > size) {
      dict *d = dictCreate(&sdsReplyDictType, NULL((void*)0));
      dictExpand(d, size);
      /* Add all the elements into the temporary dictionary. */
      while (zuiNext(&src, &zval)) {
          sds key = zuiNewSdsFromValue(&zval);
          dictEntry *de = dictAddRaw(d, key, NULL((void*)0));
          serverAssert(de)((de)?(void)0 : (_serverAssert("de","t_zset.c",4093),__builtin_unreachable
()));
          if (withscores)
              dictSetDoubleVal(de, zval.score)do { (de)->v.d = zval.score; } while(0);
      }
      serverAssert(dictSize(d) == size)((((d)->ht[0].used+(d)->ht[1].used) == size)?(void)0 : (
_serverAssert("dictSize(d) == size","t_zset.c",4097),__builtin_unreachable
()));

      /* Remove random elements to reach the right count. */
      while (size > count) {
          dictEntry *de;
          de = dictGetRandomKey(d);
          dictUnlink(d,dictGetKey(de)((de)->key));
          sdsfree(dictGetKey(de)((de)->key));
          dictFreeUnlinkedEntry(d,de);
          size--;
      }

      /* Reply with what's in the dict and release memory */
      dictIterator *di;
      dictEntry *de;
      di = dictGetIterator(d);
      while ((de = dictNext(di)) != NULL((void*)0)) {
          if (withscores && c->resp > 2)
              addReplyArrayLen(c,2);
          addReplyBulkSds(c, dictGetKey(de)((de)->key));
          if (withscores)
              addReplyDouble(c, dictGetDoubleVal(de)((de)->v.d));
      }

      dictReleaseIterator(di);
      dictRelease(d);
  }

  /* CASE 4: We have a big zset compared to the requested number of elements.
   * In this case we can simply get random elements from the zset and add
   * to the temporary set, trying to eventually get enough unique elements
   * to reach the specified count. */
  else {
      if (zsetobj->encoding == OBJ_ENCODING_ZIPLIST5) {
          /* it is inefficient to repeatedly pick one random element from a
           * ziplist. so we use this instead: */
          ziplistEntry *keys, *vals = NULL((void*)0);
          keys = zmalloc(sizeof(ziplistEntry)*count);
          if (withscores)
              vals = zmalloc(sizeof(ziplistEntry)*count);
          serverAssert(ziplistRandomPairsUnique(zsetobj->ptr, count, keys, vals) == count)((ziplistRandomPairsUnique(zsetobj->ptr, count, keys, vals
) == count)?(void)0 : (_serverAssert("ziplistRandomPairsUnique(zsetobj->ptr, count, keys, vals) == count"
,"t_zset.c",4137),__builtin_unreachable()));
          zarndmemberReplyWithZiplist(c, count, keys, vals);
          zfree(keys);
          zfree(vals);
          return;
      }

      /* Hashtable encoding (generic implementation) */
      unsigned long added = 0;
      dict *d = dictCreate(&hashDictType, NULL((void*)0));
      dictExpand(d, count);

      while (added < count) {
          ziplistEntry key;
          double score;
          zsetTypeRandomElement(zsetobj, size, &key, withscores ? &score: NULL((void*)0));

          /* Try to add the object to the dictionary. If it already exists
          * free it, otherwise increment the number of objects we have
          * in the result dictionary. */
          sds skey = zsetSdsFromZiplistEntry(&key);
          if (dictAdd(d,skey,NULL((void*)0)) != DICT_OK0) {
              sdsfree(skey);
              continue;
          }
          added++;

          if (withscores && c->resp > 2)
              addReplyArrayLen(c,2);
          zsetReplyFromZiplistEntry(c, &key);
          if (withscores)
              addReplyDouble(c, score);
      }

      /* Release memory */
      dictRelease(d);
  }
4174}

4176/* ZRANDMEMBER [<count> WITHSCORES] */
4177void zrandmemberCommand(client *c) {
  long l;
  int withscores = 0;
  robj *zset;
  ziplistEntry ele;

  if (c->argc >= 3) {
      if (getLongFromObjectOrReply(c,c->argv[2],&l,NULL((void*)0)) != C_OK0) return;
      if (c->argc > 4 || (c->argc == 4 && strcasecmp(c->argv[3]->ptr,"withscores"))) {
          addReplyErrorObject(c,shared.syntaxerr);
          return;
      } else if (c->argc == 4)
          withscores = 1;
      zrandmemberWithCountCommand(c, l, withscores);
      return;
  }

  /* Handle variant without <count> argument. Reply with simple bulk string */
  if ((zset = lookupKeyReadOrReply(c,c->argv[1],shared.null[c->resp]))== NULL((void*)0) ||
      checkType(c,zset,OBJ_ZSET3)) {
      return;
  }

  zsetTypeRandomElement(zset, zsetLength(zset), &ele,NULL((void*)0));
  zsetReplyFromZiplistEntry(c,&ele);
4202}