4 years ago · 109de9ca9e
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,4 @@
 
				+.vscode/
			
 
				+obj/
			
 
				+sv
			
 
				+
			
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
--- a/Makefile
+++ b/Makefile
@@ -0,0 +1,55 @@
 
				+CFLAGS += -std=c99 -Wall -O2 -D_REENTRANT
			
 
				+LIBS := -lm -luv
			
 
				+
			
 
				+# Check OS
			
 
				+TARGET_OS := $(shell uname -s | tr 'A-Z' 'a-z' 2>/dev/null || echo unknown)
			
 
				+ifeq ($(TARGET_OS), linux)
			
 
				+	CFLAGS += -D_POSIX_C_SOUCE=200212L -D_BSD_SOURCE -D_DEFAULT_SOURCE
			
 
				+	LIBS += -ldl
			
 
				+	LDFLAGS += -Wl,-E
			
 
				+endif
			
 
				+
			
 
				+SRC := main.c session.c logger.c mt19937-64.c dict.c zmalloc.c redisassert.c \
			
 
				+	siphash.c
			
 
				+BIN := sv
			
 
				+VER ?= $(shell git describe --tags --always --dirty)
			
 
				+
			
 
				+# OBJ Dir
			
 
				+ODIR := obj
			
 
				+OBJ := $(patsubst %.c,$(ODIR)/%.o,$(SRC))
			
 
				+THIRD := third
			
 
				+
			
 
				+## Dependencies
			
 
				+
			
 
				+# llhttp
			
 
				+DEPS += $(THIRD)/llhttp/libllhttp.a
			
 
				+CFLAGS += -I$(THIRD)/llhttp
			
 
				+LDFLAGS += -L$(THIRD)/llhttp
			
 
				+LIBS += -l:libllhttp.a
			
 
				+
			
 
				+all: $(BIN)
			
 
				+
			
 
				+clean:
			
 
				+	$(RM) -rf $(BIN)
			
 
				+	$(RM) -rf $(OBJ)
			
 
				+
			
 
				+$(BIN): $(OBJ)
			
 
				+	@echo LINK $(BIN)
			
 
				+	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
			
 
				+
			
 
				+$(OBJ): $(ODIR)
			
 
				+
			
 
				+$(ODIR):
			
 
				+	mkdir -p $@
			
 
				+
			
 
				+$(ODIR)/%.o: %.c
			
 
				+	@echo CC $<
			
 
				+	$(CC) $(CFLAGS) -c $< -o $@
			
 
				+
			
 
				+.PHONY: all clean
			
 
				+
			
 
				+.SUFFIXES:
			
 
				+.SUFFIXES: .c .o
			
 
				+
			
 
				+vpath %c src
			
 
				+vpath %h src
			
--- a/README.md
+++ b/README.md
@@ -0,0 +1,19 @@
 
				+## Server
			
 
				+
			
 
				+Toy project for joy!
			
 
				+
			
 
				+## Why
			
 
				+
			
 
				+For nowadays Im hard to count any noble applications have to be developed in C.
			
 
				+
			
 
				+But in my heart the C is the most beautiful language all over the world. precise, consice while elegent.
			
 
				+
			
 
				+I never be an expert in C.
			
 
				+
			
 
				+In fact, im alway a newbee in the C world. a followed lover.
			
 
				+
			
 
				+I'd like to practise C whenever i have time.
			
 
				+
			
 
				+I will be feeling other languages ugly and quick(developing) after i was using C for a while.
			
 
				+
			
 
				+Revealing all magic in programming by learning C.
			
--- a/docs/ws.html
+++ b/docs/ws.html
@@ -0,0 +1,25 @@
 
				+<!DOCTYPE html>
			
 
				+<html>
			
 
				+    <head>
			
 
				+        <title>ws client</title>
			
 
				+    </head>
			
 
				+    <body>
			
 
				+        <script type="text/javascript">
			
 
				+            let ws = new WebSocket('ws://localhost:8001')
			
 
				+
			
 
				+            ws.onopen = () => {
			
 
				+                console.log('connection opened')
			
 
				+            }
			
 
				+
			
 
				+            ws.onclose = () => {
			
 
				+                console.log('connection closed')
			
 
				+            }
			
 
				+
			
 
				+            ws.onmessage = (ev) => {
			
 
				+                console.log('received:' + ev)
			
 
				+            }
			
 
				+
			
 
				+            ws.send(JSON.stringify({a: 1, b: 2}))
			
 
				+        </script>
			
 
				+    </body>
			
 
				+</html>
			
--- a/src/adlist.c
+++ b/src/adlist.c
@@ -0,0 +1,383 @@
 
				+/* adlist.c - A generic doubly linked list implementation
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+#include <stdlib.h>
			
 
				+#include "adlist.h"
			
 
				+#include "zmalloc.h"
			
 
				+
			
 
				+/* Create a new list. The created list can be freed with
			
 
				+ * listRelease(), but private value of every node need to be freed
			
 
				+ * by the user before to call listRelease(), or by setting a free method using
			
 
				+ * listSetFreeMethod.
			
 
				+ *
			
 
				+ * On error, NULL is returned. Otherwise the pointer to the new list. */
			
 
				+list *listCreate(void)
			
 
				+{
			
 
				+    struct list *list;
			
 
				+
			
 
				+    if ((list = zmalloc(sizeof(*list))) == NULL)
			
 
				+        return NULL;
			
 
				+    list->head = list->tail = NULL;
			
 
				+    list->len = 0;
			
 
				+    list->dup = NULL;
			
 
				+    list->free = NULL;
			
 
				+    list->match = NULL;
			
 
				+    return list;
			
 
				+}
			
 
				+
			
 
				+/* Remove all the elements from the list without destroying the list itself. */
			
 
				+void listEmpty(list *list)
			
 
				+{
			
 
				+    unsigned long len;
			
 
				+    listNode *current, *next;
			
 
				+
			
 
				+    current = list->head;
			
 
				+    len = list->len;
			
 
				+    while(len--) {
			
 
				+        next = current->next;
			
 
				+        if (list->free) list->free(current->value);
			
 
				+        zfree(current);
			
 
				+        current = next;
			
 
				+    }
			
 
				+    list->head = list->tail = NULL;
			
 
				+    list->len = 0;
			
 
				+}
			
 
				+
			
 
				+/* Free the whole list.
			
 
				+ *
			
 
				+ * This function can't fail. */
			
 
				+void listRelease(list *list)
			
 
				+{
			
 
				+    listEmpty(list);
			
 
				+    zfree(list);
			
 
				+}
			
 
				+
			
 
				+/* Add a new node to the list, to head, containing the specified 'value'
			
 
				+ * pointer as value.
			
 
				+ *
			
 
				+ * On error, NULL is returned and no operation is performed (i.e. the
			
 
				+ * list remains unaltered).
			
 
				+ * On success the 'list' pointer you pass to the function is returned. */
			
 
				+list *listAddNodeHead(list *list, void *value)
			
 
				+{
			
 
				+    listNode *node;
			
 
				+
			
 
				+    if ((node = zmalloc(sizeof(*node))) == NULL)
			
 
				+        return NULL;
			
 
				+    node->value = value;
			
 
				+    if (list->len == 0) {
			
 
				+        list->head = list->tail = node;
			
 
				+        node->prev = node->next = NULL;
			
 
				+    } else {
			
 
				+        node->prev = NULL;
			
 
				+        node->next = list->head;
			
 
				+        list->head->prev = node;
			
 
				+        list->head = node;
			
 
				+    }
			
 
				+    list->len++;
			
 
				+    return list;
			
 
				+}
			
 
				+
			
 
				+/* Add a new node to the list, to tail, containing the specified 'value'
			
 
				+ * pointer as value.
			
 
				+ *
			
 
				+ * On error, NULL is returned and no operation is performed (i.e. the
			
 
				+ * list remains unaltered).
			
 
				+ * On success the 'list' pointer you pass to the function is returned. */
			
 
				+list *listAddNodeTail(list *list, void *value)
			
 
				+{
			
 
				+    listNode *node;
			
 
				+
			
 
				+    if ((node = zmalloc(sizeof(*node))) == NULL)
			
 
				+        return NULL;
			
 
				+    node->value = value;
			
 
				+    if (list->len == 0) {
			
 
				+        list->head = list->tail = node;
			
 
				+        node->prev = node->next = NULL;
			
 
				+    } else {
			
 
				+        node->prev = list->tail;
			
 
				+        node->next = NULL;
			
 
				+        list->tail->next = node;
			
 
				+        list->tail = node;
			
 
				+    }
			
 
				+    list->len++;
			
 
				+    return list;
			
 
				+}
			
 
				+
			
 
				+list *listInsertNode(list *list, listNode *old_node, void *value, int after) {
			
 
				+    listNode *node;
			
 
				+
			
 
				+    if ((node = zmalloc(sizeof(*node))) == NULL)
			
 
				+        return NULL;
			
 
				+    node->value = value;
			
 
				+    if (after) {
			
 
				+        node->prev = old_node;
			
 
				+        node->next = old_node->next;
			
 
				+        if (list->tail == old_node) {
			
 
				+            list->tail = node;
			
 
				+        }
			
 
				+    } else {
			
 
				+        node->next = old_node;
			
 
				+        node->prev = old_node->prev;
			
 
				+        if (list->head == old_node) {
			
 
				+            list->head = node;
			
 
				+        }
			
 
				+    }
			
 
				+    if (node->prev != NULL) {
			
 
				+        node->prev->next = node;
			
 
				+    }
			
 
				+    if (node->next != NULL) {
			
 
				+        node->next->prev = node;
			
 
				+    }
			
 
				+    list->len++;
			
 
				+    return list;
			
 
				+}
			
 
				+
			
 
				+/* Remove the specified node from the specified list.
			
 
				+ * It's up to the caller to free the private value of the node.
			
 
				+ *
			
 
				+ * This function can't fail. */
			
 
				+void listDelNode(list *list, listNode *node)
			
 
				+{
			
 
				+    if (node->prev)
			
 
				+        node->prev->next = node->next;
			
 
				+    else
			
 
				+        list->head = node->next;
			
 
				+    if (node->next)
			
 
				+        node->next->prev = node->prev;
			
 
				+    else
			
 
				+        list->tail = node->prev;
			
 
				+    if (list->free) list->free(node->value);
			
 
				+    zfree(node);
			
 
				+    list->len--;
			
 
				+}
			
 
				+
			
 
				+/* Returns a list iterator 'iter'. After the initialization every
			
 
				+ * call to listNext() will return the next element of the list.
			
 
				+ *
			
 
				+ * This function can't fail. */
			
 
				+listIter *listGetIterator(list *list, int direction)
			
 
				+{
			
 
				+    listIter *iter;
			
 
				+
			
 
				+    if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;
			
 
				+    if (direction == AL_START_HEAD)
			
 
				+        iter->next = list->head;
			
 
				+    else
			
 
				+        iter->next = list->tail;
			
 
				+    iter->direction = direction;
			
 
				+    return iter;
			
 
				+}
			
 
				+
			
 
				+/* Release the iterator memory */
			
 
				+void listReleaseIterator(listIter *iter) {
			
 
				+    zfree(iter);
			
 
				+}
			
 
				+
			
 
				+/* Create an iterator in the list private iterator structure */
			
 
				+void listRewind(list *list, listIter *li) {
			
 
				+    li->next = list->head;
			
 
				+    li->direction = AL_START_HEAD;
			
 
				+}
			
 
				+
			
 
				+void listRewindTail(list *list, listIter *li) {
			
 
				+    li->next = list->tail;
			
 
				+    li->direction = AL_START_TAIL;
			
 
				+}
			
 
				+
			
 
				+/* Return the next element of an iterator.
			
 
				+ * It's valid to remove the currently returned element using
			
 
				+ * listDelNode(), but not to remove other elements.
			
 
				+ *
			
 
				+ * The function returns a pointer to the next element of the list,
			
 
				+ * or NULL if there are no more elements, so the classical usage
			
 
				+ * pattern is:
			
 
				+ *
			
 
				+ * iter = listGetIterator(list,<direction>);
			
 
				+ * while ((node = listNext(iter)) != NULL) {
			
 
				+ *     doSomethingWith(listNodeValue(node));
			
 
				+ * }
			
 
				+ *
			
 
				+ * */
			
 
				+listNode *listNext(listIter *iter)
			
 
				+{
			
 
				+    listNode *current = iter->next;
			
 
				+
			
 
				+    if (current != NULL) {
			
 
				+        if (iter->direction == AL_START_HEAD)
			
 
				+            iter->next = current->next;
			
 
				+        else
			
 
				+            iter->next = current->prev;
			
 
				+    }
			
 
				+    return current;
			
 
				+}
			
 
				+
			
 
				+/* Duplicate the whole list. On out of memory NULL is returned.
			
 
				+ * On success a copy of the original list is returned.
			
 
				+ *
			
 
				+ * The 'Dup' method set with listSetDupMethod() function is used
			
 
				+ * to copy the node value. Otherwise the same pointer value of
			
 
				+ * the original node is used as value of the copied node.
			
 
				+ *
			
 
				+ * The original list both on success or error is never modified. */
			
 
				+list *listDup(list *orig)
			
 
				+{
			
 
				+    list *copy;
			
 
				+    listIter iter;
			
 
				+    listNode *node;
			
 
				+
			
 
				+    if ((copy = listCreate()) == NULL)
			
 
				+        return NULL;
			
 
				+    copy->dup = orig->dup;
			
 
				+    copy->free = orig->free;
			
 
				+    copy->match = orig->match;
			
 
				+    listRewind(orig, &iter);
			
 
				+    while((node = listNext(&iter)) != NULL) {
			
 
				+        void *value;
			
 
				+
			
 
				+        if (copy->dup) {
			
 
				+            value = copy->dup(node->value);
			
 
				+            if (value == NULL) {
			
 
				+                listRelease(copy);
			
 
				+                return NULL;
			
 
				+            }
			
 
				+        } else {
			
 
				+            value = node->value;
			
 
				+        }
			
 
				+        
			
 
				+        if (listAddNodeTail(copy, value) == NULL) {
			
 
				+            /* Free value if dup succeed but listAddNodeTail failed. */
			
 
				+            if (copy->free) copy->free(value);
			
 
				+
			
 
				+            listRelease(copy);
			
 
				+            return NULL;
			
 
				+        }
			
 
				+    }
			
 
				+    return copy;
			
 
				+}
			
 
				+
			
 
				+/* Search the list for a node matching a given key.
			
 
				+ * The match is performed using the 'match' method
			
 
				+ * set with listSetMatchMethod(). If no 'match' method
			
 
				+ * is set, the 'value' pointer of every node is directly
			
 
				+ * compared with the 'key' pointer.
			
 
				+ *
			
 
				+ * On success the first matching node pointer is returned
			
 
				+ * (search starts from head). If no matching node exists
			
 
				+ * NULL is returned. */
			
 
				+listNode *listSearchKey(list *list, void *key)
			
 
				+{
			
 
				+    listIter iter;
			
 
				+    listNode *node;
			
 
				+
			
 
				+    listRewind(list, &iter);
			
 
				+    while((node = listNext(&iter)) != NULL) {
			
 
				+        if (list->match) {
			
 
				+            if (list->match(node->value, key)) {
			
 
				+                return node;
			
 
				+            }
			
 
				+        } else {
			
 
				+            if (key == node->value) {
			
 
				+                return node;
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* Return the element at the specified zero-based index
			
 
				+ * where 0 is the head, 1 is the element next to head
			
 
				+ * and so on. Negative integers are used in order to count
			
 
				+ * from the tail, -1 is the last element, -2 the penultimate
			
 
				+ * and so on. If the index is out of range NULL is returned. */
			
 
				+listNode *listIndex(list *list, long index) {
			
 
				+    listNode *n;
			
 
				+
			
 
				+    if (index < 0) {
			
 
				+        index = (-index)-1;
			
 
				+        n = list->tail;
			
 
				+        while(index-- && n) n = n->prev;
			
 
				+    } else {
			
 
				+        n = list->head;
			
 
				+        while(index-- && n) n = n->next;
			
 
				+    }
			
 
				+    return n;
			
 
				+}
			
 
				+
			
 
				+/* Rotate the list removing the tail node and inserting it to the head. */
			
 
				+void listRotateTailToHead(list *list) {
			
 
				+    if (listLength(list) <= 1) return;
			
 
				+
			
 
				+    /* Detach current tail */
			
 
				+    listNode *tail = list->tail;
			
 
				+    list->tail = tail->prev;
			
 
				+    list->tail->next = NULL;
			
 
				+    /* Move it as head */
			
 
				+    list->head->prev = tail;
			
 
				+    tail->prev = NULL;
			
 
				+    tail->next = list->head;
			
 
				+    list->head = tail;
			
 
				+}
			
 
				+
			
 
				+/* Rotate the list removing the head node and inserting it to the tail. */
			
 
				+void listRotateHeadToTail(list *list) {
			
 
				+    if (listLength(list) <= 1) return;
			
 
				+
			
 
				+    listNode *head = list->head;
			
 
				+    /* Detach current head */
			
 
				+    list->head = head->next;
			
 
				+    list->head->prev = NULL;
			
 
				+    /* Move it as tail */
			
 
				+    list->tail->next = head;
			
 
				+    head->next = NULL;
			
 
				+    head->prev = list->tail;
			
 
				+    list->tail = head;
			
 
				+}
			
 
				+
			
 
				+/* Add all the elements of the list 'o' at the end of the
			
 
				+ * list 'l'. The list 'other' remains empty but otherwise valid. */
			
 
				+void listJoin(list *l, list *o) {
			
 
				+    if (o->len == 0) return;
			
 
				+
			
 
				+    o->head->prev = l->tail;
			
 
				+
			
 
				+    if (l->tail)
			
 
				+        l->tail->next = o->head;
			
 
				+    else
			
 
				+        l->head = o->head;
			
 
				+
			
 
				+    l->tail = o->tail;
			
 
				+    l->len += o->len;
			
 
				+
			
 
				+    /* Setup other as an empty list. */
			
 
				+    o->head = o->tail = NULL;
			
 
				+    o->len = 0;
			
 
				+}
			
--- a/src/adlist.h
+++ b/src/adlist.h
@@ -0,0 +1,96 @@
 
				+/* adlist.h - A generic doubly linked list implementation
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __ADLIST_H__
			
 
				+#define __ADLIST_H__
			
 
				+
			
 
				+/* Node, List, and Iterator are the only data structures used currently. */
			
 
				+
			
 
				+typedef struct listNode {
			
 
				+    struct listNode *prev;
			
 
				+    struct listNode *next;
			
 
				+    void *value;
			
 
				+} listNode;
			
 
				+
			
 
				+typedef struct listIter {
			
 
				+    listNode *next;
			
 
				+    int direction;
			
 
				+} listIter;
			
 
				+
			
 
				+typedef struct list {
			
 
				+    listNode *head;
			
 
				+    listNode *tail;
			
 
				+    void *(*dup)(void *ptr);
			
 
				+    void (*free)(void *ptr);
			
 
				+    int (*match)(void *ptr, void *key);
			
 
				+    unsigned long len;
			
 
				+} list;
			
 
				+
			
 
				+/* Functions implemented as macros */
			
 
				+#define listLength(l) ((l)->len)
			
 
				+#define listFirst(l) ((l)->head)
			
 
				+#define listLast(l) ((l)->tail)
			
 
				+#define listPrevNode(n) ((n)->prev)
			
 
				+#define listNextNode(n) ((n)->next)
			
 
				+#define listNodeValue(n) ((n)->value)
			
 
				+
			
 
				+#define listSetDupMethod(l,m) ((l)->dup = (m))
			
 
				+#define listSetFreeMethod(l,m) ((l)->free = (m))
			
 
				+#define listSetMatchMethod(l,m) ((l)->match = (m))
			
 
				+
			
 
				+#define listGetDupMethod(l) ((l)->dup)
			
 
				+#define listGetFreeMethod(l) ((l)->free)
			
 
				+#define listGetMatchMethod(l) ((l)->match)
			
 
				+
			
 
				+/* Prototypes */
			
 
				+list *listCreate(void);
			
 
				+void listRelease(list *list);
			
 
				+void listEmpty(list *list);
			
 
				+list *listAddNodeHead(list *list, void *value);
			
 
				+list *listAddNodeTail(list *list, void *value);
			
 
				+list *listInsertNode(list *list, listNode *old_node, void *value, int after);
			
 
				+void listDelNode(list *list, listNode *node);
			
 
				+listIter *listGetIterator(list *list, int direction);
			
 
				+listNode *listNext(listIter *iter);
			
 
				+void listReleaseIterator(listIter *iter);
			
 
				+list *listDup(list *orig);
			
 
				+listNode *listSearchKey(list *list, void *key);
			
 
				+listNode *listIndex(list *list, long index);
			
 
				+void listRewind(list *list, listIter *li);
			
 
				+void listRewindTail(list *list, listIter *li);
			
 
				+void listRotateTailToHead(list *list);
			
 
				+void listRotateHeadToTail(list *list);
			
 
				+void listJoin(list *l, list *o);
			
 
				+
			
 
				+/* Directions for iterators */
			
 
				+#define AL_START_HEAD 0
			
 
				+#define AL_START_TAIL 1
			
 
				+
			
 
				+#endif /* __ADLIST_H__ */
			
--- a/src/atomicvar.h
+++ b/src/atomicvar.h
@@ -0,0 +1,158 @@
 
				+/* This file implements atomic counters using c11 _Atomic, __atomic or __sync
			
 
				+ * macros if available, otherwise we will throw an error when compile.
			
 
				+ *
			
 
				+ * The exported interface is composed of three macros:
			
 
				+ *
			
 
				+ * atomicIncr(var,count) -- Increment the atomic counter
			
 
				+ * atomicGetIncr(var,oldvalue_var,count) -- Get and increment the atomic counter
			
 
				+ * atomicDecr(var,count) -- Decrement the atomic counter
			
 
				+ * atomicGet(var,dstvar) -- Fetch the atomic counter value
			
 
				+ * atomicSet(var,value)  -- Set the atomic counter value
			
 
				+ * atomicGetWithSync(var,value)  -- 'atomicGet' with inter-thread synchronization
			
 
				+ * atomicSetWithSync(var,value)  -- 'atomicSet' with inter-thread synchronization
			
 
				+ *
			
 
				+ * Never use return value from the macros, instead use the AtomicGetIncr()
			
 
				+ * if you need to get the current value and increment it atomically, like
			
 
				+ * in the following example:
			
 
				+ *
			
 
				+ *  long oldvalue;
			
 
				+ *  atomicGetIncr(myvar,oldvalue,1);
			
 
				+ *  doSomethingWith(oldvalue);
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2015, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#include <pthread.h>
			
 
				+#include "config.h"
			
 
				+
			
 
				+#ifndef __ATOMIC_VAR_H
			
 
				+#define __ATOMIC_VAR_H
			
 
				+
			
 
				+/* Define redisAtomic for atomic variable. */
			
 
				+#define redisAtomic
			
 
				+
			
 
				+/* To test Redis with Helgrind (a Valgrind tool) it is useful to define
			
 
				+ * the following macro, so that __sync macros are used: those can be detected
			
 
				+ * by Helgrind (even if they are less efficient) so that no false positive
			
 
				+ * is reported. */
			
 
				+// #define __ATOMIC_VAR_FORCE_SYNC_MACROS
			
 
				+
			
 
				+/* There will be many false positives if we test Redis with Helgrind, since
			
 
				+ * Helgrind can't understand we have imposed ordering on the program, so
			
 
				+ * we use macros in helgrind.h to tell Helgrind inter-thread happens-before
			
 
				+ * relationship explicitly for avoiding false positives.
			
 
				+ *
			
 
				+ * For more details, please see: valgrind/helgrind.h and
			
 
				+ * https://www.valgrind.org/docs/manual/hg-manual.html#hg-manual.effective-use
			
 
				+ *
			
 
				+ * These macros take effect only when 'make helgrind', and you must first
			
 
				+ * install Valgrind in the default path configuration. */
			
 
				+#ifdef __ATOMIC_VAR_FORCE_SYNC_MACROS
			
 
				+#include <valgrind/helgrind.h>
			
 
				+#else
			
 
				+#define ANNOTATE_HAPPENS_BEFORE(v) ((void) v)
			
 
				+#define ANNOTATE_HAPPENS_AFTER(v)  ((void) v)
			
 
				+#endif
			
 
				+
			
 
				+#if !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && defined(__STDC_VERSION__) && \
			
 
				+    (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)
			
 
				+/* Use '_Atomic' keyword if the compiler supports. */
			
 
				+#undef  redisAtomic
			
 
				+#define redisAtomic _Atomic
			
 
				+/* Implementation using _Atomic in C11. */
			
 
				+
			
 
				+#include <stdatomic.h>
			
 
				+#define atomicIncr(var,count) atomic_fetch_add_explicit(&var,(count),memory_order_relaxed)
			
 
				+#define atomicGetIncr(var,oldvalue_var,count) do { \
			
 
				+    oldvalue_var = atomic_fetch_add_explicit(&var,(count),memory_order_relaxed); \
			
 
				+} while(0)
			
 
				+#define atomicDecr(var,count) atomic_fetch_sub_explicit(&var,(count),memory_order_relaxed)
			
 
				+#define atomicGet(var,dstvar) do { \
			
 
				+    dstvar = atomic_load_explicit(&var,memory_order_relaxed); \
			
 
				+} while(0)
			
 
				+#define atomicSet(var,value) atomic_store_explicit(&var,value,memory_order_relaxed)
			
 
				+#define atomicGetWithSync(var,dstvar) do { \
			
 
				+    dstvar = atomic_load_explicit(&var,memory_order_seq_cst); \
			
 
				+} while(0)
			
 
				+#define atomicSetWithSync(var,value) \
			
 
				+    atomic_store_explicit(&var,value,memory_order_seq_cst)
			
 
				+#define REDIS_ATOMIC_API "c11-builtin"
			
 
				+
			
 
				+#elif !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && \
			
 
				+    (!defined(__clang__) || !defined(__APPLE__) || __apple_build_version__ > 4210057) && \
			
 
				+    defined(__ATOMIC_RELAXED) && defined(__ATOMIC_SEQ_CST)
			
 
				+/* Implementation using __atomic macros. */
			
 
				+
			
 
				+#define atomicIncr(var,count) __atomic_add_fetch(&var,(count),__ATOMIC_RELAXED)
			
 
				+#define atomicGetIncr(var,oldvalue_var,count) do { \
			
 
				+    oldvalue_var = __atomic_fetch_add(&var,(count),__ATOMIC_RELAXED); \
			
 
				+} while(0)
			
 
				+#define atomicDecr(var,count) __atomic_sub_fetch(&var,(count),__ATOMIC_RELAXED)
			
 
				+#define atomicGet(var,dstvar) do { \
			
 
				+    dstvar = __atomic_load_n(&var,__ATOMIC_RELAXED); \
			
 
				+} while(0)
			
 
				+#define atomicSet(var,value) __atomic_store_n(&var,value,__ATOMIC_RELAXED)
			
 
				+#define atomicGetWithSync(var,dstvar) do { \
			
 
				+    dstvar = __atomic_load_n(&var,__ATOMIC_SEQ_CST); \
			
 
				+} while(0)
			
 
				+#define atomicSetWithSync(var,value) \
			
 
				+    __atomic_store_n(&var,value,__ATOMIC_SEQ_CST)
			
 
				+#define REDIS_ATOMIC_API "atomic-builtin"
			
 
				+
			
 
				+#elif defined(HAVE_ATOMIC)
			
 
				+/* Implementation using __sync macros. */
			
 
				+
			
 
				+#define atomicIncr(var,count) __sync_add_and_fetch(&var,(count))
			
 
				+#define atomicGetIncr(var,oldvalue_var,count) do { \
			
 
				+    oldvalue_var = __sync_fetch_and_add(&var,(count)); \
			
 
				+} while(0)
			
 
				+#define atomicDecr(var,count) __sync_sub_and_fetch(&var,(count))
			
 
				+#define atomicGet(var,dstvar) do { \
			
 
				+    dstvar = __sync_sub_and_fetch(&var,0); \
			
 
				+} while(0)
			
 
				+#define atomicSet(var,value) do { \
			
 
				+    while(!__sync_bool_compare_and_swap(&var,var,value)); \
			
 
				+} while(0)
			
 
				+/* Actually the builtin issues a full memory barrier by default. */
			
 
				+#define atomicGetWithSync(var,dstvar) { \
			
 
				+    dstvar = __sync_sub_and_fetch(&var,0,__sync_synchronize); \
			
 
				+    ANNOTATE_HAPPENS_AFTER(&var); \
			
 
				+} while(0)
			
 
				+#define atomicSetWithSync(var,value) do { \
			
 
				+    ANNOTATE_HAPPENS_BEFORE(&var);  \
			
 
				+    while(!__sync_bool_compare_and_swap(&var,var,value,__sync_synchronize)); \
			
 
				+} while(0)
			
 
				+#define REDIS_ATOMIC_API "sync-builtin"
			
 
				+
			
 
				+#else
			
 
				+#error "Unable to determine atomic operations for your platform"
			
 
				+
			
 
				+#endif
			
 
				+#endif /* __ATOMIC_VAR_H */
			
--- a/src/config.h
+++ b/src/config.h
@@ -0,0 +1,287 @@
 
				+/*
			
 
				+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __CONFIG_H
			
 
				+#define __CONFIG_H
			
 
				+
			
 
				+#ifdef __APPLE__
			
 
				+#include <fcntl.h> // for fcntl(fd, F_FULLFSYNC)
			
 
				+#include <AvailabilityMacros.h>
			
 
				+#endif
			
 
				+
			
 
				+#ifdef __linux__
			
 
				+#include <features.h>
			
 
				+#include <fcntl.h>
			
 
				+#endif
			
 
				+
			
 
				+/* Define redis_fstat to fstat or fstat64() */
			
 
				+#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
			
 
				+#define redis_fstat fstat64
			
 
				+#define redis_stat stat64
			
 
				+#else
			
 
				+#define redis_fstat fstat
			
 
				+#define redis_stat stat
			
 
				+#endif
			
 
				+
			
 
				+/* Test for proc filesystem */
			
 
				+#ifdef __linux__
			
 
				+#define HAVE_PROC_STAT 1
			
 
				+#define HAVE_PROC_MAPS 1
			
 
				+#define HAVE_PROC_SMAPS 1
			
 
				+#define HAVE_PROC_SOMAXCONN 1
			
 
				+#define HAVE_PROC_OOM_SCORE_ADJ 1
			
 
				+#endif
			
 
				+
			
 
				+/* Test for task_info() */
			
 
				+#if defined(__APPLE__)
			
 
				+#define HAVE_TASKINFO 1
			
 
				+#endif
			
 
				+
			
 
				+/* Test for backtrace() */
			
 
				+#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__)) || \
			
 
				+    defined(__FreeBSD__) || ((defined(__OpenBSD__) || defined(__NetBSD__)) && defined(USE_BACKTRACE))\
			
 
				+ || defined(__DragonFly__) || (defined(__UCLIBC__) && defined(__UCLIBC_HAS_BACKTRACE__))
			
 
				+#define HAVE_BACKTRACE 1
			
 
				+#endif
			
 
				+
			
 
				+/* MSG_NOSIGNAL. */
			
 
				+#ifdef __linux__
			
 
				+#define HAVE_MSG_NOSIGNAL 1
			
 
				+#endif
			
 
				+
			
 
				+/* Test for polling API */
			
 
				+#ifdef __linux__
			
 
				+#define HAVE_EPOLL 1
			
 
				+#endif
			
 
				+
			
 
				+/* Test for accept4() */
			
 
				+#ifdef __linux__
			
 
				+#define HAVE_ACCEPT4 1
			
 
				+#endif
			
 
				+
			
 
				+#if (defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined (__NetBSD__)
			
 
				+#define HAVE_KQUEUE 1
			
 
				+#endif
			
 
				+
			
 
				+#ifdef __sun
			
 
				+#include <sys/feature_tests.h>
			
 
				+#ifdef _DTRACE_VERSION
			
 
				+#define HAVE_EVPORT 1
			
 
				+#define HAVE_PSINFO 1
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+/* Define redis_fsync to fdatasync() in Linux and fsync() for all the rest */
			
 
				+#if defined(__linux__)
			
 
				+#define redis_fsync(fd) fdatasync(fd)
			
 
				+#elif defined(__APPLE__)
			
 
				+#define redis_fsync(fd) fcntl(fd, F_FULLFSYNC)
			
 
				+#else
			
 
				+#define redis_fsync(fd) fsync(fd)
			
 
				+#endif
			
 
				+
			
 
				+#if __GNUC__ >= 4
			
 
				+#define redis_unreachable __builtin_unreachable
			
 
				+#else
			
 
				+#define redis_unreachable abort
			
 
				+#endif
			
 
				+
			
 
				+#if __GNUC__ >= 3
			
 
				+#define likely(x) __builtin_expect(!!(x), 1)
			
 
				+#define unlikely(x) __builtin_expect(!!(x), 0)
			
 
				+#else
			
 
				+#define likely(x) (x)
			
 
				+#define unlikely(x) (x)
			
 
				+#endif
			
 
				+
			
 
				+#if defined(__has_attribute)
			
 
				+#if __has_attribute(no_sanitize)
			
 
				+#define REDIS_NO_SANITIZE(sanitizer) __attribute__((no_sanitize(sanitizer)))
			
 
				+#endif
			
 
				+#endif
			
 
				+#if !defined(REDIS_NO_SANITIZE)
			
 
				+#define REDIS_NO_SANITIZE(sanitizer)
			
 
				+#endif
			
 
				+
			
 
				+/* Define rdb_fsync_range to sync_file_range() on Linux, otherwise we use
			
 
				+ * the plain fsync() call. */
			
 
				+#if (defined(__linux__) && defined(SYNC_FILE_RANGE_WAIT_BEFORE))
			
 
				+#define HAVE_SYNC_FILE_RANGE 1
			
 
				+#define rdb_fsync_range(fd,off,size) sync_file_range(fd,off,size,SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE)
			
 
				+#elif defined(__APPLE__)
			
 
				+#define rdb_fsync_range(fd,off,size) fcntl(fd, F_FULLFSYNC)
			
 
				+#else
			
 
				+#define rdb_fsync_range(fd,off,size) fsync(fd)
			
 
				+#endif
			
 
				+
			
 
				+/* Check if we can use setproctitle().
			
 
				+ * BSD systems have support for it, we provide an implementation for
			
 
				+ * Linux and osx. */
			
 
				+#if (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__)
			
 
				+#define USE_SETPROCTITLE
			
 
				+#endif
			
 
				+
			
 
				+#if defined(__HAIKU__)
			
 
				+#define ESOCKTNOSUPPORT 0
			
 
				+#endif
			
 
				+
			
 
				+#if (defined __linux || defined __APPLE__)
			
 
				+#define USE_SETPROCTITLE
			
 
				+#define INIT_SETPROCTITLE_REPLACEMENT
			
 
				+void spt_init(int argc, char *argv[]);
			
 
				+void setproctitle(const char *fmt, ...);
			
 
				+#endif
			
 
				+
			
 
				+/* Byte ordering detection */
			
 
				+#include <sys/types.h> /* This will likely define BYTE_ORDER */
			
 
				+
			
 
				+#ifndef BYTE_ORDER
			
 
				+#if (BSD >= 199103)
			
 
				+# include <machine/endian.h>
			
 
				+#else
			
 
				+#if defined(linux) || defined(__linux__)
			
 
				+# include <endian.h>
			
 
				+#else
			
 
				+#define	LITTLE_ENDIAN	1234	/* least-significant byte first (vax, pc) */
			
 
				+#define	BIG_ENDIAN	4321	/* most-significant byte first (IBM, net) */
			
 
				+#define	PDP_ENDIAN	3412	/* LSB first in word, MSW first in long (pdp)*/
			
 
				+
			
 
				+#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || \
			
 
				+   defined(vax) || defined(ns32000) || defined(sun386) || \
			
 
				+   defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
			
 
				+   defined(__alpha__) || defined(__alpha)
			
 
				+#define BYTE_ORDER    LITTLE_ENDIAN
			
 
				+#endif
			
 
				+
			
 
				+#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
			
 
				+    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
			
 
				+    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
			
 
				+    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
			
 
				+    defined(__hppa) || defined(__hp9000) || \
			
 
				+    defined(__hp9000s300) || defined(__hp9000s700) || \
			
 
				+    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
			
 
				+#define BYTE_ORDER	BIG_ENDIAN
			
 
				+#endif
			
 
				+#endif /* linux */
			
 
				+#endif /* BSD */
			
 
				+#endif /* BYTE_ORDER */
			
 
				+
			
 
				+/* Sometimes after including an OS-specific header that defines the
			
 
				+ * endianness we end with __BYTE_ORDER but not with BYTE_ORDER that is what
			
 
				+ * the Redis code uses. In this case let's define everything without the
			
 
				+ * underscores. */
			
 
				+#ifndef BYTE_ORDER
			
 
				+#ifdef __BYTE_ORDER
			
 
				+#if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
			
 
				+#ifndef LITTLE_ENDIAN
			
 
				+#define LITTLE_ENDIAN __LITTLE_ENDIAN
			
 
				+#endif
			
 
				+#ifndef BIG_ENDIAN
			
 
				+#define BIG_ENDIAN __BIG_ENDIAN
			
 
				+#endif
			
 
				+#if (__BYTE_ORDER == __LITTLE_ENDIAN)
			
 
				+#define BYTE_ORDER LITTLE_ENDIAN
			
 
				+#else
			
 
				+#define BYTE_ORDER BIG_ENDIAN
			
 
				+#endif
			
 
				+#endif
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+#if !defined(BYTE_ORDER) || \
			
 
				+    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
			
 
				+	/* you must determine what the correct bit order is for
			
 
				+	 * your compiler - the next line is an intentional error
			
 
				+	 * which will force your compiles to bomb until you fix
			
 
				+	 * the above macros.
			
 
				+	 */
			
 
				+#error "Undefined or invalid BYTE_ORDER"
			
 
				+#endif
			
 
				+
			
 
				+#if (__i386 || __amd64 || __powerpc__) && __GNUC__
			
 
				+#define GNUC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
			
 
				+#if defined(__clang__)
			
 
				+#define HAVE_ATOMIC
			
 
				+#endif
			
 
				+#if (defined(__GLIBC__) && defined(__GLIBC_PREREQ))
			
 
				+#if (GNUC_VERSION >= 40100 && __GLIBC_PREREQ(2, 6))
			
 
				+#define HAVE_ATOMIC
			
 
				+#endif
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+/* Make sure we can test for ARM just checking for __arm__, since sometimes
			
 
				+ * __arm is defined but __arm__ is not. */
			
 
				+#if defined(__arm) && !defined(__arm__)
			
 
				+#define __arm__
			
 
				+#endif
			
 
				+#if defined (__aarch64__) && !defined(__arm64__)
			
 
				+#define __arm64__
			
 
				+#endif
			
 
				+
			
 
				+/* Make sure we can test for SPARC just checking for __sparc__. */
			
 
				+#if defined(__sparc) && !defined(__sparc__)
			
 
				+#define __sparc__
			
 
				+#endif
			
 
				+
			
 
				+#if defined(__sparc__) || defined(__arm__)
			
 
				+#define USE_ALIGNED_ACCESS
			
 
				+#endif
			
 
				+
			
 
				+/* Define for redis_set_thread_title */
			
 
				+#ifdef __linux__
			
 
				+#define redis_set_thread_title(name) pthread_setname_np(pthread_self(), name)
			
 
				+#else
			
 
				+#if (defined __FreeBSD__ || defined __OpenBSD__)
			
 
				+#include <pthread_np.h>
			
 
				+#define redis_set_thread_title(name) pthread_set_name_np(pthread_self(), name)
			
 
				+#elif defined __NetBSD__
			
 
				+#include <pthread.h>
			
 
				+#define redis_set_thread_title(name) pthread_setname_np(pthread_self(), "%s", name)
			
 
				+#elif defined __HAIKU__
			
 
				+#include <kernel/OS.h>
			
 
				+#define redis_set_thread_title(name) rename_thread(find_thread(0), name)
			
 
				+#else
			
 
				+#if (defined __APPLE__ && defined(MAC_OS_X_VERSION_10_7))
			
 
				+int pthread_setname_np(const char *name);
			
 
				+#include <pthread.h>
			
 
				+#define redis_set_thread_title(name) pthread_setname_np(name)
			
 
				+#else
			
 
				+#define redis_set_thread_title(name)
			
 
				+#endif
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+/* Check if we can use setcpuaffinity(). */
			
 
				+#if (defined __linux || defined __NetBSD__ || defined __FreeBSD__ || defined __DragonFly__)
			
 
				+#define USE_SETCPUAFFINITY
			
 
				+void setcpuaffinity(const char *cpulist);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/crc16.c
+++ b/src/crc16.c
@@ -0,0 +1,88 @@
 
				+// #include "server.h"
			
 
				+#include <stdint.h>
			
 
				+/*
			
 
				+ * Copyright 2001-2010 Georges Menie (www.menie.org)
			
 
				+ * Copyright 2010-2012 Salvatore Sanfilippo (adapted to Redis coding style)
			
 
				+ * 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 the University of California, Berkeley 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 REGENTS 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 REGENTS AND 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.
			
 
				+ */
			
 
				+
			
 
				+/* CRC16 implementation according to CCITT standards.
			
 
				+ *
			
 
				+ * Note by @antirez: this is actually the XMODEM CRC 16 algorithm, using the
			
 
				+ * following parameters:
			
 
				+ *
			
 
				+ * Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
			
 
				+ * Width                      : 16 bit
			
 
				+ * Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
			
 
				+ * Initialization             : 0000
			
 
				+ * Reflect Input byte         : False
			
 
				+ * Reflect Output CRC         : False
			
 
				+ * Xor constant to output CRC : 0000
			
 
				+ * Output for "123456789"     : 31C3
			
 
				+ */
			
 
				+
			
 
				+static const uint16_t crc16tab[256]= {
			
 
				+    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
			
 
				+    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
			
 
				+    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
			
 
				+    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
			
 
				+    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
			
 
				+    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
			
 
				+    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
			
 
				+    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
			
 
				+    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
			
 
				+    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
			
 
				+    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
			
 
				+    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
			
 
				+    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
			
 
				+    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
			
 
				+    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
			
 
				+    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
			
 
				+    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
			
 
				+    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
			
 
				+    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
			
 
				+    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
			
 
				+    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
			
 
				+    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
			
 
				+    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
			
 
				+    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
			
 
				+    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
			
 
				+    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
			
 
				+    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
			
 
				+    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
			
 
				+    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
			
 
				+    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
			
 
				+    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
			
 
				+    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
			
 
				+};
			
 
				+
			
 
				+uint16_t crc16(const char *buf, int len) {
			
 
				+    int counter;
			
 
				+    uint16_t crc = 0;
			
 
				+    for (counter = 0; counter < len; counter++)
			
 
				+            crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *buf++)&0x00FF];
			
 
				+    return crc;
			
 
				+}
			
--- a/src/crc16_slottable.h
+++ b/src/crc16_slottable.h
@@ -0,0 +1,835 @@
 
				+#ifndef _CRC16_TABLE_H__
			
 
				+#define _CRC16_TABLE_H__
			
 
				+
			
 
				+/* A table of the shortest possible alphanumeric string that is mapped by redis' crc16
			
 
				+ * to any given redis cluster slot. 
			
 
				+ * 
			
 
				+ * The array indexes are slot numbers, so that given a desired slot, this string is guaranteed
			
 
				+ * to make redis cluster route a request to the shard holding this slot 
			
 
				+ */
			
 
				+
			
 
				+const char *crc16_slot_table[] = {
			
 
				+"06S", "Qi", "5L5", "4Iu", "4gY", "460", "1Y7", "1LV", "0QG", "ru", "7Ok", "4ji", "4DE", "65n", "2JH", "I8", "F9", "SX", "7nF", "4KD", 
			
 
				+"4eh", "6PK", "2ke", "1Ng", "0Sv", "4L", "491", "4hX", "4Ft", "5C4", "2Hy", "09R", "021", "0cX", "4Xv", "6mU", "6Cy", "42R", "0Mt", "nF", 
			
 
				+"cv", "1Pe", "5kK", "6NI", "74L", "4UF", "0nh", "MZ", "2TJ", "0ai", "4ZG", "6od", "6AH", "40c", "0OE", "lw", "aG", "0Bu", "5iz", "6Lx", 
			
 
				+"5R7", "4Ww", "0lY", "Ok", "5n3", "4ks", "8YE", "7g", "2KR", "1nP", "714", "64t", "69D", "4Ho", "07I", "Ps", "2hN", "1ML", "4fC", "7CA", 
			
 
				+"avs", "4iB", "0Rl", "5V", "2Ic", "08H", "4Gn", "66E", "aUo", "b4e", "05x", "RB", "8f", "8VD", "4dr", "5a2", "4zp", "6OS", "bl", "355", 
			
 
				+"0or", "1j2", "75V", "bno", "4Yl", "6lO", "Ap", "0bB", "0Ln", "2yM", "6Bc", "43H", "4xA", "6Mb", "22D", "14", "0mC", "Nq", "6cN", "4Vm", 
			
 
				+"ban", "aDl", "CA", "14Z", "8GG", "mm", "549", "41y", "53t", "464", "1Y3", "1LR", "06W", "Qm", "5L1", "4Iq", "4DA", "65j", "2JL", "1oN", 
			
 
				+"0QC", "6y", "7Oo", "4jm", "4el", "6PO", "9x", "1Nc", "04f", "2EM", "7nB", "bqs", "4Fp", "5C0", "d6F", "09V", "0Sr", "4H", "495", "bRo", 
			
 
				+"aio", "42V", "0Mp", "nB", "025", "17u", "4Xr", "6mQ", "74H", "4UB", "0nl", "3Kn", "cr", "1Pa", "5kO", "6NM", "6AL", "40g", "0OA", "ls", 
			
 
				+"2TN", "0am", "4ZC", "aEr", "5R3", "4Ws", "18t", "Oo", "aC", "0Bq", "bCl", "afn", "2KV", "1nT", "5Uz", "64p", "5n7", "4kw", "0PY", "7c", 
			
 
				+"2hJ", "1MH", "4fG", "6Sd", "7mi", "4Hk", "07M", "Pw", "2Ig", "08L", "4Gj", "66A", "7LD", "4iF", "0Rh", "5R", "8b", "1Oy", "4dv", "5a6", 
			
 
				+"7oX", "4JZ", "0qt", "RF", "0ov", "LD", "4A9", "4TX", "4zt", "6OW", "bh", "0AZ", "z9", "oX", "6Bg", "43L", "4Yh", "6lK", "At", "0bF", 
			
 
				+"0mG", "Nu", "6cJ", "4Vi", "4xE", "6Mf", "2vH", "10", "8GC", "mi", "5p5", "4uu", "5Kx", "4N8", "CE", "1pV", "0QO", "6u", "7Oc", "4ja", 
			
 
				+"4DM", "65f", "3Za", "I0", "0rS", "Qa", "68V", "b7F", "4gQ", "468", "dSo", "285", "274", "4D", "499", "4hP", "b8G", "67W", "0h3", "09Z", 
			
 
				+"F1", "SP", "7nN", "4KL", "51I", "6PC", "9t", "1No", "21g", "1Pm", "5kC", "6NA", "74D", "4UN", "X3", "MR", "029", "0cP", "bbM", "79t", 
			
 
				+"4c3", "42Z", "8Dd", "nN", "aO", "8Ke", "4yS", "4l2", "76u", "635", "0lQ", "Oc", "BS", "W2", "4ZO", "6ol", "7Qa", "40k", "0OM", "2zn", 
			
 
				+"69L", "4Hg", "07A", "2Fj", "2hF", "k6", "4fK", "6Sh", "7Ny", "6K9", "0PU", "7o", "2KZ", "1nX", "4EW", "4P6", "7oT", "4JV", "05p", "RJ", 
			
 
				+"8n", "1Ou", "4dz", "6QY", "7LH", "4iJ", "d7", "qV", "2Ik", "1li", "4Gf", "66M", "4Yd", "6lG", "Ax", "0bJ", "z5", "oT", "6Bk", "4wH", 
			
 
				+"4zx", "aeI", "bd", "0AV", "0oz", "LH", "4A5", "4TT", "5Kt", "4N4", "CI", "14R", "0NW", "me", "541", "41q", "4xI", "6Mj", "22L", "u4", 
			
 
				+"0mK", "Ny", "6cF", "4Ve", "4DI", "65b", "2JD", "I4", "0QK", "6q", "7Og", "4je", "4gU", "4r4", "2iX", "1LZ", "0rW", "Qe", "5L9", "4Iy", 
			
 
				+"4Fx", "5C8", "0h7", "1mw", "0Sz", "pH", "7MV", "4hT", "4ed", "6PG", "9p", "1Nk", "F5", "ST", "7nJ", "4KH", "7pH", "4UJ", "X7", "MV", 
			
 
				+"cz", "1Pi", "5kG", "6NE", "4c7", "4vV", "0Mx", "nJ", "0v5", "0cT", "4Xz", "6mY", "6bX", "5GZ", "0lU", "Og", "aK", "0By", "4yW", "4l6", 
			
 
				+"6AD", "40o", "0OI", "2zj", "BW", "W6", "4ZK", "6oh", "2hB", "k2", "4fO", "6Sl", "69H", "4Hc", "07E", "2Fn", "d5e", "83m", "4ES", "4P2", 
			
 
				+"a0F", "bQL", "0PQ", "7k", "8j", "1Oq", "50W", "hbv", "7oP", "4JR", "05t", "RN", "2Io", "08D", "4Gb", "66I", "7LL", "4iN", "d3", "5Z", 
			
 
				+"z1", "oP", "6Bo", "43D", "5IA", "6lC", "2Wm", "0bN", "8ff", "LL", "4A1", "4TP", "cPn", "aeM", "0T3", "0AR", "0NS", "ma", "545", "41u", 
			
 
				+"5Kp", "4N0", "CM", "14V", "0mO", "2Xl", "6cB", "4Va", "4xM", "6Mn", "22H", "18", "04s", "SI", "7nW", "4KU", "4ey", "6PZ", "9m", "1Nv", 
			
 
				+"e4", "pU", "7MK", "4hI", "4Fe", "67N", "2Hh", "09C", "06B", "Qx", "68O", "4Id", "4gH", "6Rk", "2iE", "j5", "0QV", "6l", "5o8", "4jx", 
			
 
				+"4DT", "4Q5", "2JY", "82j", "BJ", "0ax", "4ZV", "4O7", "552", "40r", "0OT", "lf", "aV", "t7", "4yJ", "6Li", "6bE", "4Wf", "0lH", "Oz", 
			
 
				+"2Vj", "0cI", "4Xg", "6mD", "6Ch", "42C", "0Me", "nW", "cg", "1Pt", "5kZ", "6NX", "7pU", "4UW", "0ny", "MK", "7LQ", "4iS", "267", "5G", 
			
 
				+"0i0", "08Y", "b9D", "66T", "7oM", "4JO", "G2", "RS", "8w", "1Ol", "4dc", "7Aa", "atS", "4kb", "0PL", "7v", "2KC", "H3", "4EN", "64e", 
			
 
				+"69U", "b6E", "07X", "Pb", "dRl", "296", "4fR", "4s3", "4xP", "4m1", "22U", "8Jf", "0mR", "0x3", "77v", "626", "5Km", "6no", "CP", "V1", 
			
 
				+"0NN", "3kL", "7Pb", "41h", "4za", "6OB", "20d", "0AO", "Y0", "LQ", "6an", "4TM", "bcN", "78w", "Aa", "0bS", "8Eg", "oM", "4b0", "43Y", 
			
 
				+"51T", "azL", "9i", "1Nr", "04w", "SM", "7nS", "4KQ", "4Fa", "67J", "2Hl", "09G", "e0", "4Y", "7MO", "4hM", "4gL", "6Ro", "2iA", "j1", 
			
 
				+"06F", "2Gm", "68K", "5YA", "4DP", "4Q1", "d4f", "82n", "0QR", "6h", "a1E", "bPO", "556", "40v", "0OP", "lb", "BN", "15U", "4ZR", "4O3", 
			
 
				+"6bA", "4Wb", "0lL", "2Yo", "aR", "t3", "4yN", "6Lm", "6Cl", "42G", "0Ma", "nS", "2Vn", "0cM", "4Xc", "79i", "74Y", "4US", "8ge", "MO", 
			
 
				+"cc", "1Pp", "bAL", "adN", "0i4", "1lt", "5WZ", "66P", "7LU", "4iW", "0Ry", "5C", "8s", "1Oh", "4dg", "6QD", "7oI", "4JK", "G6", "RW", 
			
 
				+"2KG", "H7", "4EJ", "64a", "7Nd", "4kf", "0PH", "7r", "1X8", "1MY", "4fV", "4s7", "69Q", "4Hz", "0sT", "Pf", "0mV", "Nd", "5S8", "4Vx", 
			
 
				+"4xT", "4m5", "22Q", "0Cz", "0NJ", "mx", "7Pf", "41l", "5Ki", "6nk", "CT", "V5", "Y4", "LU", "6aj", "4TI", "4ze", "6OF", "by", "0AK", 
			
 
				+"2l9", "oI", "4b4", "4wU", "4Yy", "6lZ", "Ae", "0bW", "0So", "4U", "7MC", "4hA", "4Fm", "67F", "3XA", "09K", "0ps", "SA", "aTl", "b5f", 
			
 
				+"4eq", "6PR", "9e", "8WG", "8XF", "6d", "5o0", "4jp", "707", "65w", "1z2", "1oS", "06J", "Qp", "68G", "4Il", "53i", "6Rc", "2iM", "1LO", 
			
 
				+"23G", "07", "4yB", "6La", "6bM", "4Wn", "18i", "Or", "BB", "0ap", "c4D", "aEo", "5q2", "40z", "8FD", "ln", "co", "346", "5kR", "6NP", 
			
 
				+"74U", "bol", "0nq", "MC", "2Vb", "0cA", "4Xo", "6mL", "7SA", "42K", "0Mm", "2xN", "7oE", "4JG", "05a", "2DJ", "2jf", "1Od", "4dk", "6QH", 
			
 
				+"482", "5yz", "0Ru", "5O", "0i8", "08Q", "4Gw", "5B7", "5M6", "4Hv", "07P", "Pj", "1X4", "1MU", "4fZ", "473", "7Nh", "4kj", "0PD", "sv", 
			
 
				+"2KK", "1nI", "4EF", "64m", "5Ke", "6ng", "CX", "V9", "0NF", "mt", "7Pj", "4uh", "4xX", "4m9", "1F6", "0Cv", "0mZ", "Nh", "5S4", "4Vt", 
			
 
				+"4Yu", "6lV", "Ai", "16r", "0Lw", "oE", "4b8", "43Q", "4zi", "6OJ", "bu", "0AG", "Y8", "LY", "6af", "4TE", "4Fi", "67B", "2Hd", "09O", 
			
 
				+"e8", "4Q", "7MG", "4hE", "4eu", "6PV", "9a", "1Nz", "0pw", "SE", "aTh", "4KY", "4DX", "4Q9", "1z6", "1oW", "0QZ", "rh", "5o4", "4jt", 
			
 
				+"4gD", "6Rg", "2iI", "j9", "06N", "Qt", "68C", "4Ih", "6bI", "4Wj", "0lD", "Ov", "aZ", "03", "4yF", "6Le", "5q6", "4tv", "0OX", "lj", 
			
 
				+"BF", "0at", "4ZZ", "6oy", "74Q", "5Ez", "0nu", "MG", "ck", "1Px", "5kV", "6NT", "6Cd", "42O", "0Mi", "2xJ", "2Vf", "0cE", "4Xk", "6mH", 
			
 
				+"2jb", "8VY", "4do", "6QL", "7oA", "4JC", "05e", "2DN", "d7E", "08U", "4Gs", "5B3", "486", "bSl", "0Rq", "5K", "1X0", "1MQ", "52w", "477", 
			
 
				+"5M2", "4Hr", "07T", "Pn", "2KO", "1nM", "4EB", "64i", "7Nl", "4kn", "8YX", "7z", "0NB", "mp", "7Pn", "41d", "5Ka", "6nc", "2UM", "14G", 
			
 
				+"19w", "Nl", "5S0", "4Vp", "bBo", "agm", "1F2", "0Cr", "0Ls", "oA", "ahl", "43U", "4Yq", "6lR", "Am", "16v", "0oo", "2ZL", "6ab", "4TA", 
			
 
				+"4zm", "6ON", "bq", "0AC", "2VY", "0cz", "4XT", "4M5", "570", "42p", "0MV", "nd", "cT", "v5", "5ki", "6Nk", "74n", "4Ud", "0nJ", "Mx", 
			
 
				+"By", "0aK", "4Ze", "6oF", "6Aj", "40A", "y4", "lU", "ae", "0BW", "4yy", "581", "4B4", "4WU", "18R", "OI", "06q", "QK", "7lU", "4IW", 
			
 
				+"53R", "6RX", "0I4", "1Lt", "g6", "rW", "7OI", "4jK", "4Dg", "65L", "2Jj", "1oh", "0pH", "Sz", "7nd", "4Kf", "4eJ", "6Pi", "2kG", "h7", 
			
 
				+"0ST", "4n", "7Mx", "4hz", "4FV", "4S7", "1x8", "09p", "4zR", "4o3", "bN", "8Hd", "0oP", "Lb", "75t", "604", "4YN", "6lm", "AR", "T3", 
			
 
				+"0LL", "2yo", "6BA", "43j", "4xc", "agR", "22f", "0CM", "0ma", "NS", "6cl", "4VO", "baL", "aDN", "Cc", "14x", "8Ge", "mO", "7PQ", "4uS", 
			
 
				+"7NS", "4kQ", "245", "7E", "0k2", "1nr", "coo", "64V", "69f", "4HM", "E0", "PQ", "2hl", "1Mn", "4fa", "6SB", "7Lb", "5yA", "0RN", "5t", 
			
 
				+"2IA", "J1", "4GL", "66g", "aUM", "b4G", "05Z", "0d3", "8D", "8Vf", "4dP", "459", "574", "42t", "0MR", "0X3", "dln", "17W", "4XP", "4M1", 
			
 
				+"74j", "5EA", "0nN", "3KL", "cP", "29", "5km", "6No", "6An", "40E", "y0", "lQ", "2Tl", "0aO", "4Za", "6oB", "4B0", "4WQ", "18V", "OM", 
			
 
				+"aa", "0BS", "bCN", "585", "53V", "axN", "0I0", "1Lp", "06u", "QO", "68x", "4IS", "4Dc", "65H", "2Jn", "1ol", "g2", "rS", "7OM", "4jO", 
			
 
				+"4eN", "6Pm", "9Z", "h3", "04D", "2Eo", "aTS", "4Kb", "4FR", "4S3", "d6d", "09t", "0SP", "4j", "a3G", "bRM", "0oT", "Lf", "6aY", "4Tz", 
			
 
				+"4zV", "4o7", "bJ", "0Ax", "0LH", "oz", "6BE", "43n", "4YJ", "6li", "AV", "T7", "0me", "NW", "6ch", "4VK", "4xg", "6MD", "22b", "0CI", 
			
 
				+"0Ny", "mK", "7PU", "4uW", "5KZ", "6nX", "Cg", "1pt", "0k6", "1nv", "4Ey", "64R", "7NW", "4kU", "241", "7A", "2hh", "1Mj", "4fe", "6SF", 
			
 
				+"69b", "4HI", "E4", "PU", "2IE", "J5", "4GH", "66c", "7Lf", "4id", "0RJ", "5p", "2jY", "8Vb", "4dT", "4q5", "5O8", "4Jx", "0qV", "Rd", 
			
 
				+"21E", "25", "5ka", "6Nc", "74f", "4Ul", "0nB", "Mp", "1f2", "0cr", "bbo", "79V", "578", "42x", "395", "nl", "am", "364", "4yq", "589", 
			
 
				+"76W", "bmn", "0ls", "OA", "Bq", "0aC", "4Zm", "6oN", "6Ab", "40I", "0Oo", "2zL", "0Qm", "6W", "7OA", "4jC", "4Do", "65D", "2Jb", "82Q", 
			
 
				+"06y", "QC", "68t", "b7d", "4gs", "5b3", "dSM", "8UE", "8ZD", "4f", "5m2", "4hr", "725", "67u", "1x0", "09x", "04H", "Sr", "7nl", "4Kn", 
			
 
				+"4eB", "6Pa", "9V", "1NM", "4YF", "6le", "AZ", "0bh", "0LD", "ov", "6BI", "43b", "4zZ", "6Oy", "bF", "0At", "0oX", "Lj", "5Q6", "4Tv", 
			
 
				+"5KV", "6nT", "Ck", "14p", "0Nu", "mG", "7PY", "41S", "4xk", "6MH", "22n", "0CE", "0mi", "2XJ", "6cd", "4VG", "69n", "4HE", "E8", "PY", 
			
 
				+"2hd", "1Mf", "4fi", "6SJ", "ath", "4kY", "0Pw", "7M", "2Kx", "1nz", "4Eu", "6pV", "5O4", "4Jt", "05R", "Rh", "8L", "1OW", "4dX", "451", 
			
 
				+"7Lj", "4ih", "0RF", "qt", "2II", "J9", "4GD", "66o", "74b", "4Uh", "0nF", "Mt", "cX", "21", "5ke", "6Ng", "5s4", "4vt", "0MZ", "nh", 
			
 
				+"1f6", "0cv", "4XX", "4M9", "4B8", "4WY", "0lw", "OE", "ai", "1Rz", "4yu", "6LV", "6Af", "40M", "y8", "lY", "Bu", "0aG", "4Zi", "6oJ", 
			
 
				+"4Dk", "6qH", "2Jf", "1od", "0Qi", "6S", "7OE", "4jG", "4gw", "5b7", "0I8", "1Lx", "0ru", "QG", "68p", "5Yz", "4FZ", "67q", "1x4", "1mU", 
			
 
				+"0SX", "4b", "5m6", "4hv", "4eF", "6Pe", "9R", "1NI", "04L", "Sv", "7nh", "4Kj", "8EX", "or", "6BM", "43f", "4YB", "6la", "2WO", "0bl", 
			
 
				+"8fD", "Ln", "5Q2", "4Tr", "cPL", "aeo", "bB", "0Ap", "0Nq", "mC", "ajn", "41W", "5KR", "6nP", "Co", "14t", "0mm", "2XN", "77I", "4VC", 
			
 
				+"4xo", "6ML", "22j", "0CA", "3xA", "1Mb", "4fm", "6SN", "69j", "4HA", "07g", "2FL", "d5G", "83O", "4Eq", "64Z", "a0d", "bQn", "0Ps", "7I", 
			
 
				+"8H", "1OS", "50u", "455", "5O0", "4Jp", "05V", "Rl", "2IM", "08f", "5Wa", "66k", "7Ln", "4il", "0RB", "5x", "Bh", "0aZ", "4Zt", "6oW", 
			
 
				+"4a9", "40P", "0Ov", "lD", "at", "0BF", "4yh", "6LK", "6bg", "4WD", "Z9", "OX", "2VH", "U8", "4XE", "6mf", "6CJ", "42a", "0MG", "nu", 
			
 
				+"cE", "1PV", "5kx", "4n8", "5P5", "4Uu", "8gC", "Mi", "04Q", "Sk", "5N7", "4Kw", "51r", "442", "9O", "1NT", "0SE", "pw", "7Mi", "4hk", 
			
 
				+"4FG", "67l", "2HJ", "09a", "3", "QZ", "68m", "4IF", "4gj", "6RI", "2ig", "1Le", "0Qt", "6N", "7OX", "4jZ", "4Dv", "5A6", "0j9", "1oy", 
			
 
				+"4xr", "6MQ", "22w", "377", "0mp", "NB", "77T", "blm", "5KO", "6nM", "Cr", "14i", "0Nl", "3kn", "ajs", "41J", "4zC", "aer", "20F", "36", 
			
 
				+"0oA", "Ls", "6aL", "4To", "bcl", "78U", "AC", "0bq", "386", "oo", "5r3", "4ws", "5l1", "4iq", "9Kf", "5e", "1y3", "1lR", "736", "66v", 
			
 
				+"7oo", "4Jm", "05K", "Rq", "8U", "1ON", "4dA", "6Qb", "7NB", "bQs", "0Pn", "7T", "2Ka", "1nc", "4El", "64G", "69w", "b6g", "07z", "1v2", 
			
 
				+"dRN", "8TF", "4fp", "5c0", "akm", "40T", "0Or", "1J2", "Bl", "15w", "4Zp", "6oS", "6bc", "5Ga", "0ln", "2YM", "ap", "0BB", "4yl", "6LO", 
			
 
				+"6CN", "42e", "0MC", "nq", "2VL", "0co", "4XA", "6mb", "5P1", "4Uq", "8gG", "Mm", "cA", "1PR", "bAn", "adl", "51v", "446", "9K", "1NP", 
			
 
				+"04U", "So", "5N3", "4Ks", "4FC", "67h", "2HN", "09e", "0SA", "ps", "7Mm", "4ho", "4gn", "6RM", "2ic", "1La", "7", "2GO", "68i", "4IB", 
			
 
				+"4Dr", "5A2", "d4D", "82L", "0Qp", "6J", "a1g", "bPm", "0mt", "NF", "6cy", "4VZ", "4xv", "6MU", "0V9", "0CX", "0Nh", "mZ", "7PD", "41N", 
			
 
				+"5KK", "6nI", "Cv", "14m", "0oE", "Lw", "6aH", "4Tk", "4zG", "6Od", "20B", "32", "0LY", "ok", "5r7", "4ww", "5Iz", "6lx", "AG", "0bu", 
			
 
				+"1y7", "1lV", "4GY", "4R8", "5l5", "4iu", "1Bz", "5a", "8Q", "i8", "4dE", "6Qf", "7ok", "4Ji", "05O", "Ru", "2Ke", "1ng", "4Eh", "64C", 
			
 
				+"7NF", "4kD", "f9", "7P", "2hy", "3m9", "4ft", "5c4", "69s", "4HX", "0sv", "PD", "23e", "0BN", "5iA", "6LC", "6bo", "4WL", "Z1", "OP", 
			
 
				+"0t3", "0aR", "c4f", "aEM", "4a1", "40X", "8Ff", "lL", "cM", "8Ig", "5kp", "4n0", "74w", "617", "0nS", "Ma", "3Fa", "U0", "4XM", "6mn", 
			
 
				+"6CB", "42i", "0MO", "2xl", "0SM", "4w", "7Ma", "4hc", "4FO", "67d", "2HB", "K2", "04Y", "Sc", "aTN", "b5D", "4eS", "4p2", "9G", "8We", 
			
 
				+"256", "6F", "7OP", "4jR", "cnl", "65U", "0j1", "1oq", "D3", "QR", "68e", "4IN", "4gb", "6RA", "2io", "1Lm", "5KG", "6nE", "Cz", "14a", 
			
 
				+"x7", "mV", "7PH", "41B", "4xz", "592", "0V5", "0CT", "0mx", "NJ", "4C7", "4VV", "4YW", "4L6", "AK", "0by", "0LU", "og", "563", "43s", 
			
 
				+"4zK", "6Oh", "bW", "w6", "0oI", "2Zj", "6aD", "4Tg", "7og", "4Je", "05C", "Ry", "2jD", "i4", "4dI", "6Qj", "5l9", "4iy", "0RW", "5m", 
			
 
				+"2IX", "08s", "4GU", "4R4", "7mV", "4HT", "07r", "PH", "0H7", "1Mw", "4fx", "5c8", "7NJ", "4kH", "f5", "sT", "2Ki", "1nk", "4Ed", "64O", 
			
 
				+"6bk", "4WH", "Z5", "OT", "ax", "0BJ", "4yd", "6LG", "4a5", "4tT", "0Oz", "lH", "Bd", "0aV", "4Zx", "aEI", "5P9", "4Uy", "0nW", "Me", 
			
 
				+"cI", "1PZ", "5kt", "4n4", "6CF", "42m", "0MK", "ny", "2VD", "U4", "4XI", "6mj", "4FK", "6sh", "2HF", "K6", "0SI", "4s", "7Me", "4hg", 
			
 
				+"4eW", "4p6", "9C", "1NX", "0pU", "Sg", "7ny", "6k9", "4Dz", "65Q", "0j5", "1ou", "0Qx", "6B", "7OT", "4jV", "4gf", "6RE", "2ik", "1Li", 
			
 
				+"D7", "QV", "68a", "4IJ", "x3", "mR", "7PL", "41F", "5KC", "6nA", "2Uo", "14e", "19U", "NN", "4C3", "4VR", "bBM", "596", "0V1", "0CP", 
			
 
				+"0LQ", "oc", "567", "43w", "4YS", "4L2", "AO", "16T", "0oM", "2Zn", "75i", "4Tc", "4zO", "6Ol", "bS", "w2", "8Y", "i0", "4dM", "6Qn", 
			
 
				+"7oc", "4Ja", "05G", "2Dl", "d7g", "08w", "4GQ", "4R0", "a2D", "bSN", "0RS", "5i", "0H3", "1Ms", "52U", "ayM", "7mR", "4HP", "07v", "PL", 
			
 
				+"2Km", "1no", "5UA", "64K", "7NN", "4kL", "f1", "7X", "5nw", "4k7", "fJ", "0Ex", "0kT", "Hf", "6eY", "4Pz", "5Mk", "6hi", "EV", "P7", 
			
 
				+"0HH", "kz", "6FE", "47n", "48o", "6ID", "26b", "0GI", "0ie", "JW", "6gh", "4RK", "5OZ", "6jX", "Gg", "0dU", "0Jy", "iK", "4d6", "4qW", 
			
 
				+"4z4", "4oU", "1DZ", "3A", "Ye", "0zW", "4Ay", "5D9", "6yj", "4LI", "A4", "TU", "zy", "0YK", "4be", "6WF", "6XG", "4md", "0VJ", "1p", 
			
 
				+"2ME", "N5", "4CH", "62c", "5K8", "4Nx", "0uV", "Vd", "xH", "8Rb", "5pu", "4u5", "D", "13W", "5Lq", "4I1", "534", "46t", "0IR", "28y", 
			
 
				+"gP", "69", "5om", "6Jo", "6dC", "5AA", "0jN", "3OL", "2Pl", "0eO", "aT1", "6kB", "6En", "44E", "98", "hQ", "ea", "0FS", "49u", "abL", 
			
 
				+"4F0", "4SQ", "8ag", "KM", "02u", "UO", "4X2", "4MS", "57V", "a8F", "0M0", "0XQ", "c2", "vS", "7KM", "4nO", "5PB", "61H", "2Nn", "1kl", 
			
 
				+"00D", "2Ao", "6zA", "4Ob", "4aN", "6Tm", "yR", "l3", "0WP", "0j", "a7G", "58W", "4BR", "4W3", "ZN", "84l", "0kP", "Hb", "71t", "644", 
			
 
				+"5ns", "4k3", "fN", "8Ld", "0HL", "29g", "6FA", "47j", "5Mo", "6hm", "ER", "P3", "0ia", "JS", "6gl", "4RO", "48k", "7Ya", "26f", "0GM", 
			
 
				+"8Ce", "iO", "4d2", "4qS", "beL", "hYw", "Gc", "0dQ", "Ya", "0zS", "cko", "60V", "4z0", "4oQ", "205", "3E", "2ll", "0YO", "4ba", "6WB", 
			
 
				+"6yn", "4LM", "A0", "TQ", "2MA", "N1", "4CL", "62g", "6XC", "59I", "0VN", "1t", "xL", "8Rf", "54y", "419", "aQM", "b0G", "01Z", "3PP", 
			
 
				+"530", "46p", "0IV", "jd", "DH", "0gz", "5Lu", "4I5", "6dG", "4Qd", "0jJ", "Ix", "gT", "r5", "5oi", "6Jk", "6Ej", "44A", "0Kg", "hU", 
			
 
				+"Fy", "0eK", "5ND", "6kF", "4F4", "4SU", "1xZ", "KI", "ee", "0FW", "49q", "5x9", "57R", "6VX", "0M4", "0XU", "02q", "UK", "4X6", "4MW", 
			
 
				+"5PF", "61L", "2Nj", "1kh", "c6", "vW", "7KI", "4nK", "4aJ", "6Ti", "yV", "l7", "0tH", "Wz", "6zE", "4Of", "4BV", "4W7", "ZJ", "0yx", 
			
 
				+"0WT", "0n", "6YY", "4lz", "5Mc", "6ha", "2SO", "0fl", "1Xa", "kr", "6FM", "47f", "bDm", "aao", "fB", "0Ep", "8bD", "Hn", "5U2", "4Pr", 
			
 
				+"5OR", "5Z3", "Go", "10t", "0Jq", "iC", "ann", "45W", "48g", "6IL", "ds", "0GA", "0im", "3Lo", "73I", "4RC", "6yb", "4LA", "03g", "2BL", 
			
 
				+"zq", "0YC", "4bm", "6WN", "a4d", "bUn", "0Ts", "3I", "Ym", "87O", "4Aq", "5D1", "5K0", "4Np", "01V", "Vl", "2nQ", "1KS", "54u", "415", 
			
 
				+"6XO", "4ml", "0VB", "1x", "2MM", "0xn", "5Sa", "62k", "gX", "61", "5oe", "6Jg", "6dK", "4Qh", "0jF", "It", "L", "0gv", "5Ly", "4I9", 
			
 
				+"5w4", "4rt", "0IZ", "jh", "ei", "1Vz", "5mT", "5x5", "4F8", "4SY", "0hw", "KE", "Fu", "0eG", "5NH", "6kJ", "6Ef", "44M", "90", "hY", 
			
 
				+"0Ui", "2S", "7KE", "4nG", "5PJ", "6uH", "Xw", "1kd", "0vu", "UG", "6xx", "790", "4cw", "5f7", "0M8", "0XY", "0WX", "0b", "5i6", "4lv", 
			
 
				+"4BZ", "63q", "ZF", "0yt", "00L", "Wv", "6zI", "4Oj", "4aF", "6Te", "yZ", "0Zh", "0HD", "kv", "6FI", "47b", "5Mg", "6he", "EZ", "0fh", 
			
 
				+"0kX", "Hj", "5U6", "4Pv", "7N9", "6Ky", "fF", "0Et", "0Ju", "iG", "6Dx", "45S", "5OV", "5Z7", "Gk", "0dY", "0ii", "3Lk", "6gd", "4RG", 
			
 
				+"48c", "6IH", "dw", "0GE", "zu", "0YG", "4bi", "6WJ", "6yf", "4LE", "A8", "TY", "Yi", "1jz", "4Au", "5D5", "4z8", "4oY", "0Tw", "3M", 
			
 
				+"xD", "1KW", "54q", "411", "5K4", "4Nt", "01R", "Vh", "2MI", "N9", "4CD", "62o", "6XK", "4mh", "0VF", "ut", "6dO", "4Ql", "0jB", "Ip", 
			
 
				+"25E", "65", "5oa", "6Jc", "538", "46x", "9Pg", "jl", "H", "0gr", "bfo", "aCm", "72W", "bin", "0hs", "KA", "em", "324", "49y", "5x1", 
			
 
				+"6Eb", "44I", "94", "3nm", "Fq", "0eC", "5NL", "6kN", "5PN", "61D", "Xs", "86Q", "0Um", "2W", "7KA", "4nC", "4cs", "5f3", "39W", "8QE", 
			
 
				+"02y", "UC", "aRn", "794", "765", "63u", "ZB", "0yp", "9Ne", "0f", "5i2", "4lr", "4aB", "6Ta", "2oO", "0Zl", "00H", "Wr", "6zM", "4On", 
			
 
				+"5lW", "5y6", "dj", "0GX", "0it", "JF", "6gy", "4RZ", "5OK", "6jI", "Gv", "0dD", "83", "iZ", "6De", "45N", "5nf", "6Kd", "24B", "72", 
			
 
				+"0kE", "Hw", "6eH", "4Pk", "5Mz", "6hx", "EG", "0fu", "0HY", "kk", "5v7", "4sw", "5h5", "4mu", "1Fz", "1a", "2MT", "0xw", "4CY", "4V8", 
			
 
				+"7kk", "4Ni", "01O", "Vu", "xY", "m8", "54l", "6Uf", "6Zg", "4oD", "b9", "3P", "Yt", "0zF", "4Ah", "60C", "4Y9", "4LX", "0wv", "TD", 
			
 
				+"zh", "0YZ", "4bt", "5g4", "Fl", "11w", "5NQ", "6kS", "aom", "44T", "0Kr", "1N2", "ep", "0FB", "49d", "6HO", "6fc", "5Ca", "0hn", "3Ml", 
			
 
				+"U", "0go", "bfr", "6ib", "6GN", "46e", "0IC", "jq", "gA", "0Ds", "bEn", "hyU", "5T1", "4Qq", "8cG", "Im", "00U", "Wo", "5J3", "4Os", 
			
 
				+"55v", "406", "yC", "0Zq", "0WA", "ts", "6YL", "4lo", "4BC", "63h", "2LN", "0ym", "02d", "2CO", "6xa", "4MB", "4cn", "6VM", "2mc", "1Ha", 
			
 
				+"0Up", "2J", "a5g", "bTm", "5PS", "5E2", "Xn", "86L", "0ip", "JB", "73T", "bhm", "48z", "5y2", "dn", "337", "87", "3on", "6Da", "45J", 
			
 
				+"5OO", "6jM", "Gr", "10i", "0kA", "Hs", "6eL", "4Po", "5nb", "aar", "24F", "76", "8AE", "ko", "5v3", "4ss", "bgl", "aBn", "EC", "0fq", 
			
 
				+"2MP", "0xs", "776", "62v", "5h1", "4mq", "9Of", "1e", "2nL", "1KN", "54h", "6Ub", "7ko", "4Nm", "01K", "Vq", "Yp", "0zB", "4Al", "60G", 
			
 
				+"6Zc", "bUs", "0Tn", "3T", "zl", "8PF", "4bp", "5g0", "aSm", "787", "03z", "1r2", "4e9", "44P", "0Kv", "hD", "Fh", "0eZ", "5NU", "6kW", 
			
 
				+"6fg", "4SD", "0hj", "KX", "et", "0FF", "5mI", "6HK", "6GJ", "46a", "0IG", "ju", "Q", "Q8", "5Ld", "6if", "5T5", "4Qu", "1zz", "Ii", 
			
 
				+"gE", "0Dw", "5ox", "4j8", "55r", "402", "yG", "0Zu", "00Q", "Wk", "5J7", "4Ow", "4BG", "63l", "2LJ", "0yi", "0WE", "tw", "6YH", "4lk", 
			
 
				+"4cj", "6VI", "2mg", "0XD", "0vh", "UZ", "6xe", "4MF", "5PW", "5E6", "Xj", "1ky", "0Ut", "2N", "7KX", "4nZ", "5OC", "6jA", "2Qo", "0dL", 
			
 
				+"1ZA", "iR", "6Dm", "45F", "48v", "acO", "db", "0GP", "94M", "JN", "4G3", "4RR", "5Mr", "4H2", "EO", "12T", "0HQ", "kc", "527", "47w", 
			
 
				+"5nn", "6Kl", "fS", "s2", "0kM", "3NO", "71i", "4Pc", "7kc", "4Na", "01G", "3PM", "xQ", "m0", "54d", "6Un", "a6D", "59T", "0VS", "1i", 
			
 
				+"197", "85o", "4CQ", "4V0", "4Y1", "4LP", "03v", "TL", "0L3", "0YR", "56U", "a9E", "6Zo", "4oL", "b1", "3X", "2Om", "0zN", "5QA", "60K", 
			
 
				+"ex", "0FJ", "49l", "6HG", "6fk", "4SH", "0hf", "KT", "Fd", "0eV", "5NY", "aAI", "4e5", "4pT", "0Kz", "hH", "gI", "1TZ", "5ot", "4j4", 
			
 
				+"5T9", "4Qy", "0jW", "Ie", "DU", "Q4", "5Lh", "6ij", "6GF", "46m", "0IK", "jy", "0WI", "0s", "6YD", "4lg", "4BK", "6wh", "ZW", "O6", 
			
 
				+"0tU", "Wg", "6zX", "6o9", "4aW", "4t6", "yK", "0Zy", "0Ux", "2B", "7KT", "4nV", "bzI", "61Q", "Xf", "1ku", "02l", "UV", "6xi", "4MJ", 
			
 
				+"4cf", "6VE", "2mk", "0XH", "0Jd", "iV", "6Di", "45B", "5OG", "6jE", "Gz", "0dH", "0ix", "JJ", "4G7", "4RV", "48r", "6IY", "df", "0GT", 
			
 
				+"0HU", "kg", "523", "47s", "5Mv", "4H6", "EK", "0fy", "0kI", "3NK", "6eD", "4Pg", "5nj", "6Kh", "fW", "s6", "xU", "m4", "5ph", "6Uj", 
			
 
				+"7kg", "4Ne", "01C", "Vy", "193", "1hZ", "4CU", "4V4", "5h9", "4my", "0VW", "1m", "zd", "0YV", "4bx", "5g8", "4Y5", "4LT", "03r", "TH", 
			
 
				+"Yx", "0zJ", "4Ad", "60O", "6Zk", "4oH", "b5", "wT", "6fo", "4SL", "0hb", "KP", "27e", "0FN", "49h", "6HC", "4e1", "44X", "8Bf", "hL", 
			
 
				+"0p3", "0eR", "bdO", "aAM", "70w", "657", "0jS", "Ia", "gM", "8Mg", "5op", "4j0", "6GB", "46i", "0IO", "28d", "Y", "Q0", "5Ll", "6in", 
			
 
				+"4BO", "63d", "ZS", "O2", "0WM", "0w", "7Ia", "4lc", "4aS", "4t2", "yO", "8Se", "00Y", "Wc", "aPN", "b1D", "bzM", "61U", "Xb", "1kq", 
			
 
				+"216", "2F", "7KP", "4nR", "4cb", "6VA", "2mo", "0XL", "02h", "UR", "6xm", "4MN", "5j7", "4ow", "0TY", "3c", "YG", "0zu", "5Qz", "60p", 
			
 
				+"6yH", "4Lk", "03M", "Tw", "2lJ", "0Yi", "4bG", "6Wd", "6Xe", "4mF", "0Vh", "1R", "2Mg", "0xD", "4Cj", "62A", "7kX", "4NZ", "0ut", "VF", 
			
 
				+"xj", "1Ky", "5pW", "5e6", "5nU", "6KW", "fh", "0EZ", "0kv", "HD", "4E9", "4PX", "5MI", "6hK", "Et", "0fF", "0Hj", "kX", "6Fg", "47L", 
			
 
				+"48M", "6If", "dY", "50", "0iG", "Ju", "6gJ", "4Ri", "5Ox", "4J8", "GE", "0dw", "1Zz", "ii", "5t5", "4qu", "02W", "Um", "5H1", "4Mq", 
			
 
				+"57t", "424", "2mP", "0Xs", "0UC", "2y", "7Ko", "4nm", "bzr", "61j", "2NL", "1kN", "00f", "2AM", "6zc", "bus", "4al", "6TO", "yp", "0ZB", 
			
 
				+"0Wr", "0H", "a7e", "58u", "4Bp", "5G0", "Zl", "84N", "f", "13u", "5LS", "5Y2", "amo", "46V", "0Ip", "jB", "gr", "1Ta", "5oO", "6JM", 
			
 
				+"6da", "4QB", "0jl", "3On", "2PN", "0em", "5Nb", "aAr", "6EL", "44g", "0KA", "hs", "eC", "0Fq", "49W", "abn", "5V3", "4Ss", "8aE", "Ko", 
			
 
				+"YC", "0zq", "754", "60t", "5j3", "4os", "9Md", "3g", "2lN", "0Ym", "4bC", "7GA", "6yL", "4Lo", "03I", "Ts", "2Mc", "1ha", "4Cn", "62E", 
			
 
				+"6Xa", "4mB", "0Vl", "1V", "xn", "8RD", "5pS", "5e2", "aQo", "b0e", "01x", "VB", "0kr", "1n2", "71V", "bjo", "5nQ", "6KS", "fl", "315", 
			
 
				+"0Hn", "29E", "6Fc", "47H", "5MM", "6hO", "Ep", "0fB", "0iC", "Jq", "6gN", "4Rm", "48I", "6Ib", "26D", "54", "8CG", "im", "509", "45y", 
			
 
				+"ben", "hYU", "GA", "0ds", "4cY", "420", "2mT", "0Xw", "02S", "Ui", "5H5", "4Mu", "5Pd", "61n", "XY", "M8", "0UG", "vu", "7Kk", "4ni", 
			
 
				+"4ah", "6TK", "yt", "0ZF", "B9", "WX", "6zg", "4OD", "4Bt", "5G4", "Zh", "0yZ", "0Wv", "0L", "4y9", "4lX", "6Gy", "46R", "0It", "jF", 
			
 
				+"b", "0gX", "5LW", "5Y6", "6de", "4QF", "0jh", "IZ", "gv", "0DD", "5oK", "6JI", "6EH", "44c", "0KE", "hw", "2PJ", "0ei", "5Nf", "6kd", 
			
 
				+"5V7", "4Sw", "0hY", "Kk", "eG", "0Fu", "49S", "6Hx", "7ia", "4Lc", "03E", "2Bn", "zS", "o2", "4bO", "6Wl", "a4F", "bUL", "0TQ", "3k", 
			
 
				+"YO", "87m", "4AS", "4T2", "7kP", "4NR", "01t", "VN", "xb", "1Kq", "54W", "hfv", "6Xm", "4mN", "1FA", "1Z", "2Mo", "0xL", "4Cb", "62I", 
			
 
				+"5MA", "6hC", "2Sm", "0fN", "0Hb", "kP", "6Fo", "47D", "bDO", "aaM", "0P3", "0ER", "8bf", "HL", "4E1", "4PP", "5Op", "4J0", "GM", "10V", 
			
 
				+"0JS", "ia", "505", "45u", "48E", "6In", "dQ", "58", "0iO", "3LM", "6gB", "4Ra", "0UK", "2q", "7Kg", "4ne", "5Ph", "61b", "XU", "M4", 
			
 
				+"0vW", "Ue", "5H9", "4My", "4cU", "4v4", "2mX", "1HZ", "0Wz", "tH", "4y5", "4lT", "4Bx", "5G8", "Zd", "0yV", "B5", "WT", "6zk", "4OH", 
			
 
				+"4ad", "6TG", "yx", "0ZJ", "gz", "0DH", "5oG", "6JE", "6di", "4QJ", "0jd", "IV", "n", "0gT", "680", "6iY", "4g7", "4rV", "0Ix", "jJ", 
			
 
				+"eK", "0Fy", "5mv", "4h6", "6fX", "5CZ", "0hU", "Kg", "FW", "S6", "5Nj", "6kh", "6ED", "44o", "0KI", "3nK", "zW", "o6", "4bK", "6Wh", 
			
 
				+"6yD", "4Lg", "03A", "2Bj", "YK", "0zy", "4AW", "4T6", "6ZX", "6O9", "0TU", "3o", "xf", "1Ku", "54S", "6UY", "7kT", "4NV", "01p", "VJ", 
			
 
				+"2Mk", "0xH", "4Cf", "62M", "6Xi", "4mJ", "0Vd", "uV", "0Hf", "kT", "6Fk", "4sH", "5ME", "6hG", "Ex", "0fJ", "0kz", "HH", "4E5", "4PT", 
			
 
				+"5nY", "aaI", "fd", "0EV", "0JW", "ie", "501", "45q", "5Ot", "4J4", "GI", "10R", "0iK", "Jy", "6gF", "4Re", "48A", "6Ij", "dU", "q4", 
			
 
				+"5Pl", "61f", "XQ", "M0", "0UO", "2u", "7Kc", "4na", "4cQ", "428", "39u", "8Qg", "0vS", "Ua", "aRL", "b3F", "bxO", "63W", "0l3", "0yR", 
			
 
				+"234", "0D", "4y1", "4lP", "55I", "6TC", "2om", "0ZN", "B1", "WP", "6zo", "4OL", "6dm", "4QN", "1zA", "IR", "25g", "0DL", "5oC", "6JA", 
			
 
				+"4g3", "46Z", "9PE", "jN", "j", "0gP", "684", "aCO", "72u", "675", "0hQ", "Kc", "eO", "8Oe", "5mr", "4h2", "7Ua", "44k", "0KM", "3nO", 
			
 
				+"FS", "S2", "5Nn", "6kl", "4x6", "4mW", "0Vy", "1C", "0m4", "0xU", "5SZ", "62P", "7kI", "4NK", "C6", "VW", "2nj", "1Kh", "54N", "6UD", 
			
 
				+"6ZE", "4of", "0TH", "3r", "YV", "L7", "4AJ", "60a", "6yY", "4Lz", "0wT", "Tf", "zJ", "0Yx", "4bV", "4w7", "5lu", "4i5", "dH", "0Gz", 
			
 
				+"0iV", "Jd", "5W8", "4Rx", "5Oi", "6jk", "GT", "R5", "0JJ", "ix", "6DG", "45l", "5nD", "6KF", "fy", "0EK", "0kg", "HU", "6ej", "4PI", 
			
 
				+"5MX", "5X9", "Ee", "0fW", "1XZ", "kI", "4f4", "4sU", "00w", "WM", "4Z0", "4OQ", "55T", "hgu", "ya", "0ZS", "a0", "0Y", "6Yn", "4lM", 
			
 
				+"4Ba", "63J", "2Ll", "0yO", "02F", "2Cm", "6xC", "aG0", "4cL", "6Vo", "2mA", "n1", "0UR", "2h", "a5E", "bTO", "5Pq", "4U1", "XL", "86n", 
			
 
				+"FN", "11U", "5Ns", "4K3", "516", "44v", "0KP", "hb", "eR", "p3", "49F", "6Hm", "6fA", "4Sb", "0hL", "3MN", "w", "0gM", "5LB", "7ya", 
			
 
				+"6Gl", "46G", "0Ia", "jS", "gc", "0DQ", "bEL", "hyw", "4D2", "4QS", "8ce", "IO", "0m0", "0xQ", "byL", "62T", "4x2", "4mS", "227", "1G", 
			
 
				+"2nn", "1Kl", "54J", "7Ea", "7kM", "4NO", "C2", "VS", "YR", "L3", "4AN", "60e", "6ZA", "4ob", "0TL", "3v", "zN", "8Pd", "4bR", "4w3", 
			
 
				+"aSO", "b2E", "03X", "Tb", "0iR", "3LP", "73v", "666", "48X", "4i1", "dL", "8Nf", "0JN", "3oL", "6DC", "45h", "5Om", "6jo", "GP", "R1", 
			
 
				+"0kc", "HQ", "6en", "4PM", "a09", "6KB", "24d", "0EO", "8Ag", "kM", "4f0", "47Y", "697", "aBL", "Ea", "0fS", "4ay", "5d9", "ye", "0ZW", 
			
 
				+"00s", "WI", "4Z4", "4OU", "4Be", "63N", "Zy", "0yK", "a4", "tU", "6Yj", "4lI", "4cH", "6Vk", "2mE", "n5", "02B", "Ux", "6xG", "4Md", 
			
 
				+"5Pu", "4U5", "XH", "86j", "0UV", "2l", "5k8", "4nx", "512", "44r", "0KT", "hf", "FJ", "0ex", "5Nw", "4K7", "6fE", "4Sf", "0hH", "Kz", 
			
 
				+"eV", "p7", "49B", "6Hi", "6Gh", "46C", "0Ie", "jW", "s", "0gI", "5LF", "6iD", "4D6", "4QW", "0jy", "IK", "gg", "0DU", "5oZ", "6JX", 
			
 
				+"7kA", "4NC", "01e", "3Po", "xs", "8RY", "54F", "6UL", "a6f", "59v", "0Vq", "1K", "d3E", "85M", "4Cs", "5F3", "5I2", "4Lr", "03T", "Tn", 
			
 
				+"zB", "0Yp", "56w", "437", "6ZM", "4on", "1Da", "3z", "2OO", "0zl", "4AB", "60i", "5Oa", "6jc", "2QM", "0dn", "0JB", "ip", "6DO", "45d", 
			
 
				+"48T", "acm", "1B2", "0Gr", "94o", "Jl", "5W0", "4Rp", "5MP", "5X1", "Em", "12v", "0Hs", "kA", "all", "47U", "5nL", "6KN", "fq", "0EC", 
			
 
				+"0ko", "3Nm", "6eb", "4PA", "a8", "0Q", "6Yf", "4lE", "4Bi", "63B", "Zu", "0yG", "0tw", "WE", "4Z8", "4OY", "4au", "5d5", "yi", "1Jz", 
			
 
				+"0UZ", "vh", "5k4", "4nt", "5Py", "4U9", "XD", "1kW", "02N", "Ut", "6xK", "4Mh", "4cD", "6Vg", "2mI", "n9", "eZ", "43", "49N", "6He", 
			
 
				+"6fI", "4Sj", "0hD", "Kv", "FF", "0et", "7n9", "6ky", "5u6", "4pv", "0KX", "hj", "gk", "0DY", "5oV", "5z7", "6dx", "5Az", "0ju", "IG", 
			
 
				+"Dw", "0gE", "5LJ", "6iH", "6Gd", "46O", "0Ii", "28B", "xw", "1Kd", "54B", "6UH", "7kE", "4NG", "01a", "3Pk", "0m8", "0xY", "4Cw", "5F7", 
			
 
				+"6Xx", "59r", "0Vu", "1O", "zF", "0Yt", "4bZ", "433", "5I6", "4Lv", "03P", "Tj", "YZ", "0zh", "4AF", "60m", "6ZI", "4oj", "0TD", "wv", 
			
 
				+"0JF", "it", "6DK", "4qh", "5Oe", "6jg", "GX", "R9", "0iZ", "Jh", "5W4", "4Rt", "48P", "4i9", "dD", "0Gv", "0Hw", "kE", "4f8", "47Q", 
			
 
				+"5MT", "5X5", "Ei", "12r", "0kk", "HY", "6ef", "4PE", "5nH", "6KJ", "fu", "0EG", "4Bm", "63F", "Zq", "0yC", "0Wo", "0U", "6Yb", "4lA", 
			
 
				+"4aq", "5d1", "ym", "8SG", "0ts", "WA", "aPl", "b1f", "747", "61w", "2NQ", "1kS", "9Lg", "2d", "5k0", "4np", "57i", "6Vc", "2mM", "0Xn", 
			
 
				+"02J", "Up", "6xO", "4Ml", "6fM", "4Sn", "1xa", "Kr", "27G", "47", "49J", "6Ha", "5u2", "44z", "8BD", "hn", "FB", "0ep", "bdm", "aAo", 
			
 
				+"70U", "bkl", "0jq", "IC", "go", "306", "5oR", "5z3", "7WA", "46K", "0Im", "28F", "Ds", "0gA", "5LN", "6iL", "0cY", "020", "6mT", "4Xw", 
			
 
				+"42S", "6Cx", "nG", "0Mu", "1Pd", "cw", "6NH", "5kJ", "4UG", "74M", "3Kk", "0ni", "0ah", "BZ", "6oe", "4ZF", "40b", "6AI", "lv", "0OD", 
			
 
				+"0Bt", "aF", "6Ly", "4yZ", "4Wv", "5R6", "Oj", "0lX", "Qh", "06R", "4It", "5L4", "461", "4gX", "1LW", "1Y6", "rt", "0QF", "4jh", "7Oj", 
			
 
				+"65o", "4DD", "I9", "2JI", "SY", "F8", "4KE", "7nG", "6PJ", "4ei", "1Nf", "2kd", "4M", "0Sw", "4hY", "490", "5C5", "4Fu", "09S", "2Hx", 
			
 
				+"6OR", "4zq", "354", "bm", "LA", "0os", "bnn", "75W", "6lN", "4Ym", "0bC", "Aq", "2yL", "0Lo", "43I", "6Bb", "6Mc", "5ha", "15", "22E", 
			
 
				+"Np", "0mB", "4Vl", "6cO", "aDm", "bao", "1pS", "1e2", "ml", "8GF", "41x", "548", "4kr", "5n2", "7f", "8YD", "1nQ", "2KS", "64u", "715", 
			
 
				+"4Hn", "69E", "Pr", "07H", "1MM", "2hO", "6Sa", "4fB", "4iC", "7LA", "5W", "0Rm", "08I", "2Ib", "66D", "4Go", "b4d", "aUn", "RC", "05y", 
			
 
				+"8VE", "8g", "5a3", "4ds", "42W", "ain", "nC", "0Mq", "17t", "024", "6mP", "4Xs", "4UC", "74I", "3Ko", "0nm", "8IY", "cs", "6NL", "5kN", 
			
 
				+"40f", "6AM", "lr", "8FX", "0al", "2TO", "6oa", "4ZB", "4Wr", "5R2", "On", "18u", "0Bp", "aB", "afo", "bCm", "465", "53u", "1LS", "1Y2", 
			
 
				+"Ql", "06V", "4Ip", "5L0", "65k", "5Ta", "1oO", "2JM", "6x", "0QB", "4jl", "7On", "6PN", "4em", "1Nb", "9y", "2EL", "04g", "4KA", "7nC", 
			
 
				+"5C1", "4Fq", "09W", "d6G", "4I", "0Ss", "bRn", "494", "LE", "0ow", "4TY", "4A8", "6OV", "4zu", "1Qz", "bi", "oY", "z8", "43M", "6Bf", 
			
 
				+"6lJ", "4Yi", "0bG", "Au", "Nt", "0mF", "4Vh", "6cK", "6Mg", "4xD", "11", "22A", "mh", "0NZ", "4ut", "5p4", "4N9", "5Ky", "1pW", "CD", 
			
 
				+"1nU", "2KW", "64q", "4EZ", "4kv", "5n6", "7b", "0PX", "1MI", "2hK", "6Se", "4fF", "4Hj", "69A", "Pv", "07L", "08M", "2If", "6rH", "4Gk", 
			
 
				+"4iG", "7LE", "5S", "0Ri", "1Ox", "8c", "5a7", "4dw", "5Zz", "7oY", "RG", "0qu", "1Pl", "21f", "adR", "5kB", "4UO", "74E", "MS", "X2", 
			
 
				+"0cQ", "028", "79u", "bbL", "4vS", "4c2", "nO", "8De", "8Kd", "aN", "4l3", "4yR", "634", "76t", "Ob", "0lP", "W3", "BR", "6om", "4ZN", 
			
 
				+"40j", "6AA", "2zo", "0OL", "6t", "0QN", "5zA", "7Ob", "65g", "4DL", "I1", "2JA", "0g3", "06Z", "b7G", "68W", "469", "4gP", "284", "dSn", 
			
 
				+"4E", "275", "4hQ", "498", "67V", "b8F", "1mr", "0h2", "SQ", "F0", "4KM", "7nO", "6PB", "4ea", "1Nn", "9u", "6lF", "4Ye", "0bK", "Ay", 
			
 
				+"oU", "z4", "43A", "6Bj", "6OZ", "4zy", "0AW", "be", "LI", "2O9", "4TU", "4A4", "4N5", "5Ku", "14S", "CH", "md", "0NV", "41p", "540", 
			
 
				+"6Mk", "4xH", "u5", "22M", "Nx", "0mJ", "4Vd", "6cG", "4Hf", "69M", "Pz", "0sH", "k7", "2hG", "6Si", "4fJ", "4kz", "7Nx", "7n", "0PT", 
			
 
				+"1nY", "dqh", "4P7", "4EV", "4JW", "7oU", "RK", "05q", "1Ot", "8o", "6QX", "50R", "4iK", "7LI", "qW", "d6", "08A", "2Ij", "66L", "4Gg", 
			
 
				+"4UK", "74A", "MW", "X6", "1Ph", "21b", "6ND", "5kF", "4vW", "4c6", "nK", "0My", "0cU", "0v4", "6mX", "5HZ", "4Wz", "6bY", "Of", "0lT", 
			
 
				+"0Bx", "aJ", "4l7", "4yV", "40n", "6AE", "lz", "0OH", "W7", "BV", "6oi", "4ZJ", "65c", "4DH", "I5", "2JE", "6p", "0QJ", "4jd", "7Of", 
			
 
				+"4r5", "4gT", "280", "2iY", "Qd", "0rV", "4Ix", "5L8", "5C9", "4Fy", "1mv", "0h6", "4A", "1CZ", "4hU", "7MW", "6PF", "4ee", "1Nj", "9q", 
			
 
				+"SU", "F4", "4KI", "7nK", "oQ", "z0", "43E", "6Bn", "6lB", "4Ya", "0bO", "2Wl", "LM", "8fg", "4TQ", "4A0", "aeL", "cPo", "0AS", "ba", 
			
 
				+"3kP", "0NR", "41t", "544", "4N1", "5Kq", "14W", "CL", "2Xm", "0mN", "5FA", "6cC", "6Mo", "4xL", "19", "22I", "k3", "2hC", "6Sm", "4fN", 
			
 
				+"4Hb", "69I", "2Fo", "07D", "83l", "d5d", "4P3", "4ER", "bQM", "a0G", "7j", "0PP", "1Op", "8k", "hbw", "50V", "4JS", "7oQ", "RO", "05u", 
			
 
				+"08E", "2In", "66H", "4Gc", "4iO", "7LM", "qS", "d2", "0ay", "BK", "4O6", "4ZW", "40s", "553", "lg", "0OU", "t6", "aW", "6Lh", "4yK", 
			
 
				+"4Wg", "6bD", "2Yj", "0lI", "0cH", "2Vk", "6mE", "4Xf", "42B", "6Ci", "nV", "0Md", "1Pu", "cf", "6NY", "bAI", "4UV", "7pT", "MJ", "0nx", 
			
 
				+"SH", "04r", "4KT", "7nV", "azI", "4ex", "1Nw", "9l", "pT", "e5", "4hH", "7MJ", "67O", "4Fd", "09B", "2Hi", "Qy", "06C", "4Ie", "68N", 
			
 
				+"6Rj", "4gI", "j4", "2iD", "6m", "0QW", "4jy", "5o9", "4Q4", "4DU", "1oZ", "2JX", "4m0", "4xQ", "8Jg", "22T", "Na", "0mS", "627", "77w", 
			
 
				+"6nn", "5Kl", "V0", "CQ", "3kM", "0NO", "41i", "7Pc", "6OC", "5jA", "0AN", "20e", "LP", "Y1", "4TL", "6ao", "78v", "bcO", "0bR", "0w3", 
			
 
				+"oL", "8Ef", "43X", "4b1", "4iR", "7LP", "5F", "266", "08X", "0i1", "66U", "b9E", "4JN", "7oL", "RR", "G3", "1Om", "8v", "6QA", "4db", 
			
 
				+"4kc", "7Na", "7w", "0PM", "H2", "2KB", "64d", "4EO", "b6D", "69T", "Pc", "07Y", "297", "dRm", "4s2", "4fS", "40w", "557", "lc", "0OQ", 
			
 
				+"15T", "BO", "4O2", "4ZS", "4Wc", "76i", "2Yn", "0lM", "t2", "aS", "6Ll", "4yO", "42F", "6Cm", "nR", "8Dx", "0cL", "2Vo", "6mA", "4Xb", 
			
 
				+"4UR", "74X", "MN", "8gd", "1Pq", "cb", "adO", "bAM", "azM", "51U", "1Ns", "9h", "SL", "04v", "4KP", "7nR", "67K", "5VA", "09F", "2Hm", 
			
 
				+"4X", "e1", "4hL", "7MN", "6Rn", "4gM", "j0", "3ya", "2Gl", "06G", "4Ia", "68J", "4Q0", "4DQ", "82o", "d4g", "6i", "0QS", "bPN", "a1D", 
			
 
				+"Ne", "0mW", "4Vy", "5S9", "4m4", "4xU", "1SZ", "22P", "my", "0NK", "41m", "7Pg", "6nj", "5Kh", "V4", "CU", "LT", "Y5", "4TH", "6ak", 
			
 
				+"6OG", "4zd", "0AJ", "bx", "oH", "0Lz", "4wT", "4b5", "78r", "4Yx", "0bV", "Ad", "1lu", "0i5", "66Q", "4Gz", "4iV", "7LT", "5B", "0Rx", 
			
 
				+"1Oi", "8r", "6QE", "4df", "4JJ", "7oH", "RV", "G7", "H6", "2KF", "6ph", "4EK", "4kg", "7Ne", "7s", "0PI", "1MX", "1X9", "4s6", "4fW", 
			
 
				+"5XZ", "69P", "Pg", "0sU", "06", "23F", "afr", "4yC", "4Wo", "6bL", "Os", "0lA", "0aq", "BC", "aEn", "c4E", "4ts", "5q3", "lo", "8FE", 
			
 
				+"347", "cn", "6NQ", "5kS", "bom", "74T", "MB", "0np", "17i", "2Vc", "6mM", "4Xn", "42J", "6Ca", "2xO", "0Ml", "4T", "0Sn", "5xa", "7MB", 
			
 
				+"67G", "4Fl", "09J", "2Ha", "1u2", "04z", "b5g", "aTm", "6PS", "4ep", "8WF", "9d", "6e", "8XG", "4jq", "5o1", "65v", "706", "1oR", "1z3", 
			
 
				+"Qq", "06K", "4Im", "68F", "6Rb", "4gA", "1LN", "2iL", "6nf", "5Kd", "V8", "CY", "mu", "0NG", "41a", "7Pk", "4m8", "4xY", "0Cw", "1F7", 
			
 
				+"Ni", "19r", "4Vu", "5S5", "6lW", "4Yt", "0bZ", "Ah", "oD", "0Lv", "43P", "4b9", "6OK", "4zh", "0AF", "bt", "LX", "Y9", "4TD", "6ag", 
			
 
				+"4JF", "7oD", "RZ", "0qh", "1Oe", "2jg", "6QI", "4dj", "4iZ", "483", "5N", "0Rt", "08P", "0i9", "5B6", "4Gv", "4Hw", "5M7", "Pk", "07Q", 
			
 
				+"1MT", "1X5", "472", "52r", "4kk", "7Ni", "sw", "0PE", "1nH", "2KJ", "64l", "4EG", "4Wk", "6bH", "Ow", "0lE", "02", "23B", "6Ld", "4yG", 
			
 
				+"4tw", "5q7", "lk", "0OY", "0au", "BG", "6ox", "5Jz", "4UZ", "74P", "MF", "0nt", "1Py", "cj", "6NU", "5kW", "42N", "6Ce", "nZ", "0Mh", 
			
 
				+"0cD", "2Vg", "6mI", "4Xj", "67C", "4Fh", "09N", "2He", "4P", "e9", "4hD", "7MF", "6PW", "4et", "3n9", "2ky", "SD", "0pv", "4KX", "7nZ", 
			
 
				+"4Q8", "4DY", "1oV", "1z7", "6a", "1Az", "4ju", "5o5", "6Rf", "4gE", "j8", "2iH", "Qu", "06O", "4Ii", "68B", "mq", "0NC", "41e", "7Po", 
			
 
				+"6nb", "bar", "14F", "2UL", "Nm", "19v", "4Vq", "5S1", "agl", "bBn", "0Cs", "1F3", "1I2", "0Lr", "43T", "ahm", "6lS", "4Yp", "16w", "Al", 
			
 
				+"2ZM", "0on", "5Da", "6ac", "6OO", "4zl", "0AB", "bp", "1Oa", "8z", "6QM", "4dn", "4JB", "aUs", "2DO", "05d", "08T", "d7D", "5B2", "4Gr", 
			
 
				+"bSm", "487", "5J", "0Rp", "1MP", "1X1", "476", "52v", "4Hs", "5M3", "Po", "07U", "1nL", "2KN", "64h", "4EC", "4ko", "7Nm", "ss", "0PA", 
			
 
				+"QJ", "06p", "4IV", "7lT", "6RY", "4gz", "1Lu", "0I5", "rV", "g7", "4jJ", "7OH", "65M", "4Df", "1oi", "2Jk", "2Ej", "04A", "4Kg", "7ne", 
			
 
				+"6Ph", "4eK", "h6", "2kF", "4o", "0SU", "5xZ", "7My", "4S6", "4FW", "09q", "1x9", "17R", "2VX", "4M4", "4XU", "42q", "571", "ne", "0MW", 
			
 
				+"v4", "cU", "6Nj", "5kh", "4Ue", "74o", "My", "0nK", "0aJ", "Bx", "6oG", "4Zd", "4tH", "6Ak", "lT", "y5", "0BV", "ad", "580", "4yx", 
			
 
				+"4WT", "4B5", "OH", "0lz", "4kP", "7NR", "7D", "244", "1ns", "0k3", "64W", "con", "4HL", "69g", "PP", "E1", "1Mo", "2hm", "6SC", "52I", 
			
 
				+"4ia", "7Lc", "5u", "0RO", "J0", "3Ya", "66f", "4GM", "b4F", "aUL", "Ra", "0qS", "8Vg", "8E", "458", "4dQ", "4o2", "4zS", "8He", "bO", 
			
 
				+"Lc", "0oQ", "605", "75u", "6ll", "4YO", "T2", "AS", "2yn", "0LM", "43k", "7Ra", "6MA", "4xb", "0CL", "22g", "NR", "19I", "4VN", "6cm", 
			
 
				+"aDO", "baM", "14y", "Cb", "mN", "8Gd", "41Z", "7PP", "axO", "53W", "1Lq", "0I1", "QN", "06t", "4IR", "68y", "65I", "4Db", "1om", "2Jo", 
			
 
				+"6Z", "g3", "4jN", "7OL", "6Pl", "4eO", "h2", "2kB", "2En", "04E", "4Kc", "7na", "4S2", "4FS", "09u", "d6e", "4k", "0SQ", "bRL", "a3F", 
			
 
				+"42u", "575", "na", "0MS", "17V", "dlo", "4M0", "4XQ", "4Ua", "74k", "3KM", "0nO", "28", "cQ", "6Nn", "5kl", "40D", "6Ao", "lP", "y1", 
			
 
				+"0aN", "2Tm", "6oC", "5JA", "4WP", "4B1", "OL", "18W", "0BR", "0W3", "584", "bCO", "1nw", "0k7", "64S", "4Ex", "4kT", "7NV", "sH", "0Pz", 
			
 
				+"1Mk", "2hi", "6SG", "4fd", "4HH", "69c", "PT", "E5", "J4", "2ID", "66b", "4GI", "4ie", "7Lg", "5q", "0RK", "1OZ", "8A", "4q4", "4dU", 
			
 
				+"4Jy", "5O9", "Re", "0qW", "Lg", "0oU", "5DZ", "6aX", "4o6", "4zW", "0Ay", "bK", "2yj", "0LI", "43o", "6BD", "6lh", "4YK", "T6", "AW", 
			
 
				+"NV", "0md", "4VJ", "6ci", "6ME", "4xf", "0CH", "22c", "mJ", "0Nx", "4uV", "7PT", "6nY", "baI", "1pu", "Cf", "6V", "0Ql", "4jB", "aus", 
			
 
				+"65E", "4Dn", "1oa", "2Jc", "QB", "06x", "b7e", "68u", "5b2", "4gr", "8UD", "dSL", "4g", "8ZE", "4hs", "5m3", "67t", "724", "09y", "1x1", 
			
 
				+"Ss", "04I", "4Ko", "7nm", "azr", "4eC", "1NL", "9W", "24", "21D", "6Nb", "bAr", "4Um", "74g", "Mq", "0nC", "0cs", "1f3", "79W", "bbn", 
			
 
				+"42y", "579", "nm", "394", "365", "al", "588", "4yp", "bmo", "76V", "1i2", "0lr", "0aB", "Bp", "6oO", "4Zl", "40H", "6Ac", "2zM", "0On", 
			
 
				+"4HD", "69o", "PX", "E9", "1Mg", "2he", "6SK", "4fh", "4kX", "7NZ", "7L", "0Pv", "3N9", "2Ky", "6pW", "4Et", "4Ju", "5O5", "Ri", "05S", 
			
 
				+"1OV", "8M", "450", "4dY", "4ii", "7Lk", "qu", "0RG", "J8", "2IH", "66n", "4GE", "6ld", "4YG", "0bi", "2WJ", "ow", "0LE", "43c", "6BH", 
			
 
				+"6Ox", "5jz", "0Au", "bG", "Lk", "0oY", "4Tw", "5Q7", "6nU", "5KW", "14q", "Cj", "mF", "0Nt", "41R", "7PX", "6MI", "4xj", "0CD", "22o", 
			
 
				+"NZ", "0mh", "4VF", "6ce", "65A", "4Dj", "1oe", "2Jg", "6R", "0Qh", "4jF", "7OD", "5b6", "4gv", "1Ly", "0I9", "QF", "0rt", "4IZ", "68q", 
			
 
				+"67p", "5Vz", "1mT", "1x5", "4c", "0SY", "4hw", "5m7", "6Pd", "4eG", "1NH", "9S", "Sw", "04M", "4Kk", "7ni", "4Ui", "74c", "Mu", "0nG", 
			
 
				+"20", "cY", "6Nf", "5kd", "4vu", "5s5", "ni", "390", "0cw", "1f7", "4M8", "4XY", "4WX", "4B9", "OD", "0lv", "0BZ", "ah", "6LW", "4yt", 
			
 
				+"40L", "6Ag", "lX", "y9", "0aF", "Bt", "6oK", "4Zh", "1Mc", "2ha", "6SO", "4fl", "5Xa", "69k", "2FM", "07f", "83N", "d5F", "6pS", "4Ep", 
			
 
				+"bQo", "a0e", "7H", "0Pr", "1OR", "8I", "454", "50t", "4Jq", "5O1", "Rm", "05W", "08g", "2IL", "66j", "4GA", "4im", "7Lo", "5y", "0RC", 
			
 
				+"os", "0LA", "43g", "6BL", "78I", "4YC", "0bm", "2WN", "Lo", "8fE", "4Ts", "5Q3", "aen", "cPM", "0Aq", "bC", "mB", "0Np", "41V", "ajo", 
			
 
				+"6nQ", "5KS", "14u", "Cn", "2XO", "0ml", "4VB", "6ca", "6MM", "4xn", "1Sa", "22k", "Sj", "04P", "4Kv", "5N6", "443", "4eZ", "1NU", "9N", 
			
 
				+"pv", "0SD", "4hj", "7Mh", "67m", "4FF", "1mI", "2HK", "2GJ", "2", "4IG", "68l", "6RH", "4gk", "1Ld", "2if", "6O", "0Qu", "5zz", "7OY", 
			
 
				+"5A7", "4Dw", "1ox", "0j8", "15r", "Bi", "6oV", "4Zu", "40Q", "4a8", "lE", "0Ow", "0BG", "au", "6LJ", "4yi", "4WE", "6bf", "OY", "Z8", 
			
 
				+"U9", "2VI", "6mg", "4XD", "4vh", "6CK", "nt", "0MF", "1PW", "cD", "4n9", "5ky", "4Ut", "5P4", "Mh", "0nZ", "4ip", "5l0", "5d", "9Kg", 
			
 
				+"08z", "1y2", "66w", "737", "4Jl", "7on", "Rp", "05J", "1OO", "8T", "6Qc", "50i", "4kA", "7NC", "7U", "0Po", "1nb", "dqS", "64F", "4Em", 
			
 
				+"b6f", "69v", "PA", "0ss", "8TG", "dRO", "5c1", "4fq", "6MP", "4xs", "376", "22v", "NC", "0mq", "bll", "77U", "6nL", "5KN", "14h", "Cs", 
			
 
				+"3ko", "0Nm", "41K", "7PA", "6Oa", "4zB", "37", "20G", "Lr", "8fX", "4Tn", "6aM", "78T", "bcm", "0bp", "AB", "on", "387", "43z", "5r2", 
			
 
				+"447", "51w", "1NQ", "9J", "Sn", "04T", "4Kr", "5N2", "67i", "4FB", "09d", "2HO", "4z", "1Ca", "4hn", "7Ml", "6RL", "4go", "8UY", "2ib", 
			
 
				+"2GN", "6", "4IC", "68h", "5A3", "4Ds", "82M", "d4E", "6K", "0Qq", "bPl", "a1f", "40U", "akl", "lA", "0Os", "15v", "Bm", "6oR", "4Zq", 
			
 
				+"4WA", "6bb", "2YL", "0lo", "0BC", "aq", "6LN", "4ym", "42d", "6CO", "np", "0MB", "0cn", "2VM", "6mc", "5Ha", "4Up", "5P0", "Ml", "8gF", 
			
 
				+"1PS", "1E2", "adm", "bAo", "1lW", "1y6", "4R9", "4GX", "4it", "5l4", "qh", "0RZ", "i9", "8P", "6Qg", "4dD", "4Jh", "7oj", "Rt", "05N", 
			
 
				+"1nf", "2Kd", "64B", "4Ei", "4kE", "7NG", "7Q", "f8", "1Mz", "2hx", "5c5", "4fu", "4HY", "69r", "PE", "0sw", "NG", "0mu", "5Fz", "6cx", 
			
 
				+"6MT", "4xw", "0CY", "0V8", "3kk", "0Ni", "41O", "7PE", "6nH", "5KJ", "14l", "Cw", "Lv", "0oD", "4Tj", "6aI", "6Oe", "4zF", "33", "bZ", 
			
 
				+"oj", "0LX", "4wv", "5r6", "6ly", "4YZ", "0bt", "AF", "4v", "0SL", "4hb", "awS", "67e", "4FN", "K3", "2HC", "Sb", "04X", "b5E", "aTO", 
			
 
				+"4p3", "4eR", "8Wd", "9F", "6G", "257", "4jS", "7OQ", "65T", "cnm", "1op", "0j0", "QS", "D2", "4IO", "68d", "7Ba", "4gc", "1Ll", "2in", 
			
 
				+"0BO", "23d", "6LB", "4ya", "4WM", "6bn", "OQ", "Z0", "0aS", "Ba", "aEL", "c4g", "40Y", "4a0", "lM", "8Fg", "8If", "cL", "4n1", "5kq", 
			
 
				+"616", "74v", "3KP", "0nR", "U1", "2VA", "6mo", "4XL", "42h", "6CC", "2xm", "0MN", "4Jd", "7of", "Rx", "05B", "i5", "2jE", "6Qk", "4dH", 
			
 
				+"4ix", "5l8", "5l", "0RV", "08r", "2IY", "4R5", "4GT", "4HU", "7mW", "PI", "07s", "1Mv", "0H6", "5c9", "4fy", "4kI", "7NK", "sU", "f4", 
			
 
				+"1nj", "2Kh", "64N", "4Ee", "6nD", "5KF", "1ph", "2Uj", "mW", "x6", "41C", "7PI", "593", "5hZ", "0CU", "0V4", "NK", "0my", "4VW", "4C6", 
			
 
				+"4L7", "4YV", "0bx", "AJ", "of", "0LT", "43r", "562", "6Oi", "4zJ", "w7", "bV", "Lz", "0oH", "4Tf", "6aE", "67a", "4FJ", "K7", "2HG", 
			
 
				+"4r", "0SH", "4hf", "7Md", "4p7", "4eV", "1NY", "9B", "Sf", "0pT", "4Kz", "7nx", "65P", "5TZ", "1ot", "0j4", "6C", "0Qy", "4jW", "7OU", 
			
 
				+"6RD", "4gg", "1Lh", "2ij", "QW", "D6", "4IK", "7lI", "4WI", "6bj", "OU", "Z4", "0BK", "ay", "6LF", "4ye", "4tU", "4a4", "lI", "2o9", 
			
 
				+"0aW", "Be", "6oZ", "4Zy", "4Ux", "5P8", "Md", "0nV", "8Ib", "cH", "4n5", "5ku", "42l", "6CG", "nx", "0MJ", "U5", "2VE", "6mk", "4XH", 
			
 
				+"i1", "8X", "6Qo", "4dL", "5ZA", "7ob", "2Dm", "05F", "08v", "d7f", "4R1", "4GP", "bSO", "a2E", "5h", "0RR", "1Mr", "0H2", "ayL", "52T", 
			
 
				+"4HQ", "69z", "PM", "07w", "1nn", "2Kl", "64J", "4Ea", "4kM", "7NO", "7Y", "f0", "mS", "x2", "41G", "7PM", "aDR", "5KB", "14d", "2Un", 
			
 
				+"NO", "19T", "4VS", "4C2", "597", "bBL", "0CQ", "0V0", "ob", "0LP", "43v", "566", "4L3", "4YR", "16U", "AN", "2Zo", "0oL", "4Tb", "6aA", 
			
 
				+"6Om", "4zN", "w3", "bR", "4oT", "4z5", "wH", "0Tz", "0zV", "Yd", "5D8", "4Ax", "4LH", "6yk", "TT", "A5", "0YJ", "zx", "6WG", "4bd", 
			
 
				+"4me", "6XF", "1q", "0VK", "N4", "2MD", "62b", "4CI", "4Ny", "5K9", "Ve", "0uW", "1KZ", "xI", "4u4", "5pt", "4k6", "5nv", "0Ey", "fK", 
			
 
				+"Hg", "0kU", "641", "6eX", "6hh", "5Mj", "P6", "EW", "29b", "0HI", "47o", "6FD", "6IE", "48n", "0GH", "dz", "JV", "0id", "4RJ", "6gi", 
			
 
				+"6jY", "beI", "0dT", "Gf", "iJ", "0Jx", "4qV", "4d7", "UN", "02t", "4MR", "4X3", "a8G", "57W", "0XP", "0M1", "2Z", "c3", "4nN", "7KL", 
			
 
				+"61I", "5PC", "1km", "2No", "2An", "00E", "4Oc", "7ja", "6Tl", "4aO", "l2", "yS", "0k", "0WQ", "58V", "a7F", "4W2", "4BS", "84m", "ZO", 
			
 
				+"13V", "E", "4I0", "5Lp", "46u", "535", "ja", "0IS", "68", "gQ", "6Jn", "5ol", "4Qa", "6dB", "3OM", "0jO", "0eN", "2Pm", "6kC", "5NA", 
			
 
				+"44D", "6Eo", "hP", "99", "0FR", "0S3", "abM", "49t", "4SP", "4F1", "KL", "8af", "0zR", "0o3", "60W", "ckn", "4oP", "4z1", "3D", "204", 
			
 
				+"0YN", "2lm", "6WC", "56I", "4LL", "6yo", "TP", "A1", "N0", "903", "62f", "4CM", "4ma", "6XB", "1u", "0VO", "8Rg", "xM", "418", "54x", 
			
 
				+"b0F", "aQL", "Va", "0uS", "Hc", "0kQ", "645", "71u", "4k2", "5nr", "8Le", "fO", "29f", "0HM", "47k", "7Va", "6hl", "5Mn", "P2", "ES", 
			
 
				+"JR", "1yA", "4RN", "6gm", "6IA", "48j", "0GL", "26g", "iN", "8Cd", "45Z", "4d3", "hYv", "beM", "0dP", "Gb", "6VY", "4cz", "0XT", "0M5", 
			
 
				+"UJ", "02p", "4MV", "4X7", "61M", "5PG", "1ki", "Xz", "vV", "c7", "4nJ", "7KH", "6Th", "4aK", "l6", "yW", "2Aj", "00A", "4Og", "6zD", 
			
 
				+"4W6", "4BW", "0yy", "ZK", "0o", "0WU", "58R", "6YX", "46q", "531", "je", "0IW", "13R", "A", "4I4", "5Lt", "4Qe", "6dF", "Iy", "0jK", 
			
 
				+"r4", "gU", "6Jj", "5oh", "4pH", "6Ek", "hT", "0Kf", "0eJ", "Fx", "6kG", "5NE", "4ST", "4F5", "KH", "0hz", "0FV", "ed", "5x8", "49p", 
			
 
				+"bvs", "6yc", "2BM", "03f", "0YB", "zp", "6WO", "4bl", "bUo", "a4e", "3H", "0Tr", "87N", "Yl", "5D0", "4Ap", "4Nq", "5K1", "Vm", "01W", 
			
 
				+"1KR", "xA", "414", "54t", "4mm", "6XN", "1y", "0VC", "0xo", "2ML", "62j", "4CA", "7xA", "5Mb", "0fm", "2SN", "ks", "0HA", "47g", "6FL", 
			
 
				+"aan", "bDl", "0Eq", "fC", "Ho", "8bE", "4Ps", "5U3", "5Z2", "5OS", "10u", "Gn", "iB", "0Jp", "45V", "ano", "6IM", "48f", "1Wa", "dr", 
			
 
				+"3Ln", "0il", "4RB", "6ga", "2R", "0Uh", "4nF", "7KD", "61A", "5PK", "1ke", "Xv", "UF", "0vt", "4MZ", "6xy", "5f6", "4cv", "0XX", "0M9", 
			
 
				+"0c", "0WY", "4lw", "5i7", "63p", "5Rz", "0yu", "ZG", "Ww", "00M", "4Ok", "6zH", "6Td", "4aG", "0Zi", "2oJ", "60", "gY", "6Jf", "5od", 
			
 
				+"4Qi", "6dJ", "Iu", "0jG", "0gw", "M", "4I8", "5Lx", "4ru", "5w5", "ji", "1Yz", "0FZ", "eh", "5x4", "5mU", "4SX", "4F9", "KD", "0hv", 
			
 
				+"0eF", "Ft", "6kK", "5NI", "44L", "6Eg", "hX", "91", "0YF", "zt", "6WK", "4bh", "4LD", "6yg", "TX", "A9", "0zZ", "Yh", "5D4", "4At", 
			
 
				+"4oX", "4z9", "3L", "0Tv", "1KV", "xE", "410", "54p", "4Nu", "5K5", "Vi", "01S", "N8", "2MH", "62n", "4CE", "4mi", "6XJ", "uu", "0VG", 
			
 
				+"kw", "0HE", "47c", "6FH", "6hd", "5Mf", "0fi", "2SJ", "Hk", "0kY", "4Pw", "5U7", "6Kx", "5nz", "0Eu", "fG", "iF", "0Jt", "45R", "6Dy", 
			
 
				+"5Z6", "5OW", "0dX", "Gj", "JZ", "0ih", "4RF", "6ge", "6II", "48b", "0GD", "dv", "61E", "5PO", "1ka", "Xr", "2V", "0Ul", "4nB", "aqs", 
			
 
				+"5f2", "4cr", "8QD", "39V", "UB", "02x", "795", "aRo", "63t", "764", "0yq", "ZC", "0g", "9Nd", "4ls", "5i3", "7DA", "4aC", "0Zm", "2oN", 
			
 
				+"Ws", "00I", "4Oo", "6zL", "4Qm", "6dN", "Iq", "0jC", "64", "25D", "6Jb", "bEr", "46y", "539", "jm", "9Pf", "0gs", "I", "aCl", "bfn", 
			
 
				+"bio", "72V", "1m2", "0hr", "325", "el", "5x0", "49x", "44H", "6Ec", "3nl", "95", "0eB", "Fp", "6kO", "5NM", "4mt", "5h4", "uh", "0VZ", 
			
 
				+"0xv", "2MU", "4V9", "4CX", "4Nh", "7kj", "Vt", "01N", "m9", "xX", "6Ug", "54m", "4oE", "6Zf", "3Q", "b8", "0zG", "Yu", "60B", "4Ai", 
			
 
				+"4LY", "4Y8", "TE", "0ww", "1Iz", "zi", "5g5", "4bu", "5y7", "5lV", "0GY", "dk", "JG", "0iu", "5Bz", "6gx", "6jH", "5OJ", "0dE", "Gw", 
			
 
				+"3ok", "82", "45O", "6Dd", "6Ke", "5ng", "73", "fZ", "Hv", "0kD", "4Pj", "6eI", "6hy", "7m9", "0ft", "EF", "kj", "0HX", "4sv", "5v6", 
			
 
				+"Wn", "00T", "4Or", "5J2", "407", "55w", "0Zp", "yB", "0z", "1Ga", "4ln", "6YM", "63i", "4BB", "0yl", "2LO", "2CN", "02e", "4MC", "7hA", 
			
 
				+"6VL", "4co", "0XA", "2mb", "2K", "0Uq", "bTl", "a5f", "5E3", "5PR", "86M", "Xo", "11v", "Fm", "6kR", "5NP", "44U", "aol", "hA", "0Ks", 
			
 
				+"0FC", "eq", "6HN", "49e", "4SA", "6fb", "3Mm", "0ho", "0gn", "T", "6ic", "5La", "46d", "6GO", "jp", "0IB", "0Dr", "1A2", "hyT", "bEo", 
			
 
				+"4Qp", "5T0", "Il", "8cF", "0xr", "2MQ", "62w", "777", "4mp", "5h0", "1d", "9Og", "1KO", "2nM", "6Uc", "54i", "4Nl", "7kn", "Vp", "01J", 
			
 
				+"0zC", "Yq", "60F", "4Am", "4oA", "6Zb", "3U", "0To", "8PG", "zm", "5g1", "4bq", "786", "aSl", "TA", "0ws", "JC", "0iq", "bhl", "73U", 
			
 
				+"5y3", "5lR", "336", "do", "3oo", "86", "45K", "7TA", "6jL", "5ON", "0dA", "Gs", "Hr", "8bX", "4Pn", "6eM", "6Ka", "5nc", "77", "24G", 
			
 
				+"kn", "8AD", "47z", "5v2", "aBo", "bgm", "0fp", "EB", "403", "4aZ", "0Zt", "yF", "Wj", "00P", "4Ov", "5J6", "63m", "4BF", "0yh", "ZZ", 
			
 
				+"tv", "0WD", "4lj", "6YI", "6VH", "4ck", "0XE", "2mf", "2CJ", "02a", "4MG", "6xd", "5E7", "5PV", "1kx", "Xk", "2O", "0Uu", "bTh", "7KY", 
			
 
				+"44Q", "4e8", "hE", "0Kw", "11r", "Fi", "6kV", "5NT", "4SE", "6ff", "KY", "0hk", "0FG", "eu", "6HJ", "49a", "4rh", "6GK", "jt", "0IF", 
			
 
				+"Q9", "P", "6ig", "5Le", "4Qt", "5T4", "Ih", "0jZ", "0Dv", "gD", "4j9", "5oy", "aD0", "7kb", "3PL", "01F", "m1", "xP", "6Uo", "54e", 
			
 
				+"59U", "a6E", "1h", "0VR", "85n", "196", "4V1", "4CP", "4LQ", "4Y0", "TM", "03w", "0YS", "za", "a9D", "56T", "4oM", "6Zn", "3Y", "b0", 
			
 
				+"0zO", "2Ol", "60J", "4Aa", "7za", "5OB", "0dM", "2Qn", "iS", "0Ja", "45G", "6Dl", "acN", "48w", "0GQ", "dc", "JO", "94L", "4RS", "4G2", 
			
 
				+"4H3", "5Ms", "12U", "EN", "kb", "0HP", "47v", "526", "6Km", "5no", "s3", "fR", "3NN", "0kL", "4Pb", "6eA", "0r", "0WH", "4lf", "6YE", 
			
 
				+"63a", "4BJ", "O7", "ZV", "Wf", "0tT", "4Oz", "6zY", "4t7", "4aV", "0Zx", "yJ", "2C", "0Uy", "4nW", "7KU", "61P", "5PZ", "1kt", "Xg", 
			
 
				+"UW", "02m", "4MK", "6xh", "6VD", "4cg", "0XI", "2mj", "0FK", "ey", "6HF", "49m", "4SI", "6fj", "KU", "0hg", "0eW", "Fe", "6kZ", "5NX", 
			
 
				+"4pU", "4e4", "hI", "2k9", "0Dz", "gH", "4j5", "5ou", "4Qx", "5T8", "Id", "0jV", "Q5", "DT", "6ik", "5Li", "46l", "6GG", "jx", "0IJ", 
			
 
				+"m5", "xT", "6Uk", "54a", "4Nd", "7kf", "Vx", "01B", "0xz", "192", "4V5", "4CT", "4mx", "5h8", "1l", "0VV", "0YW", "ze", "5g9", "4by", 
			
 
				+"4LU", "4Y4", "TI", "03s", "0zK", "Yy", "60N", "4Ae", "4oI", "6Zj", "wU", "b4", "iW", "0Je", "45C", "6Dh", "6jD", "5OF", "0dI", "2Qj", 
			
 
				+"JK", "0iy", "4RW", "4G6", "6IX", "48s", "0GU", "dg", "kf", "0HT", "47r", "522", "4H7", "5Mw", "0fx", "EJ", "Hz", "0kH", "4Pf", "6eE", 
			
 
				+"6Ki", "5nk", "s7", "fV", "63e", "4BN", "O3", "ZR", "0v", "0WL", "4lb", "6YA", "4t3", "4aR", "8Sd", "yN", "Wb", "00X", "b1E", "aPO", 
			
 
				+"61T", "bzL", "1kp", "Xc", "2G", "217", "4nS", "7KQ", "7Fa", "4cc", "0XM", "2mn", "US", "02i", "4MO", "6xl", "4SM", "6fn", "KQ", "0hc", 
			
 
				+"0FO", "27d", "6HB", "49i", "44Y", "4e0", "hM", "8Bg", "0eS", "Fa", "aAL", "bdN", "656", "70v", "3OP", "0jR", "8Mf", "gL", "4j1", "5oq", 
			
 
				+"46h", "6GC", "28e", "0IN", "Q1", "X", "6io", "5Lm", "6KV", "5nT", "1Uz", "fi", "HE", "0kw", "4PY", "4E8", "6hJ", "5MH", "0fG", "Eu", 
			
 
				+"kY", "0Hk", "47M", "6Ff", "6Ig", "48L", "51", "dX", "Jt", "0iF", "4Rh", "6gK", "4J9", "5Oy", "0dv", "GD", "ih", "0JZ", "4qt", "5t4", 
			
 
				+"4ov", "5j6", "3b", "0TX", "0zt", "YF", "60q", "4AZ", "4Lj", "6yI", "Tv", "03L", "0Yh", "zZ", "6We", "4bF", "4mG", "6Xd", "1S", "0Vi", 
			
 
				+"0xE", "2Mf", "6vH", "4Ck", "bth", "7kY", "VG", "0uu", "1Kx", "xk", "5e7", "5pV", "13t", "g", "5Y3", "5LR", "46W", "amn", "jC", "0Iq", 
			
 
				+"0DA", "gs", "6JL", "5oN", "4QC", "70I", "3Oo", "0jm", "0el", "2PO", "6ka", "5Nc", "44f", "6EM", "hr", "8BX", "0Fp", "eB", "abo", "49V", 
			
 
				+"4Sr", "5V2", "Kn", "8aD", "Ul", "02V", "4Mp", "5H0", "425", "57u", "0Xr", "2mQ", "2x", "0UB", "4nl", "7Kn", "61k", "5Pa", "1kO", "2NM", 
			
 
				+"2AL", "00g", "4OA", "6zb", "6TN", "4am", "0ZC", "yq", "0I", "0Ws", "58t", "a7d", "5G1", "4Bq", "84O", "Zm", "HA", "0ks", "bjn", "71W", 
			
 
				+"6KR", "5nP", "314", "fm", "29D", "0Ho", "47I", "6Fb", "6hN", "5ML", "0fC", "Eq", "Jp", "0iB", "4Rl", "6gO", "6Ic", "48H", "55", "26E", 
			
 
				+"il", "8CF", "45x", "508", "hYT", "beo", "0dr", "1a2", "0zp", "YB", "60u", "755", "4or", "5j2", "3f", "9Me", "0Yl", "2lO", "6Wa", "4bB", 
			
 
				+"4Ln", "6yM", "Tr", "03H", "0xA", "2Mb", "62D", "4Co", "4mC", "7HA", "1W", "0Vm", "8RE", "xo", "5e3", "54Z", "b0d", "aQn", "VC", "01y", 
			
 
				+"46S", "6Gx", "jG", "0Iu", "0gY", "c", "5Y7", "5LV", "4QG", "6dd", "3Ok", "0ji", "0DE", "gw", "6JH", "5oJ", "44b", "6EI", "hv", "0KD", 
			
 
				+"0eh", "FZ", "6ke", "5Ng", "4Sv", "5V6", "Kj", "0hX", "0Ft", "eF", "6Hy", "49R", "421", "4cX", "0Xv", "2mU", "Uh", "02R", "4Mt", "5H4", 
			
 
				+"61o", "5Pe", "M9", "XX", "vt", "0UF", "4nh", "7Kj", "6TJ", "4ai", "0ZG", "yu", "WY", "B8", "4OE", "6zf", "5G5", "4Bu", "1iz", "Zi", 
			
 
				+"0M", "0Ww", "4lY", "4y8", "6hB", "aW1", "0fO", "2Sl", "kQ", "0Hc", "47E", "6Fn", "aaL", "bDN", "0ES", "fa", "HM", "8bg", "4PQ", "4E0", 
			
 
				+"4J1", "5Oq", "10W", "GL", "3oP", "0JR", "45t", "504", "6Io", "48D", "59", "dP", "3LL", "0iN", "5BA", "6gC", "4Lb", "6yA", "2Bo", "03D", 
			
 
				+"o3", "zR", "6Wm", "4bN", "bUM", "a4G", "3j", "0TP", "87l", "YN", "4T3", "4AR", "4NS", "7kQ", "VO", "01u", "1Kp", "xc", "hfw", "54V", 
			
 
				+"4mO", "6Xl", "uS", "0Va", "0xM", "2Mn", "62H", "4Cc", "0DI", "25b", "6JD", "5oF", "4QK", "6dh", "IW", "0je", "0gU", "o", "6iX", "5LZ", 
			
 
				+"4rW", "4g6", "jK", "0Iy", "0Fx", "eJ", "4h7", "5mw", "4Sz", "6fY", "Kf", "0hT", "S7", "FV", "6ki", "5Nk", "44n", "6EE", "hz", "0KH", 
			
 
				+"2p", "0UJ", "4nd", "7Kf", "61c", "5Pi", "M5", "XT", "Ud", "0vV", "4Mx", "5H8", "4v5", "4cT", "0Xz", "2mY", "0A", "1GZ", "4lU", "4y4", 
			
 
				+"5G9", "4By", "0yW", "Ze", "WU", "B4", "4OI", "6zj", "6TF", "4ae", "0ZK", "yy", "kU", "0Hg", "47A", "6Fj", "6hF", "5MD", "0fK", "Ey", 
			
 
				+"HI", "2K9", "4PU", "4E4", "6KZ", "5nX", "0EW", "fe", "id", "0JV", "45p", "500", "4J5", "5Ou", "0dz", "GH", "Jx", "0iJ", "4Rd", "6gG", 
			
 
				+"6Ik", "5li", "q5", "dT", "o7", "zV", "6Wi", "4bJ", "4Lf", "6yE", "Tz", "0wH", "0zx", "YJ", "4T7", "4AV", "4oz", "6ZY", "3n", "0TT", 
			
 
				+"1Kt", "xg", "6UX", "54R", "4NW", "7kU", "VK", "01q", "0xI", "2Mj", "62L", "4Cg", "4mK", "6Xh", "uW", "0Ve", "4QO", "6dl", "IS", "0ja", 
			
 
				+"0DM", "25f", "7Za", "5oB", "4rS", "4g2", "jO", "9PD", "0gQ", "k", "aCN", "685", "674", "72t", "Kb", "0hP", "8Od", "eN", "4h3", "49Z", 
			
 
				+"44j", "6EA", "3nN", "0KL", "S3", "FR", "6km", "5No", "61g", "5Pm", "M1", "XP", "2t", "0UN", "ad0", "7Kb", "429", "4cP", "8Qf", "39t", 
			
 
				+"0c3", "02Z", "b3G", "aRM", "63V", "bxN", "0yS", "Za", "0E", "235", "4lQ", "4y0", "6TB", "4aa", "0ZO", "2ol", "WQ", "B0", "4OM", "6zn", 
			
 
				+"4i4", "5lt", "1WZ", "dI", "Je", "0iW", "4Ry", "5W9", "6jj", "5Oh", "R4", "GU", "iy", "0JK", "45m", "6DF", "6KG", "5nE", "0EJ", "fx", 
			
 
				+"HT", "0kf", "4PH", "6ek", "5X8", "5MY", "0fV", "Ed", "kH", "0Hz", "4sT", "4f5", "4mV", "4x7", "1B", "0Vx", "0xT", "0m5", "62Q", "4Cz", 
			
 
				+"4NJ", "7kH", "VV", "C7", "1Ki", "xz", "6UE", "54O", "4og", "6ZD", "3s", "0TI", "L6", "YW", "6th", "4AK", "6l9", "6yX", "Tg", "0wU", 
			
 
				+"0Yy", "zK", "4w6", "4bW", "11T", "FO", "4K2", "5Nr", "44w", "517", "hc", "0KQ", "p2", "eS", "6Hl", "49G", "4Sc", "72i", "3MO", "0hM", 
			
 
				+"0gL", "v", "6iA", "5LC", "46F", "6Gm", "jR", "1YA", "0DP", "gb", "hyv", "bEM", "4QR", "4D3", "IN", "8cd", "WL", "00v", "4OP", "4Z1", 
			
 
				+"hgt", "55U", "0ZR", "0O3", "0X", "a1", "4lL", "6Yo", "63K", "5RA", "0yN", "2Lm", "2Cl", "02G", "4Ma", "6xB", "6Vn", "4cM", "n0", "39i", 
			
 
				+"2i", "0US", "bTN", "a5D", "4U0", "5Pp", "86o", "XM", "Ja", "0iS", "667", "73w", "4i0", "48Y", "8Ng", "dM", "3oM", "0JO", "45i", "6DB", 
			
 
				+"6jn", "5Ol", "R0", "GQ", "HP", "0kb", "4PL", "6eo", "6KC", "5nA", "0EN", "24e", "kL", "8Af", "47X", "4f1", "aBM", "696", "0fR", "0s3", 
			
 
				+"0xP", "0m1", "62U", "byM", "4mR", "4x3", "1F", "226", "1Km", "2no", "6UA", "54K", "4NN", "7kL", "VR", "C3", "L2", "YS", "60d", "4AO", 
			
 
				+"4oc", "7Ja", "3w", "0TM", "8Pe", "zO", "4w2", "4bS", "b2D", "aSN", "Tc", "03Y", "44s", "513", "hg", "0KU", "0ey", "FK", "4K6", "5Nv", 
			
 
				+"4Sg", "6fD", "3MK", "0hI", "p6", "eW", "6Hh", "49C", "46B", "6Gi", "jV", "0Id", "0gH", "r", "6iE", "5LG", "4QV", "4D7", "IJ", "0jx", 
			
 
				+"0DT", "gf", "6JY", "bEI", "5d8", "4ax", "0ZV", "yd", "WH", "00r", "4OT", "4Z5", "63O", "4Bd", "0yJ", "Zx", "tT", "a5", "4lH", "6Yk", 
			
 
				+"6Vj", "4cI", "n4", "2mD", "Uy", "02C", "4Me", "6xF", "4U4", "5Pt", "1kZ", "XI", "2m", "0UW", "4ny", "5k9", "6jb", "ber", "0do", "2QL", 
			
 
				+"iq", "0JC", "45e", "6DN", "acl", "48U", "0Gs", "dA", "Jm", "94n", "4Rq", "5W1", "5X0", "5MQ", "12w", "El", "1M2", "0Hr", "47T", "alm", 
			
 
				+"6KO", "5nM", "0EB", "fp", "3Nl", "0kn", "bjs", "6ec", "4NB", "aQs", "3Pn", "01d", "1Ka", "xr", "6UM", "54G", "59w", "a6g", "1J", "0Vp", 
			
 
				+"85L", "d3D", "5F2", "4Cr", "4Ls", "5I3", "To", "03U", "0Yq", "zC", "436", "56v", "4oo", "6ZL", "ws", "0TA", "0zm", "2ON", "60h", "4AC", 
			
 
				+"42", "27B", "6Hd", "49O", "4Sk", "6fH", "Kw", "0hE", "0eu", "FG", "6kx", "5Nz", "4pw", "5u7", "hk", "0KY", "0DX", "gj", "5z6", "5oW", 
			
 
				+"4QZ", "6dy", "IF", "0jt", "0gD", "Dv", "6iI", "5LK", "46N", "6Ge", "jZ", "0Ih", "0P", "a9", "4lD", "6Yg", "63C", "4Bh", "0yF", "Zt", 
			
 
				+"WD", "0tv", "4OX", "4Z9", "5d4", "4at", "0ZZ", "yh", "2a", "1Ez", "4nu", "5k5", "4U8", "5Px", "1kV", "XE", "Uu", "02O", "4Mi", "6xJ", 
			
 
				+"6Vf", "4cE", "n8", "2mH", "iu", "0JG", "45a", "6DJ", "6jf", "5Od", "R8", "GY", "Ji", "1yz", "4Ru", "5W5", "4i8", "48Q", "0Gw", "dE", 
			
 
				+"kD", "0Hv", "47P", "4f9", "5X4", "5MU", "0fZ", "Eh", "HX", "0kj", "4PD", "6eg", "6KK", "5nI", "0EF", "ft", "1Ke", "xv", "6UI", "54C", 
			
 
				+"4NF", "7kD", "VZ", "0uh", "0xX", "0m9", "5F6", "4Cv", "4mZ", "6Xy", "1N", "0Vt", "0Yu", "zG", "432", "56r", "4Lw", "5I7", "Tk", "03Q", 
			
 
				+"0zi", "2OJ", "60l", "4AG", "4ok", "6ZH", "ww", "0TE", "4So", "6fL", "Ks", "0hA", "46", "27F", "7XA", "49K", "4ps", "5u3", "ho", "8BE", 
			
 
				+"0eq", "FC", "aAn", "bdl", "bkm", "70T", "IB", "0jp", "307", "gn", "5z2", "5oS", "46J", "6Ga", "28G", "0Il", "13i", "z", "6iM", "5LO", 
			
 
				+"63G", "4Bl", "0yB", "Zp", "0T", "0Wn", "58i", "6Yc", "5d0", "4ap", "8SF", "yl", "1q2", "00z", "b1g", "aPm", "61v", "746", "1kR", "XA", 
			
 
				+"2e", "9Lf", "4nq", "5k1", "6Vb", "4cA", "0Xo", "2mL", "Uq", "02K", "4Mm", "6xN", "8YG", "7e", "5n1", "4kq", "716", "64v", "2KP", "1nR", 
			
 
				+"07K", "Pq", "69F", "4Hm", "4fA", "6Sb", "2hL", "1MN", "0Rn", "5T", "7LB", "5ya", "4Gl", "66G", "2Ia", "08J", "05z", "1t2", "aUm", "b4g", 
			
 
				+"4dp", "5a0", "8d", "8VF", "bn", "357", "4zr", "6OQ", "75T", "bnm", "0op", "LB", "Ar", "16i", "4Yn", "6lM", "6Ba", "43J", "0Ll", "2yO", 
			
 
				+"22F", "16", "4xC", "agr", "6cL", "4Vo", "0mA", "Ns", "CC", "14X", "bal", "aDn", "5p3", "4us", "8GE", "mo", "5L7", "4Iw", "06Q", "Qk", 
			
 
				+"1Y5", "1LT", "53r", "462", "7Oi", "4jk", "0QE", "rw", "2JJ", "1oH", "4DG", "65l", "7nD", "4KF", "0ph", "SZ", "2kg", "1Ne", "4ej", "6PI", 
			
 
				+"493", "4hZ", "0St", "4N", "0h9", "09P", "4Fv", "5C6", "4Xt", "6mW", "023", "0cZ", "0Mv", "nD", "4c9", "42P", "5kI", "6NK", "ct", "1Pg", 
			
 
				+"X9", "MX", "74N", "4UD", "4ZE", "6of", "BY", "W8", "0OG", "lu", "6AJ", "40a", "4yY", "4l8", "aE", "0Bw", "18r", "Oi", "5R5", "4Wu", 
			
 
				+"4EY", "4P8", "2KT", "1nV", "8YC", "7a", "5n5", "4ku", "4fE", "6Sf", "2hH", "k8", "07O", "Pu", "69B", "4Hi", "4Gh", "66C", "2Ie", "08N", 
			
 
				+"d9", "5P", "7LF", "4iD", "4dt", "5a4", "2jy", "3o9", "0qv", "RD", "7oZ", "4JX", "6ay", "4TZ", "0ot", "LF", "bj", "0AX", "4zv", "6OU", 
			
 
				+"6Be", "43N", "0Lh", "oZ", "Av", "0bD", "4Yj", "6lI", "6cH", "4Vk", "0mE", "Nw", "22B", "12", "4xG", "6Md", "5p7", "4uw", "0NY", "mk", 
			
 
				+"CG", "1pT", "5Kz", "6nx", "1Y1", "1LP", "53v", "466", "5L3", "4Is", "06U", "Qo", "2JN", "1oL", "4DC", "65h", "7Om", "4jo", "0QA", "rs", 
			
 
				+"9z", "1Na", "4en", "6PM", "aTs", "4KB", "04d", "2EO", "d6D", "09T", "4Fr", "5C2", "497", "bRm", "0Sp", "4J", "0Mr", "1H2", "aim", "42T", 
			
 
				+"4Xp", "6mS", "027", "17w", "0nn", "3Kl", "74J", "5Ea", "5kM", "6NO", "cp", "1Pc", "0OC", "lq", "6AN", "40e", "4ZA", "6ob", "2TL", "0ao", 
			
 
				+"18v", "Om", "5R1", "4Wq", "bCn", "afl", "aA", "0Bs", "07C", "Py", "69N", "4He", "4fI", "6Sj", "2hD", "k4", "0PW", "7m", "5n9", "4ky", 
			
 
				+"4EU", "4P4", "2KX", "1nZ", "05r", "RH", "7oV", "4JT", "4dx", "5a8", "8l", "1Ow", "d5", "qT", "7LJ", "4iH", "4Gd", "66O", "2Ii", "08B", 
			
 
				+"Az", "0bH", "4Yf", "6lE", "6Bi", "43B", "z7", "oV", "bf", "0AT", "4zz", "6OY", "4A7", "4TV", "0ox", "LJ", "CK", "14P", "5Kv", "4N6", 
			
 
				+"543", "41s", "0NU", "mg", "22N", "u6", "4xK", "6Mh", "6cD", "4Vg", "0mI", "2Xj", "7Oa", "4jc", "0QM", "6w", "2JB", "I2", "4DO", "65d", 
			
 
				+"68T", "b7D", "06Y", "Qc", "dSm", "287", "4gS", "4r2", "7MP", "4hR", "276", "4F", "0h1", "09X", "b8E", "67U", "7nL", "4KN", "F3", "SR", 
			
 
				+"9v", "1Nm", "4eb", "6PA", "5kA", "6NC", "21e", "1Po", "X1", "MP", "74F", "4UL", "bbO", "79v", "0v3", "0cR", "8Df", "nL", "4c1", "42X", 
			
 
				+"4yQ", "4l0", "aM", "8Kg", "0lS", "Oa", "76w", "637", "4ZM", "6on", "BQ", "W0", "0OO", "2zl", "6AB", "40i", "4fM", "6Sn", "3xa", "k0", 
			
 
				+"07G", "2Fl", "69J", "4Ha", "4EQ", "4P0", "d5g", "83o", "0PS", "7i", "a0D", "bQN", "50U", "hbt", "8h", "1Os", "05v", "RL", "7oR", "4JP", 
			
 
				+"5WA", "66K", "2Im", "08F", "d1", "5X", "7LN", "4iL", "6Bm", "43F", "z3", "oR", "2Wo", "0bL", "4Yb", "6lA", "4A3", "4TR", "8fd", "LN", 
			
 
				+"bb", "0AP", "cPl", "aeO", "547", "41w", "0NQ", "mc", "CO", "14T", "5Kr", "4N2", "77i", "4Vc", "0mM", "2Xn", "22J", "u2", "4xO", "6Ml", 
			
 
				+"2JF", "I6", "4DK", "6qh", "7Oe", "4jg", "0QI", "6s", "1Y9", "1LX", "4gW", "4r6", "68P", "5YZ", "0rU", "Qg", "0h5", "1mu", "4Fz", "67Q", 
			
 
				+"7MT", "4hV", "0Sx", "4B", "9r", "1Ni", "4ef", "6PE", "7nH", "4KJ", "F7", "SV", "X5", "MT", "74B", "4UH", "5kE", "6NG", "cx", "1Pk", 
			
 
				+"0Mz", "nH", "4c5", "4vT", "4Xx", "79r", "0v7", "0cV", "0lW", "Oe", "5R9", "4Wy", "4yU", "4l4", "aI", "1RZ", "0OK", "ly", "6AF", "40m", 
			
 
				+"4ZI", "6oj", "BU", "W4", "265", "5E", "488", "4iQ", "b9F", "66V", "0i2", "1lr", "G0", "RQ", "7oO", "4JM", "4da", "6QB", "8u", "1On", 
			
 
				+"0PN", "7t", "7Nb", "aa0", "4EL", "64g", "2KA", "H1", "07Z", "0f3", "69W", "b6G", "4fP", "479", "dRn", "294", "22W", "8Jd", "4xR", "4m3", 
			
 
				+"77t", "624", "0mP", "Nb", "CR", "V3", "5Ko", "6nm", "ajS", "41j", "0NL", "3kN", "20f", "0AM", "4zc", "aeR", "6al", "4TO", "Y2", "LS", 
			
 
				+"Ac", "0bQ", "bcL", "78u", "4b2", "4wS", "8Ee", "oO", "7nU", "4KW", "04q", "SK", "9o", "1Nt", "51R", "6PX", "7MI", "4hK", "e6", "pW", 
			
 
				+"2Hj", "09A", "4Fg", "67L", "68M", "4If", "0rH", "Qz", "2iG", "j7", "4gJ", "6Ri", "7Ox", "4jz", "0QT", "6n", "1z8", "1oY", "4DV", "4Q7", 
			
 
				+"4ZT", "4O5", "BH", "0az", "0OV", "ld", "550", "40p", "4yH", "6Lk", "aT", "t5", "0lJ", "Ox", "6bG", "4Wd", "4Xe", "6mF", "2Vh", "0cK", 
			
 
				+"0Mg", "nU", "6Cj", "42A", "5kX", "6NZ", "ce", "1Pv", "2N9", "MI", "7pW", "4UU", "4Gy", "5B9", "0i6", "1lv", "1BZ", "5A", "7LW", "4iU", 
			
 
				+"4de", "6QF", "8q", "1Oj", "G4", "RU", "7oK", "4JI", "4EH", "64c", "2KE", "H5", "0PJ", "7p", "7Nf", "4kd", "4fT", "4s5", "2hY", "290", 
			
 
				+"0sV", "Pd", "5M8", "4Hx", "6cY", "4Vz", "0mT", "Nf", "1F8", "0Cx", "4xV", "4m7", "7Pd", "41n", "0NH", "mz", "CV", "V7", "5Kk", "6ni", 
			
 
				+"6ah", "4TK", "Y6", "LW", "20b", "0AI", "4zg", "6OD", "4b6", "4wW", "0Ly", "oK", "Ag", "0bU", "5IZ", "6lX", "9k", "1Np", "51V", "azN", 
			
 
				+"7nQ", "4KS", "04u", "SO", "2Hn", "09E", "4Fc", "67H", "7MM", "4hO", "e2", "pS", "2iC", "j3", "4gN", "6Rm", "68I", "4Ib", "06D", "2Go", 
			
 
				+"d4d", "82l", "4DR", "4Q3", "a1G", "bPM", "0QP", "6j", "0OR", "0Z3", "554", "40t", "4ZP", "4O1", "BL", "15W", "0lN", "2Ym", "6bC", "5GA", 
			
 
				+"4yL", "6Lo", "aP", "09", "0Mc", "nQ", "6Cn", "42E", "4Xa", "6mB", "2Vl", "0cO", "8gg", "MM", "7pS", "4UQ", "bAN", "adL", "ca", "1Pr", 
			
 
				+"G8", "RY", "7oG", "4JE", "4di", "6QJ", "2jd", "1Of", "0Rw", "5M", "480", "4iY", "4Gu", "5B5", "2Ix", "08S", "07R", "Ph", "5M4", "4Ht", 
			
 
				+"4fX", "471", "1X6", "1MW", "0PF", "st", "7Nj", "4kh", "4ED", "64o", "2KI", "H9", "CZ", "14A", "5Kg", "6ne", "7Ph", "41b", "0ND", "mv", 
			
 
				+"1F4", "0Ct", "4xZ", "6My", "5S6", "4Vv", "0mX", "Nj", "Ak", "0bY", "4Yw", "6lT", "6Bx", "43S", "0Lu", "oG", "bw", "0AE", "4zk", "6OH", 
			
 
				+"6ad", "4TG", "0oi", "2ZJ", "7MA", "4hC", "0Sm", "4W", "2Hb", "09I", "4Fo", "67D", "aTn", "b5d", "04y", "SC", "9g", "8WE", "4es", "6PP", 
			
 
				+"5o2", "4jr", "8XD", "6f", "1z0", "1oQ", "705", "65u", "68E", "4In", "06H", "Qr", "2iO", "1LM", "4gB", "6Ra", "5ia", "6Lc", "23E", "05", 
			
 
				+"0lB", "Op", "6bO", "4Wl", "c4F", "aEm", "1d2", "0ar", "8FF", "ll", "558", "40x", "5kP", "6NR", "cm", "344", "0ns", "MA", "74W", "bon", 
			
 
				+"4Xm", "6mN", "3FA", "0cC", "0Mo", "2xL", "6Cb", "42I", "4dm", "6QN", "8y", "1Ob", "05g", "2DL", "7oC", "4JA", "4Gq", "5B1", "d7G", "08W", 
			
 
				+"0Rs", "5I", "484", "bSn", "52u", "475", "1X2", "1MS", "07V", "Pl", "5M0", "4Hp", "5Ua", "64k", "2KM", "1nO", "0PB", "7x", "7Nn", "4kl", 
			
 
				+"7Pl", "41f", "8GX", "mr", "2UO", "14E", "5Kc", "6na", "5S2", "4Vr", "19u", "Nn", "1F0", "0Cp", "bBm", "ago", "ahn", "43W", "0Lq", "oC", 
			
 
				+"Ao", "16t", "4Ys", "6lP", "75I", "4TC", "0om", "2ZN", "bs", "0AA", "4zo", "6OL", "2Hf", "09M", "4Fk", "6sH", "7ME", "4hG", "0Si", "4S", 
			
 
				+"9c", "1Nx", "4ew", "6PT", "7nY", "bqh", "0pu", "SG", "1z4", "1oU", "4DZ", "65q", "5o6", "4jv", "0QX", "6b", "2iK", "1LI", "4gF", "6Re", 
			
 
				+"68A", "4Ij", "06L", "Qv", "0lF", "Ot", "6bK", "4Wh", "4yD", "6Lg", "aX", "01", "0OZ", "lh", "5q4", "4tt", "4ZX", "4O9", "BD", "0av", 
			
 
				+"0nw", "ME", "74S", "4UY", "5kT", "6NV", "ci", "1Pz", "0Mk", "nY", "6Cf", "42M", "4Xi", "6mJ", "2Vd", "0cG", "bL", "8Hf", "4zP", "4o1", 
			
 
				+"75v", "606", "0oR", "0z3", "AP", "T1", "4YL", "6lo", "6BC", "43h", "0LN", "2ym", "22d", "0CO", "4xa", "6MB", "6cn", "4VM", "0mc", "NQ", 
			
 
				+"Ca", "14z", "baN", "aDL", "7PS", "41Y", "8Gg", "mM", "247", "7G", "7NQ", "4kS", "com", "64T", "0k0", "1np", "E2", "PS", "69d", "4HO", 
			
 
				+"4fc", "7Ca", "2hn", "1Ml", "0RL", "5v", "avS", "4ib", "4GN", "66e", "2IC", "J3", "05X", "Rb", "aUO", "b4E", "4dR", "4q3", "8F", "8Vd", 
			
 
				+"4XV", "4M7", "1f8", "0cx", "0MT", "nf", "572", "42r", "5kk", "6Ni", "cV", "v7", "0nH", "Mz", "74l", "4Uf", "4Zg", "6oD", "2Tj", "0aI", 
			
 
				+"y6", "lW", "6Ah", "40C", "5iZ", "583", "ag", "0BU", "0ly", "OK", "4B6", "4WW", "7lW", "4IU", "06s", "QI", "0I6", "1Lv", "4gy", "5b9", 
			
 
				+"7OK", "4jI", "g4", "rU", "2Jh", "1oj", "4De", "65N", "7nf", "4Kd", "04B", "Sx", "2kE", "h5", "4eH", "6Pk", "5m8", "4hx", "0SV", "4l", 
			
 
				+"2HY", "09r", "4FT", "4S5", "5Q8", "4Tx", "0oV", "Ld", "bH", "0Az", "4zT", "4o5", "6BG", "43l", "0LJ", "ox", "AT", "T5", "4YH", "6lk", 
			
 
				+"6cj", "4VI", "0mg", "NU", "2vh", "0CK", "4xe", "6MF", "7PW", "4uU", "2n9", "mI", "Ce", "1pv", "5KX", "6nZ", "5UZ", "64P", "0k4", "1nt", 
			
 
				+"0Py", "7C", "7NU", "4kW", "4fg", "6SD", "2hj", "1Mh", "E6", "PW", "7mI", "4HK", "4GJ", "66a", "2IG", "J7", "0RH", "5r", "7Ld", "4if", 
			
 
				+"4dV", "4q7", "8B", "1OY", "0qT", "Rf", "7ox", "4Jz", "0MP", "nb", "576", "42v", "4XR", "4M3", "dll", "17U", "0nL", "3KN", "74h", "4Ub", 
			
 
				+"5ko", "6Nm", "cR", "v3", "y2", "lS", "6Al", "40G", "4Zc", "aER", "2Tn", "0aM", "18T", "OO", "4B2", "4WS", "bCL", "587", "ac", "0BQ", 
			
 
				+"0I2", "1Lr", "53T", "axL", "68z", "4IQ", "06w", "QM", "2Jl", "1on", "4Da", "65J", "7OO", "4jM", "g0", "6Y", "9X", "h1", "4eL", "6Po", 
			
 
				+"7nb", "aA0", "04F", "2Em", "d6f", "09v", "4FP", "4S1", "a3E", "bRO", "0SR", "4h", "AX", "T9", "4YD", "6lg", "6BK", "4wh", "0LF", "ot", 
			
 
				+"bD", "0Av", "4zX", "4o9", "5Q4", "4Tt", "0oZ", "Lh", "Ci", "14r", "5KT", "6nV", "ajh", "41Q", "0Nw", "mE", "22l", "0CG", "4xi", "6MJ", 
			
 
				+"6cf", "4VE", "0mk", "NY", "07a", "2FJ", "69l", "4HG", "4fk", "6SH", "2hf", "1Md", "0Pu", "7O", "7NY", "bQh", "4Ew", "6pT", "0k8", "1nx", 
			
 
				+"05P", "Rj", "5O6", "4Jv", "4dZ", "453", "8N", "1OU", "0RD", "qv", "7Lh", "4ij", "4GF", "66m", "2IK", "1lI", "5kc", "6Na", "21G", "27", 
			
 
				+"8gX", "Mr", "74d", "4Un", "bbm", "79T", "1f0", "0cp", "397", "nn", "5s2", "42z", "4ys", "6LP", "ao", "366", "0lq", "OC", "76U", "bml", 
			
 
				+"4Zo", "6oL", "Bs", "0aA", "0Om", "2zN", "7QA", "40K", "7OC", "4jA", "0Qo", "6U", "3ZA", "1ob", "4Dm", "65F", "68v", "b7f", "0rs", "QA", 
			
 
				+"dSO", "8UG", "4gq", "5b1", "5m0", "4hp", "8ZF", "4d", "1x2", "09z", "727", "67w", "7nn", "4Kl", "04J", "Sp", "9T", "1NO", "51i", "6Pc", 
			
 
				+"6BO", "43d", "0LB", "op", "2WM", "0bn", "5Ia", "6lc", "5Q0", "4Tp", "8fF", "Ll", "1D2", "0Ar", "cPN", "aem", "ajl", "41U", "0Ns", "mA", 
			
 
				+"Cm", "14v", "5KP", "6nR", "6cb", "4VA", "0mo", "2XL", "22h", "0CC", "4xm", "6MN", "4fo", "6SL", "2hb", "8TY", "07e", "2FN", "69h", "4HC", 
			
 
				+"4Es", "64X", "d5E", "83M", "0Pq", "7K", "a0f", "bQl", "50w", "457", "8J", "1OQ", "05T", "Rn", "5O2", "4Jr", "4GB", "66i", "2IO", "08d", 
			
 
				+"1Ba", "5z", "7Ll", "4in", "0nD", "Mv", "7ph", "4Uj", "5kg", "6Ne", "cZ", "23", "0MX", "nj", "5s6", "4vv", "4XZ", "6my", "1f4", "0ct", 
			
 
				+"0lu", "OG", "6bx", "5Gz", "4yw", "6LT", "ak", "0BY", "0Oi", "2zJ", "6Ad", "40O", "4Zk", "6oH", "Bw", "0aE", "2Jd", "1of", "4Di", "65B", 
			
 
				+"7OG", "4jE", "g8", "6Q", "2ix", "1Lz", "4gu", "5b5", "68r", "4IY", "0rw", "QE", "1x6", "1mW", "4FX", "4S9", "5m4", "4ht", "0SZ", "ph", 
			
 
				+"9P", "h9", "4eD", "6Pg", "7nj", "4Kh", "04N", "St", "22u", "375", "4xp", "598", "77V", "blo", "0mr", "1h2", "Cp", "14k", "5KM", "6nO", 
			
 
				+"7PB", "41H", "0Nn", "3kl", "20D", "34", "4zA", "6Ob", "6aN", "4Tm", "0oC", "Lq", "AA", "0bs", "bcn", "78W", "569", "43y", "384", "om", 
			
 
				+"9Kd", "5g", "5l3", "4is", "734", "66t", "1y1", "08y", "05I", "Rs", "7om", "4Jo", "4dC", "7AA", "8W", "1OL", "0Pl", "7V", "ats", "4kB", 
			
 
				+"4En", "64E", "2Kc", "1na", "07x", "PB", "69u", "b6e", "4fr", "5c2", "dRL", "8TD", "4Zv", "6oU", "Bj", "0aX", "0Ot", "lF", "6Ay", "40R", 
			
 
				+"4yj", "6LI", "av", "0BD", "0lh", "OZ", "6be", "4WF", "4XG", "6md", "2VJ", "0ci", "0ME", "nw", "6CH", "42c", "5kz", "6Nx", "cG", "1PT", 
			
 
				+"0nY", "Mk", "5P7", "4Uw", "5N5", "4Ku", "04S", "Si", "9M", "1NV", "4eY", "440", "7Mk", "4hi", "0SG", "pu", "2HH", "K8", "4FE", "67n", 
			
 
				+"68o", "4ID", "1", "QX", "2ie", "1Lg", "4gh", "6RK", "7OZ", "4jX", "0Qv", "6L", "2Jy", "3O9", "4Dt", "5A4", "4C9", "4VX", "0mv", "ND", 
			
 
				+"22q", "0CZ", "4xt", "6MW", "7PF", "41L", "x9", "mX", "Ct", "14o", "5KI", "6nK", "6aJ", "4Ti", "0oG", "Lu", "bY", "30", "4zE", "6Of", 
			
 
				+"5r5", "4wu", "380", "oi", "AE", "0bw", "4YY", "4L8", "5Wz", "66p", "1y5", "1lT", "0RY", "5c", "5l7", "4iw", "4dG", "6Qd", "8S", "1OH", 
			
 
				+"05M", "Rw", "7oi", "4Jk", "4Ej", "64A", "2Kg", "1ne", "0Ph", "7R", "7ND", "4kF", "4fv", "5c6", "0H9", "1My", "0st", "PF", "69q", "4HZ", 
			
 
				+"0Op", "lB", "ako", "40V", "4Zr", "6oQ", "Bn", "15u", "0ll", "2YO", "6ba", "4WB", "4yn", "6LM", "ar", "1Ra", "0MA", "ns", "6CL", "42g", 
			
 
				+"4XC", "79I", "2VN", "0cm", "8gE", "Mo", "5P3", "4Us", "bAl", "adn", "cC", "1PP", "9I", "1NR", "51t", "444", "5N1", "4Kq", "04W", "Sm", 
			
 
				+"2HL", "09g", "4FA", "67j", "7Mo", "4hm", "0SC", "4y", "2ia", "1Lc", "4gl", "6RO", "68k", "5Ya", "5", "2GM", "d4F", "82N", "4Dp", "5A0", 
			
 
				+"a1e", "bPo", "0Qr", "6H", "Cx", "14c", "5KE", "6nG", "7PJ", "4uH", "x5", "mT", "0V7", "0CV", "4xx", "590", "4C5", "4VT", "0mz", "NH", 
			
 
				+"AI", "16R", "4YU", "4L4", "561", "43q", "0LW", "oe", "bU", "w4", "4zI", "6Oj", "6aF", "4Te", "0oK", "Ly", "05A", "2Dj", "7oe", "4Jg", 
			
 
				+"4dK", "6Qh", "2jF", "i6", "0RU", "5o", "7Ly", "5yZ", "4GW", "4R6", "1y9", "08q", "07p", "PJ", "7mT", "4HV", "4fz", "6SY", "0H5", "1Mu", 
			
 
				+"f7", "sV", "7NH", "4kJ", "4Ef", "64M", "2Kk", "1ni", "4yb", "6LA", "23g", "0BL", "Z3", "OR", "6bm", "4WN", "c4d", "aEO", "Bb", "0aP", 
			
 
				+"8Fd", "lN", "4a3", "40Z", "5kr", "4n2", "cO", "8Ie", "0nQ", "Mc", "74u", "615", "4XO", "6ml", "2VB", "U2", "0MM", "2xn", "7Sa", "42k", 
			
 
				+"7Mc", "4ha", "0SO", "4u", "3Xa", "K0", "4FM", "67f", "aTL", "b5F", "0pS", "Sa", "9E", "8Wg", "4eQ", "448", "7OR", "4jP", "254", "6D", 
			
 
				+"0j3", "1os", "cnn", "65W", "68g", "4IL", "9", "QP", "2im", "1Lo", "53I", "6RC", "7PN", "41D", "x1", "mP", "2Um", "14g", "5KA", "6nC", 
			
 
				+"4C1", "4VP", "19W", "NL", "0V3", "0CR", "bBO", "594", "565", "43u", "0LS", "oa", "AM", "16V", "4YQ", "4L0", "6aB", "4Ta", "0oO", "2Zl", 
			
 
				+"bQ", "38", "4zM", "6On", "4dO", "6Ql", "2jB", "i2", "05E", "2Dn", "7oa", "4Jc", "4GS", "4R2", "d7e", "08u", "0RQ", "5k", "a2F", "bSL", 
			
 
				+"52W", "ayO", "0H1", "1Mq", "07t", "PN", "69y", "4HR", "4Eb", "64I", "2Ko", "1nm", "f3", "7Z", "7NL", "4kN", "Z7", "OV", "6bi", "4WJ", 
			
 
				+"4yf", "6LE", "az", "0BH", "0Ox", "lJ", "4a7", "4tV", "4Zz", "6oY", "Bf", "0aT", "0nU", "Mg", "74q", "5EZ", "5kv", "4n6", "cK", "1PX", 
			
 
				+"0MI", "2xj", "6CD", "42o", "4XK", "6mh", "2VF", "U6", "2HD", "K4", "4FI", "67b", "7Mg", "4he", "0SK", "4q", "9A", "1NZ", "4eU", "4p4", 
			
 
				+"5N9", "4Ky", "0pW", "Se", "0j7", "1ow", "4Dx", "5A8", "7OV", "4jT", "0Qz", "rH", "2ii", "1Lk", "4gd", "6RG", "68c", "4IH", "D5", "QT", 
			
 
				+"5Ls", "4I3", "F", "13U", "0IP", "jb", "536", "46v", "5oo", "6Jm", "gR", "r3", "0jL", "3ON", "6dA", "4Qb", "5NB", "aAR", "2Pn", "0eM", 
			
 
				+"0Ka", "hS", "6El", "44G", "49w", "abN", "ec", "0FQ", "8ae", "KO", "4F2", "4SS", "4X0", "4MQ", "02w", "UM", "0M2", "0XS", "57T", "a8D", 
			
 
				+"7KO", "4nM", "c0", "2Y", "2Nl", "1kn", "aJ1", "61J", "6zC", "aE0", "00F", "2Am", "yP", "l1", "4aL", "6To", "a7E", "58U", "0WR", "0h", 
			
 
				+"ZL", "84n", "4BP", "4W1", "fH", "0Ez", "5nu", "4k5", "5U8", "4Px", "0kV", "Hd", "ET", "P5", "5Mi", "6hk", "6FG", "47l", "0HJ", "kx", 
			
 
				+"dy", "0GK", "48m", "6IF", "6gj", "4RI", "0ig", "JU", "Ge", "0dW", "5OX", "5Z9", "4d4", "4qU", "1ZZ", "iI", "0Ty", "3C", "4z6", "4oW", 
			
 
				+"5QZ", "60P", "Yg", "0zU", "A6", "TW", "6yh", "4LK", "4bg", "6WD", "2lj", "0YI", "0VH", "1r", "6XE", "4mf", "4CJ", "62a", "2MG", "N7", 
			
 
				+"0uT", "Vf", "7kx", "4Nz", "5pw", "4u7", "xJ", "1KY", "0IT", "jf", "532", "46r", "5Lw", "4I7", "B", "0gx", "0jH", "Iz", "6dE", "4Qf", 
			
 
				+"5ok", "6Ji", "gV", "r7", "0Ke", "hW", "6Eh", "44C", "5NF", "6kD", "2Pj", "0eI", "0hy", "KK", "4F6", "4SW", "49s", "6HX", "eg", "0FU", 
			
 
				+"0M6", "0XW", "4cy", "5f9", "4X4", "4MU", "02s", "UI", "Xy", "1kj", "5PD", "61N", "7KK", "4nI", "c4", "vU", "yT", "l5", "4aH", "6Tk", 
			
 
				+"6zG", "4Od", "00B", "Wx", "ZH", "0yz", "4BT", "4W5", "5i8", "4lx", "0WV", "0l", "71v", "646", "0kR", "3NP", "fL", "8Lf", "5nq", "4k1", 
			
 
				+"6FC", "47h", "0HN", "29e", "EP", "P1", "5Mm", "6ho", "6gn", "4RM", "0ic", "JQ", "26d", "0GO", "48i", "6IB", "4d0", "45Y", "8Cg", "iM", 
			
 
				+"Ga", "0dS", "beN", "hYu", "ckm", "60T", "Yc", "0zQ", "207", "3G", "4z2", "4oS", "4bc", "7Ga", "2ln", "0YM", "A2", "TS", "6yl", "4LO", 
			
 
				+"4CN", "62e", "2MC", "N3", "0VL", "1v", "6XA", "4mb", "5ps", "4u3", "xN", "8Rd", "01X", "Vb", "aQO", "b0E", "5og", "6Je", "gZ", "63", 
			
 
				+"0jD", "Iv", "6dI", "4Qj", "7l9", "6iy", "N", "0gt", "0IX", "jj", "5w6", "4rv", "5mV", "5x7", "ek", "0FY", "0hu", "KG", "6fx", "5Cz", 
			
 
				+"5NJ", "6kH", "Fw", "0eE", "92", "3nk", "6Ed", "44O", "7KG", "4nE", "c8", "2Q", "Xu", "1kf", "5PH", "61B", "4X8", "4MY", "0vw", "UE", 
			
 
				+"2mx", "1Hz", "4cu", "5f5", "5i4", "4lt", "0WZ", "th", "ZD", "0yv", "4BX", "4W9", "6zK", "4Oh", "00N", "Wt", "yX", "l9", "4aD", "6Tg", 
			
 
				+"2SM", "0fn", "5Ma", "6hc", "6FO", "47d", "0HB", "kp", "24Y", "0Er", "bDo", "aam", "5U0", "4Pp", "8bF", "Hl", "Gm", "10v", "5OP", "5Z1", 
			
 
				+"anl", "45U", "0Js", "iA", "dq", "0GC", "48e", "6IN", "6gb", "4RA", "0io", "3Lm", "03e", "2BN", "7iA", "4LC", "4bo", "6WL", "zs", "0YA", 
			
 
				+"0Tq", "3K", "a4f", "bUl", "4As", "5D3", "Yo", "87M", "01T", "Vn", "5K2", "4Nr", "54w", "417", "xB", "1KQ", "1Fa", "1z", "6XM", "4mn", 
			
 
				+"4CB", "62i", "2MO", "0xl", "1za", "Ir", "6dM", "4Qn", "5oc", "6Ja", "25G", "67", "9Pe", "jn", "5w2", "46z", "bfm", "aCo", "J", "0gp", 
			
 
				+"0hq", "KC", "72U", "bil", "5mR", "5x3", "eo", "326", "96", "3no", "7UA", "44K", "5NN", "6kL", "Fs", "0eA", "Xq", "1kb", "5PL", "61F", 
			
 
				+"7KC", "4nA", "0Uo", "2U", "39U", "8QG", "4cq", "5f1", "aRl", "796", "0vs", "UA", "2LQ", "0yr", "767", "63w", "5i0", "4lp", "9Ng", "0d", 
			
 
				+"2oM", "0Zn", "55i", "6Tc", "6zO", "4Ol", "00J", "Wp", "6FK", "4sh", "0HF", "kt", "EX", "P9", "5Me", "6hg", "5U4", "4Pt", "0kZ", "Hh", 
			
 
				+"fD", "0Ev", "5ny", "4k9", "4d8", "45Q", "0Jw", "iE", "Gi", "10r", "5OT", "5Z5", "6gf", "4RE", "0ik", "JY", "du", "0GG", "48a", "6IJ", 
			
 
				+"4bk", "6WH", "zw", "0YE", "03a", "2BJ", "6yd", "4LG", "4Aw", "5D7", "Yk", "0zY", "0Tu", "3O", "6Zx", "bUh", "54s", "413", "xF", "1KU", 
			
 
				+"01P", "Vj", "5K6", "4Nv", "4CF", "62m", "2MK", "0xh", "0VD", "uv", "6XI", "4mj", "5NS", "6kQ", "Fn", "11u", "0Kp", "hB", "aoo", "44V", 
			
 
				+"49f", "6HM", "er", "1Va", "0hl", "3Mn", "6fa", "4SB", "5Lb", "7yA", "W", "0gm", "0IA", "js", "6GL", "46g", "bEl", "hyW", "gC", "0Dq", 
			
 
				+"8cE", "Io", "5T3", "4Qs", "5J1", "4Oq", "00W", "Wm", "yA", "0Zs", "55t", "404", "6YN", "4lm", "0WC", "0y", "2LL", "0yo", "4BA", "63j", 
			
 
				+"6xc", "bws", "02f", "2CM", "2ma", "0XB", "4cl", "6VO", "a5e", "bTo", "0Ur", "2H", "Xl", "86N", "5PQ", "5E0", "dh", "0GZ", "5lU", "5y4", 
			
 
				+"4G9", "4RX", "0iv", "JD", "Gt", "0dF", "5OI", "6jK", "6Dg", "45L", "81", "iX", "fY", "70", "5nd", "6Kf", "6eJ", "4Pi", "0kG", "Hu", 
			
 
				+"EE", "0fw", "5Mx", "4H8", "5v5", "4su", "1Xz", "ki", "0VY", "1c", "5h7", "4mw", "5Sz", "62p", "2MV", "0xu", "01M", "Vw", "7ki", "4Nk", 
			
 
				+"54n", "6Ud", "2nJ", "1KH", "0Th", "3R", "6Ze", "4oF", "4Aj", "60A", "Yv", "0zD", "0wt", "TF", "6yy", "4LZ", "4bv", "5g6", "zj", "0YX", 
			
 
				+"0Kt", "hF", "6Ey", "44R", "5NW", "6kU", "Fj", "0eX", "0hh", "KZ", "6fe", "4SF", "49b", "6HI", "ev", "0FD", "0IE", "jw", "6GH", "46c", 
			
 
				+"5Lf", "6id", "S", "0gi", "0jY", "Ik", "5T7", "4Qw", "5oz", "6Jx", "gG", "0Du", "yE", "0Zw", "4aY", "400", "5J5", "4Ou", "00S", "Wi", 
			
 
				+"ZY", "O8", "4BE", "63n", "6YJ", "4li", "0WG", "tu", "2me", "0XF", "4ch", "6VK", "6xg", "4MD", "02b", "UX", "Xh", "3K9", "5PU", "5E4", 
			
 
				+"7KZ", "4nX", "0Uv", "2L", "73V", "bho", "0ir", "1l2", "dl", "335", "48x", "5y0", "6Dc", "45H", "85", "3ol", "Gp", "0dB", "5OM", "6jO", 
			
 
				+"6eN", "4Pm", "0kC", "Hq", "24D", "74", "bDr", "6Kb", "529", "47y", "8AG", "km", "EA", "0fs", "bgn", "aBl", "774", "62t", "199", "0xq", 
			
 
				+"9Od", "1g", "5h3", "4ms", "54j", "7EA", "2nN", "1KL", "01I", "Vs", "7km", "4No", "4An", "60E", "Yr", "1ja", "0Tl", "3V", "6Za", "4oB", 
			
 
				+"4br", "5g2", "zn", "8PD", "03x", "TB", "aSo", "785", "49n", "6HE", "ez", "0FH", "0hd", "KV", "6fi", "4SJ", "bdI", "6kY", "Ff", "0eT", 
			
 
				+"0Kx", "hJ", "4e7", "4pV", "5ov", "4j6", "gK", "0Dy", "0jU", "Ig", "6dX", "5AZ", "5Lj", "6ih", "DW", "Q6", "0II", "28b", "6GD", "46o", 
			
 
				+"6YF", "4le", "0WK", "0q", "ZU", "O4", "4BI", "63b", "5J9", "4Oy", "0tW", "We", "yI", "1JZ", "4aU", "4t4", "7KV", "4nT", "0Uz", "vH", 
			
 
				+"Xd", "1kw", "5PY", "5E8", "6xk", "4MH", "02n", "UT", "2mi", "0XJ", "4cd", "6VG", "2Qm", "0dN", "5OA", "6jC", "6Do", "45D", "89", "iP", 
			
 
				+"0R3", "0GR", "48t", "acM", "4G1", "4RP", "94O", "JL", "EM", "12V", "5Mp", "4H0", "525", "47u", "0HS", "ka", "fQ", "78", "5nl", "6Kn", 
			
 
				+"6eB", "4Pa", "0kO", "3NM", "01E", "3PO", "7ka", "4Nc", "54f", "6Ul", "xS", "m2", "0VQ", "1k", "a6F", "59V", "4CS", "4V2", "195", "85m", 
			
 
				+"03t", "TN", "4Y3", "4LR", "56W", "a9G", "zb", "0YP", "b3", "3Z", "6Zm", "4oN", "4Ab", "60I", "2Oo", "0zL", "1xA", "KR", "6fm", "4SN", 
			
 
				+"49j", "6HA", "27g", "0FL", "8Bd", "hN", "4e3", "44Z", "bdM", "aAO", "Fb", "0eP", "0jQ", "Ic", "70u", "655", "5or", "4j2", "gO", "8Me", 
			
 
				+"0IM", "28f", "7Wa", "46k", "5Ln", "6il", "DS", "Q2", "ZQ", "O0", "4BM", "63f", "6YB", "4la", "0WO", "0u", "yM", "8Sg", "4aQ", "408", 
			
 
				+"aPL", "b1F", "0tS", "Wa", "0n3", "1ks", "bzO", "61W", "7KR", "4nP", "214", "2D", "2mm", "0XN", "57I", "6VC", "6xo", "4ML", "02j", "UP", 
			
 
				+"6Dk", "4qH", "0Jf", "iT", "Gx", "0dJ", "5OE", "6jG", "4G5", "4RT", "0iz", "JH", "dd", "0GV", "48p", "5y8", "521", "47q", "0HW", "ke", 
			
 
				+"EI", "12R", "5Mt", "4H4", "6eF", "4Pe", "0kK", "Hy", "fU", "s4", "5nh", "6Kj", "54b", "6Uh", "xW", "m6", "01A", "3PK", "7ke", "4Ng", 
			
 
				+"4CW", "4V6", "191", "0xy", "0VU", "1o", "6XX", "59R", "4bz", "6WY", "zf", "0YT", "03p", "TJ", "4Y7", "4LV", "4Af", "60M", "Yz", "0zH", 
			
 
				+"b7", "wV", "6Zi", "4oJ", "5H3", "4Ms", "02U", "Uo", "2mR", "0Xq", "57v", "426", "7Km", "4no", "0UA", "vs", "2NN", "1kL", "5Pb", "61h", 
			
 
				+"6za", "4OB", "00d", "2AO", "yr", "1Ja", "4an", "6TM", "a7g", "58w", "0Wp", "0J", "Zn", "84L", "4Br", "5G2", "5LQ", "5Y0", "d", "13w", 
			
 
				+"0Ir", "1L2", "amm", "46T", "5oM", "6JO", "gp", "0DB", "0jn", "3Ol", "6dc", "5Aa", "bdr", "6kb", "2PL", "0eo", "0KC", "hq", "6EN", "44e", 
			
 
				+"49U", "abl", "eA", "0Fs", "8aG", "Km", "5V1", "4Sq", "1Dz", "3a", "5j5", "4ou", "4AY", "4T8", "YE", "0zw", "03O", "Tu", "6yJ", "4Li", 
			
 
				+"4bE", "6Wf", "zY", "o8", "0Vj", "1P", "6Xg", "4mD", "4Ch", "62C", "2Me", "0xF", "0uv", "VD", "7kZ", "4NX", "5pU", "5e4", "xh", "3k9", 
			
 
				+"fj", "0EX", "5nW", "6KU", "6ey", "4PZ", "0kt", "HF", "Ev", "0fD", "5MK", "6hI", "6Fe", "47N", "0Hh", "kZ", "26B", "52", "48O", "6Id", 
			
 
				+"6gH", "4Rk", "0iE", "Jw", "GG", "0du", "5Oz", "6jx", "5t7", "4qw", "0JY", "ik", "2mV", "0Xu", "57r", "422", "5H7", "4Mw", "02Q", "Uk", 
			
 
				+"2NJ", "1kH", "5Pf", "61l", "7Ki", "4nk", "0UE", "vw", "yv", "0ZD", "4aj", "6TI", "6ze", "4OF", "0th", "WZ", "Zj", "0yX", "4Bv", "5G6", 
			
 
				+"6Yy", "4lZ", "0Wt", "0N", "0Iv", "jD", "4g9", "46P", "5LU", "5Y4", "Dh", "0gZ", "0jj", "IX", "6dg", "4QD", "5oI", "6JK", "gt", "0DF", 
			
 
				+"0KG", "hu", "6EJ", "44a", "5Nd", "6kf", "FY", "S8", "1xz", "Ki", "5V5", "4Su", "49Q", "4h8", "eE", "0Fw", "756", "60v", "YA", "0zs", 
			
 
				+"9Mf", "3e", "5j1", "4oq", "4bA", "6Wb", "2lL", "0Yo", "03K", "Tq", "6yN", "4Lm", "4Cl", "62G", "2Ma", "0xB", "0Vn", "1T", "6Xc", "59i", 
			
 
				+"54Y", "5e0", "xl", "8RF", "01z", "1p2", "aQm", "b0g", "71T", "bjm", "0kp", "HB", "fn", "317", "5nS", "6KQ", "6Fa", "47J", "0Hl", "29G", 
			
 
				+"Er", "12i", "5MO", "6hM", "6gL", "4Ro", "0iA", "Js", "26F", "56", "48K", "7YA", "5t3", "4qs", "8CE", "io", "GC", "0dq", "bel", "hYW", 
			
 
				+"7Ke", "4ng", "0UI", "2s", "XW", "M6", "5Pj", "6uh", "6xX", "6m9", "0vU", "Ug", "2mZ", "0Xy", "4cW", "4v6", "4y7", "4lV", "0Wx", "0B", 
			
 
				+"Zf", "0yT", "4Bz", "63Q", "6zi", "4OJ", "B7", "WV", "yz", "0ZH", "4af", "6TE", "5oE", "6JG", "gx", "0DJ", "0jf", "IT", "6dk", "4QH", 
			
 
				+"5LY", "5Y8", "l", "0gV", "0Iz", "jH", "4g5", "4rT", "5mt", "4h4", "eI", "1VZ", "0hW", "Ke", "5V9", "4Sy", "5Nh", "6kj", "FU", "S4", 
			
 
				+"0KK", "hy", "6EF", "44m", "03G", "2Bl", "6yB", "4La", "4bM", "6Wn", "zQ", "o0", "0TS", "3i", "a4D", "bUN", "4AQ", "4T0", "YM", "87o", 
			
 
				+"01v", "VL", "7kR", "4NP", "54U", "hft", "0N3", "1Ks", "0Vb", "1X", "6Xo", "4mL", "5SA", "62K", "2Mm", "0xN", "2So", "0fL", "5MC", "6hA", 
			
 
				+"6Fm", "47F", "1XA", "kR", "fb", "0EP", "bDM", "aaO", "4E3", "4PR", "8bd", "HN", "GO", "10T", "5Or", "4J2", "507", "45w", "0JQ", "ic", 
			
 
				+"dS", "q2", "48G", "6Il", "73i", "4Rc", "0iM", "3LO", "XS", "M2", "5Pn", "61d", "7Ka", "4nc", "0UM", "2w", "39w", "8Qe", "4cS", "4v2", 
			
 
				+"aRN", "b3D", "02Y", "Uc", "Zb", "0yP", "bxM", "63U", "4y3", "4lR", "236", "0F", "2oo", "0ZL", "4ab", "6TA", "6zm", "4ON", "B3", "WR", 
			
 
				+"0jb", "IP", "6do", "4QL", "5oA", "6JC", "25e", "0DN", "9PG", "jL", "4g1", "46X", "686", "aCM", "h", "0gR", "0hS", "Ka", "72w", "677", 
			
 
				+"49Y", "4h0", "eM", "8Og", "0KO", "3nM", "6EB", "44i", "5Nl", "6kn", "FQ", "S0", "4bI", "6Wj", "zU", "o4", "03C", "Ty", "6yF", "4Le", 
			
 
				+"4AU", "4T4", "YI", "1jZ", "0TW", "3m", "5j9", "4oy", "54Q", "5e8", "xd", "1Kw", "01r", "VH", "7kV", "4NT", "4Cd", "62O", "2Mi", "0xJ", 
			
 
				+"0Vf", "uT", "6Xk", "4mH", "6Fi", "47B", "0Hd", "kV", "Ez", "0fH", "5MG", "6hE", "4E7", "4PV", "0kx", "HJ", "ff", "0ET", "bDI", "6KY", 
			
 
				+"503", "45s", "0JU", "ig", "GK", "0dy", "5Ov", "4J6", "6gD", "4Rg", "0iI", "3LK", "dW", "q6", "48C", "6Ih", "4Z2", "4OS", "00u", "WO", 
			
 
				+"yc", "0ZQ", "55V", "hgw", "6Yl", "4lO", "a2", "tS", "2Ln", "0yM", "4Bc", "63H", "6xA", "4Mb", "02D", "2Co", "2mC", "n3", "4cN", "6Vm", 
			
 
				+"a5G", "bTM", "0UP", "2j", "XN", "86l", "5Ps", "4U3", "5Nq", "4K1", "FL", "11W", "0KR", "3nP", "514", "44t", "49D", "6Ho", "eP", "49", 
			
 
				+"0hN", "3ML", "6fC", "5CA", "aV1", "6iB", "u", "0gO", "0Ic", "jQ", "6Gn", "46E", "bEN", "hyu", "ga", "0DS", "8cg", "IM", "4D0", "4QQ", 
			
 
				+"1FZ", "1A", "4x4", "4mU", "4Cy", "5F9", "0m6", "0xW", "C4", "VU", "7kK", "4NI", "54L", "6UF", "xy", "1Kj", "0TJ", "3p", "6ZG", "4od", 
			
 
				+"4AH", "60c", "YT", "L5", "0wV", "Td", "5I8", "4Lx", "4bT", "4w5", "zH", "0Yz", "dJ", "0Gx", "5lw", "4i7", "6gY", "4Rz", "0iT", "Jf", 
			
 
				+"GV", "R7", "5Ok", "6ji", "6DE", "45n", "0JH", "iz", "24b", "0EI", "5nF", "6KD", "6eh", "4PK", "0ke", "HW", "Eg", "0fU", "5MZ", "6hX", 
			
 
				+"4f6", "4sW", "0Hy", "kK", "yg", "0ZU", "55R", "6TX", "4Z6", "4OW", "00q", "WK", "2Lj", "0yI", "4Bg", "63L", "6Yh", "4lK", "a6", "tW", 
			
 
				+"2mG", "n7", "4cJ", "6Vi", "6xE", "4Mf", "0vH", "Uz", "XJ", "1kY", "5Pw", "4U7", "7Kx", "4nz", "0UT", "2n", "0KV", "hd", "510", "44p", 
			
 
				+"5Nu", "4K5", "FH", "0ez", "0hJ", "Kx", "6fG", "4Sd", "5mi", "6Hk", "eT", "p5", "0Ig", "jU", "6Gj", "46A", "5LD", "6iF", "q", "0gK", 
			
 
				+"1zZ", "II", "4D4", "4QU", "5oX", "5z9", "ge", "0DW", "byN", "62V", "0m2", "0xS", "225", "1E", "4x0", "4mQ", "54H", "6UB", "2nl", "1Kn", 
			
 
				+"C0", "VQ", "7kO", "4NM", "4AL", "60g", "YP", "L1", "0TN", "3t", "6ZC", "ae0", "4bP", "439", "zL", "8Pf", "03Z", "0b3", "aSM", "b2G", 
			
 
				+"73t", "664", "0iP", "Jb", "dN", "8Nd", "48Z", "4i3", "6DA", "45j", "0JL", "3oN", "GR", "R3", "5Oo", "6jm", "6el", "4PO", "0ka", "HS", 
			
 
				+"24f", "0EM", "5nB", "aaR", "4f2", "4sS", "8Ae", "kO", "Ec", "0fQ", "695", "aBN", "6Yd", "4lG", "0Wi", "0S", "Zw", "0yE", "4Bk", "6wH", 
			
 
				+"6zx", "buh", "0tu", "WG", "yk", "0ZY", "4aw", "5d7", "5k6", "4nv", "0UX", "2b", "XF", "1kU", "741", "61q", "6xI", "4Mj", "02L", "Uv", 
			
 
				+"2mK", "0Xh", "4cF", "6Ve", "49L", "6Hg", "eX", "41", "0hF", "Kt", "6fK", "4Sh", "5Ny", "4K9", "FD", "0ev", "0KZ", "hh", "5u4", "4pt", 
			
 
				+"5oT", "5z5", "gi", "1Tz", "0jw", "IE", "4D8", "4QY", "5LH", "6iJ", "Du", "0gG", "0Ik", "jY", "6Gf", "46M", "01g", "3Pm", "7kC", "4NA", 
			
 
				+"54D", "6UN", "xq", "1Kb", "0Vs", "1I", "a6d", "59t", "4Cq", "5F1", "d3G", "85O", "03V", "Tl", "5I0", "4Lp", "56u", "435", "2lQ", "0Yr", 
			
 
				+"0TB", "3x", "6ZO", "4ol", "5Qa", "60k", "2OM", "0zn", "2QO", "0dl", "5Oc", "6ja", "6DM", "45f", "1Za", "ir", "dB", "0Gp", "48V", "aco", 
			
 
				+"5W2", "4Rr", "94m", "Jn", "Eo", "12t", "5MR", "5X3", "aln", "47W", "0Hq", "kC", "fs", "0EA", "5nN", "6KL", "71I", "4PC", "0km", "3No", 
			
 
				+"Zs", "0yA", "4Bo", "63D", "7IA", "4lC", "0Wm", "0W", "yo", "8SE", "4as", "5d3", "aPn", "b1d", "00y", "WC", "XB", "1kQ", "745", "61u", 
			
 
				+"5k2", "4nr", "9Le", "2f", "2mO", "0Xl", "4cB", "6Va", "6xM", "4Mn", "02H", "Ur", "0hB", "Kp", "6fO", "4Sl", "49H", "6Hc", "27E", "45", 
			
 
				+"8BF", "hl", "518", "44x", "bdo", "aAm", "2PQ", "0er", "0js", "IA", "70W", "bkn", "5oP", "5z1", "gm", "304", "0Io", "28D", "6Gb", "46I", 
			
 
				+"5LL", "6iN", "y", "0gC", "5pH", "6UJ", "xu", "1Kf", "C8", "VY", "7kG", "4NE", "4Cu", "5F5", "2Mx", "1hz", "0Vw", "1M", "4x8", "4mY", 
			
 
				+"4bX", "431", "zD", "0Yv", "03R", "Th", "5I4", "4Lt", "4AD", "60o", "YX", "L9", "0TF", "wt", "6ZK", "4oh", "6DI", "45b", "0JD", "iv", 
			
 
				+"GZ", "0dh", "5Og", "6je", "5W6", "4Rv", "0iX", "Jj", "dF", "0Gt", "48R", "6Iy", "6Fx", "47S", "0Hu", "kG", "Ek", "0fY", "5MV", "5X7", 
			
 
				+"6ed", "4PG", "0ki", "3Nk", "fw", "0EE", "5nJ", "6KH", "356", "bo", "6OP", "4zs", "bnl", "75U", "LC", "0oq", "0bA", "As", "6lL", "4Yo", 
			
 
				+"43K", "7RA", "2yN", "0Lm", "17", "22G", "6Ma", "4xB", "4Vn", "6cM", "Nr", "19i", "14Y", "CB", "aDo", "bam", "41z", "5p2", "mn", "8GD", 
			
 
				+"7d", "8YF", "4kp", "5n0", "64w", "717", "1nS", "2KQ", "Pp", "07J", "4Hl", "69G", "6Sc", "52i", "1MO", "2hM", "5U", "0Ro", "4iA", "7LC", 
			
 
				+"66F", "4Gm", "08K", "3YA", "RA", "0qs", "b4f", "aUl", "5a1", "4dq", "8VG", "8e", "6mV", "4Xu", "17r", "022", "nE", "0Mw", "42Q", "4c8", 
			
 
				+"6NJ", "5kH", "1Pf", "cu", "MY", "X8", "4UE", "74O", "6og", "4ZD", "W9", "BX", "lt", "0OF", "4th", "6AK", "4l9", "4yX", "0Bv", "aD", 
			
 
				+"Oh", "0lZ", "4Wt", "5R4", "4Iv", "5L6", "Qj", "06P", "1LU", "1Y4", "463", "4gZ", "4jj", "7Oh", "rv", "0QD", "1oI", "2JK", "65m", "4DF", 
			
 
				+"4KG", "7nE", "2EJ", "04a", "1Nd", "2kf", "6PH", "4ek", "5xz", "492", "4O", "0Su", "09Q", "0h8", "5C7", "4Fw", "5Dz", "6ax", "LG", "0ou", 
			
 
				+"0AY", "bk", "6OT", "4zw", "43O", "6Bd", "2yJ", "0Li", "0bE", "Aw", "6lH", "4Yk", "4Vj", "6cI", "Nv", "0mD", "13", "22C", "6Me", "4xF", 
			
 
				+"4uv", "5p6", "mj", "0NX", "1pU", "CF", "6ny", "7k9", "4P9", "4EX", "1nW", "2KU", "sh", "0PZ", "4kt", "5n4", "6Sg", "4fD", "k9", "2hI", 
			
 
				+"Pt", "07N", "4Hh", "69C", "66B", "4Gi", "08O", "2Id", "5Q", "d8", "4iE", "7LG", "5a5", "4du", "1Oz", "8a", "RE", "0qw", "4JY", "aUh", 
			
 
				+"nA", "0Ms", "42U", "ail", "6mR", "4Xq", "17v", "026", "3Km", "0no", "4UA", "74K", "6NN", "5kL", "1Pb", "cq", "lp", "0OB", "40d", "6AO", 
			
 
				+"6oc", "5Ja", "0an", "2TM", "Ol", "18w", "4Wp", "5R0", "afm", "bCo", "0Br", "1G2", "1LQ", "1Y0", "467", "53w", "4Ir", "5L2", "Qn", "06T", 
			
 
				+"1oM", "2JO", "65i", "4DB", "4jn", "7Ol", "6z", "1Aa", "8WY", "2kb", "6PL", "4eo", "4KC", "7nA", "2EN", "04e", "09U", "d6E", "5C3", "4Fs", 
			
 
				+"bRl", "496", "4K", "0Sq", "0bI", "2Wj", "6lD", "4Yg", "43C", "6Bh", "oW", "z6", "0AU", "bg", "6OX", "5jZ", "4TW", "4A6", "LK", "0oy", 
			
 
				+"14Q", "CJ", "4N7", "5Kw", "41r", "542", "mf", "0NT", "u7", "22O", "6Mi", "4xJ", "4Vf", "6cE", "Nz", "0mH", "Px", "07B", "4Hd", "69O", 
			
 
				+"6Sk", "4fH", "k5", "2hE", "7l", "0PV", "4kx", "5n8", "4P5", "4ET", "83j", "2KY", "RI", "05s", "4JU", "7oW", "5a9", "4dy", "1Ov", "8m", 
			
 
				+"qU", "d4", "4iI", "7LK", "66N", "4Ge", "08C", "2Ih", "6NB", "a59", "1Pn", "21d", "MQ", "X0", "4UM", "74G", "79w", "bbN", "0cS", "0v2", 
			
 
				+"nM", "8Dg", "42Y", "4c0", "4l1", "4yP", "8Kf", "aL", "0y3", "0lR", "636", "76v", "6oo", "4ZL", "W1", "BP", "2zm", "0ON", "40h", "6AC", 
			
 
				+"4jb", "auS", "6v", "0QL", "I3", "2JC", "65e", "4DN", "b7E", "68U", "Qb", "06X", "286", "dSl", "4r3", "4gR", "4hS", "7MQ", "4G", "277", 
			
 
				+"09Y", "0h0", "67T", "b8D", "4KO", "7nM", "SS", "F2", "1Nl", "9w", "azR", "4ec", "43G", "6Bl", "oS", "z2", "0bM", "2Wn", "78i", "4Yc", 
			
 
				+"4TS", "4A2", "LO", "8fe", "0AQ", "bc", "aeN", "cPm", "41v", "546", "mb", "0NP", "14U", "CN", "4N3", "5Ks", "4Vb", "6cA", "2Xo", "0mL", 
			
 
				+"u3", "22K", "6Mm", "4xN", "6So", "4fL", "k1", "2hA", "2Fm", "07F", "5XA", "69K", "4P1", "4EP", "83n", "d5f", "7h", "0PR", "bQO", "a0E", 
			
 
				+"hbu", "50T", "1Or", "8i", "RM", "05w", "4JQ", "7oS", "66J", "4Ga", "08G", "2Il", "5Y", "d0", "4iM", "7LO", "MU", "X4", "4UI", "74C", 
			
 
				+"6NF", "5kD", "1Pj", "cy", "nI", "2m9", "4vU", "4c4", "6mZ", "4Xy", "0cW", "0v6", "Od", "0lV", "4Wx", "5R8", "4l5", "4yT", "0Bz", "aH", 
			
 
				+"lx", "0OJ", "40l", "6AG", "6ok", "4ZH", "W5", "BT", "I7", "2JG", "65a", "4DJ", "4jf", "7Od", "6r", "0QH", "1LY", "1Y8", "4r7", "4gV", 
			
 
				+"4Iz", "68Q", "Qf", "0rT", "1mt", "0h4", "67P", "5VZ", "4hW", "7MU", "4C", "0Sy", "1Nh", "9s", "6PD", "4eg", "4KK", "7nI", "SW", "F6", 
			
 
				+"8Je", "22V", "4m2", "4xS", "625", "77u", "Nc", "0mQ", "V2", "CS", "6nl", "5Kn", "41k", "7Pa", "3kO", "0NM", "0AL", "20g", "6OA", "4zb", 
			
 
				+"4TN", "6am", "LR", "Y3", "0bP", "Ab", "78t", "bcM", "43Z", "4b3", "oN", "8Ed", "5D", "264", "4iP", "489", "66W", "b9G", "08Z", "0i3", 
			
 
				+"RP", "G1", "4JL", "7oN", "6QC", "50I", "1Oo", "8t", "7u", "0PO", "4ka", "7Nc", "64f", "4EM", "H0", "963", "Pa", "0sS", "b6F", "69V", 
			
 
				+"478", "4fQ", "295", "dRo", "4O4", "4ZU", "15R", "BI", "le", "0OW", "40q", "551", "6Lj", "4yI", "t4", "aU", "Oy", "0lK", "4We", "6bF", 
			
 
				+"6mG", "4Xd", "0cJ", "2Vi", "nT", "0Mf", "4vH", "6Ck", "adI", "5kY", "1Pw", "cd", "MH", "0nz", "4UT", "7pV", "4KV", "7nT", "SJ", "04p", 
			
 
				+"1Nu", "9n", "6PY", "4ez", "4hJ", "7MH", "pV", "e7", "1mi", "2Hk", "67M", "4Ff", "4Ig", "68L", "2Gj", "06A", "j6", "2iF", "6Rh", "4gK", 
			
 
				+"5zZ", "7Oy", "6o", "0QU", "1oX", "1z9", "4Q6", "4DW", "5FZ", "6cX", "Ng", "0mU", "0Cy", "1F9", "4m6", "4xW", "41o", "7Pe", "3kK", "0NI", 
			
 
				+"V6", "CW", "6nh", "5Kj", "4TJ", "6ai", "LV", "Y7", "0AH", "bz", "6OE", "4zf", "4wV", "4b7", "oJ", "0Lx", "0bT", "Af", "6lY", "4Yz", 
			
 
				+"5B8", "4Gx", "1lw", "0i7", "qH", "0Rz", "4iT", "7LV", "6QG", "4dd", "1Ok", "8p", "RT", "G5", "4JH", "7oJ", "64b", "4EI", "H4", "2KD", 
			
 
				+"7q", "0PK", "4ke", "7Ng", "4s4", "4fU", "1MZ", "2hX", "Pe", "0sW", "4Hy", "5M9", "la", "0OS", "40u", "555", "4O0", "4ZQ", "15V", "BM", 
			
 
				+"2Yl", "0lO", "4Wa", "6bB", "6Ln", "4yM", "08", "aQ", "nP", "0Mb", "42D", "6Co", "6mC", "5HA", "0cN", "2Vm", "ML", "8gf", "4UP", "74Z", 
			
 
				+"adM", "bAO", "1Ps", "0U3", "1Nq", "9j", "azO", "51W", "4KR", "7nP", "SN", "04t", "09D", "2Ho", "67I", "4Fb", "4hN", "7ML", "4Z", "e3", 
			
 
				+"j2", "2iB", "6Rl", "4gO", "4Ic", "68H", "2Gn", "06E", "82m", "d4e", "4Q2", "4DS", "bPL", "a1F", "6k", "0QQ", "1pH", "2UJ", "6nd", "5Kf", 
			
 
				+"41c", "7Pi", "mw", "0NE", "0Cu", "1F5", "6Mx", "5hz", "4Vw", "5S7", "Nk", "0mY", "0bX", "Aj", "6lU", "4Yv", "43R", "6By", "oF", "0Lt", 
			
 
				+"0AD", "bv", "6OI", "4zj", "4TF", "6ae", "LZ", "0oh", "RX", "G9", "4JD", "7oF", "6QK", "4dh", "1Og", "2je", "5L", "0Rv", "4iX", "481", 
			
 
				+"5B4", "4Gt", "08R", "2Iy", "Pi", "07S", "4Hu", "5M5", "470", "4fY", "1MV", "1X7", "su", "0PG", "4ki", "7Nk", "64n", "4EE", "H8", "2KH", 
			
 
				+"6Lb", "4yA", "04", "23D", "Oq", "0lC", "4Wm", "6bN", "aEl", "c4G", "0as", "BA", "lm", "8FG", "40y", "559", "6NS", "5kQ", "345", "cl", 
			
 
				+"1k2", "0nr", "boo", "74V", "6mO", "4Xl", "0cB", "2Va", "2xM", "0Mn", "42H", "6Cc", "4hB", "aws", "4V", "0Sl", "09H", "2Hc", "67E", "4Fn", 
			
 
				+"b5e", "aTo", "SB", "04x", "8WD", "9f", "6PQ", "4er", "4js", "5o3", "6g", "8XE", "1oP", "1z1", "65t", "704", "4Io", "68D", "Qs", "06I", 
			
 
				+"1LL", "2iN", "7BA", "4gC", "41g", "7Pm", "ms", "0NA", "14D", "2UN", "aDr", "5Kb", "4Vs", "5S3", "No", "19t", "0Cq", "1F1", "agn", "bBl", 
			
 
				+"43V", "aho", "oB", "0Lp", "16u", "An", "6lQ", "4Yr", "4TB", "6aa", "2ZO", "0ol", "1Qa", "br", "6OM", "4zn", "6QO", "4dl", "1Oc", "8x", 
			
 
				+"2DM", "05f", "5Za", "7oB", "5B0", "4Gp", "08V", "d7F", "5H", "0Rr", "bSo", "485", "474", "52t", "1MR", "1X3", "Pm", "07W", "4Hq", "5M1", 
			
 
				+"64j", "4EA", "1nN", "2KL", "7y", "0PC", "4km", "7No", "Ou", "0lG", "4Wi", "6bJ", "6Lf", "4yE", "00", "aY", "li", "8FC", "4tu", "5q5", 
			
 
				+"4O8", "4ZY", "0aw", "BE", "MD", "0nv", "4UX", "74R", "6NW", "5kU", "341", "ch", "nX", "0Mj", "42L", "6Cg", "6mK", "4Xh", "0cF", "2Ve", 
			
 
				+"09L", "2Hg", "67A", "4Fj", "4hF", "7MD", "4R", "0Sh", "1Ny", "9b", "6PU", "4ev", "4KZ", "7nX", "SF", "0pt", "1oT", "1z5", "65p", "5Tz", 
			
 
				+"4jw", "5o7", "6c", "0QY", "1LH", "2iJ", "6Rd", "4gG", "4Ik", "7li", "Qw", "06M", "7F", "246", "4kR", "7NP", "64U", "col", "1nq", "0k1", 
			
 
				+"PR", "E3", "4HN", "69e", "6SA", "4fb", "1Mm", "2ho", "5w", "0RM", "4ic", "7La", "66d", "4GO", "J2", "2IB", "Rc", "05Y", "b4D", "aUN", 
			
 
				+"4q2", "4dS", "8Ve", "8G", "8Hg", "bM", "4o0", "4zQ", "607", "75w", "La", "0oS", "T0", "AQ", "6ln", "4YM", "43i", "6BB", "2yl", "0LO", 
			
 
				+"0CN", "22e", "6MC", "5hA", "4VL", "6co", "NP", "0mb", "1ps", "0u3", "aDM", "baO", "41X", "7PR", "mL", "8Gf", "4IT", "7lV", "QH", "06r", 
			
 
				+"1Lw", "0I7", "5b8", "4gx", "4jH", "7OJ", "rT", "g5", "1ok", "2Ji", "65O", "4Dd", "4Ke", "7ng", "Sy", "04C", "h4", "2kD", "6Pj", "4eI", 
			
 
				+"4hy", "5m9", "4m", "0SW", "09s", "2HX", "4S4", "4FU", "4M6", "4XW", "0cy", "1f9", "ng", "0MU", "42s", "573", "6Nh", "5kj", "v6", "cW", 
			
 
				+"3KK", "0nI", "4Ug", "74m", "6oE", "4Zf", "0aH", "Bz", "lV", "y7", "40B", "6Ai", "582", "4yz", "0BT", "af", "OJ", "0lx", "4WV", "4B7", 
			
 
				+"64Q", "4Ez", "1nu", "0k5", "7B", "0Px", "4kV", "7NT", "6SE", "4ff", "1Mi", "2hk", "PV", "E7", "4HJ", "69a", "6rh", "4GK", "J6", "2IF", 
			
 
				+"5s", "0RI", "4ig", "7Le", "4q6", "4dW", "1OX", "8C", "Rg", "0qU", "5ZZ", "7oy", "4Ty", "5Q9", "Le", "0oW", "1QZ", "bI", "4o4", "4zU", 
			
 
				+"43m", "6BF", "oy", "0LK", "T4", "AU", "6lj", "4YI", "4VH", "6ck", "NT", "0mf", "0CJ", "22a", "6MG", "4xd", "4uT", "7PV", "mH", "0Nz", 
			
 
				+"1pw", "Cd", "aDI", "5KY", "1Ls", "0I3", "axM", "53U", "4IP", "7lR", "QL", "06v", "1oo", "2Jm", "65K", "5TA", "4jL", "7ON", "6X", "g1", 
			
 
				+"h0", "9Y", "6Pn", "4eM", "4Ka", "7nc", "2El", "04G", "09w", "d6g", "4S0", "4FQ", "bRN", "a3D", "4i", "0SS", "nc", "0MQ", "42w", "577", 
			
 
				+"4M2", "4XS", "17T", "dlm", "3KO", "0nM", "4Uc", "74i", "6Nl", "5kn", "v2", "cS", "lR", "y3", "40F", "6Am", "6oA", "4Zb", "0aL", "2To", 
			
 
				+"ON", "18U", "4WR", "4B3", "586", "bCM", "0BP", "ab", "PZ", "0sh", "4HF", "69m", "6SI", "4fj", "1Me", "2hg", "7N", "0Pt", "4kZ", "7NX", 
			
 
				+"6pU", "4Ev", "1ny", "0k9", "Rk", "05Q", "4Jw", "5O7", "452", "50r", "1OT", "8O", "qw", "0RE", "4ik", "7Li", "66l", "4GG", "08a", "2IJ", 
			
 
				+"T8", "AY", "6lf", "4YE", "43a", "6BJ", "ou", "0LG", "0Aw", "bE", "4o8", "4zY", "4Tu", "5Q5", "Li", "8fC", "14s", "Ch", "6nW", "5KU", 
			
 
				+"41P", "7PZ", "mD", "0Nv", "0CF", "22m", "6MK", "4xh", "4VD", "6cg", "NX", "0mj", "5za", "7OB", "6T", "0Qn", "1oc", "2Ja", "65G", "4Dl", 
			
 
				+"b7g", "68w", "1w2", "06z", "8UF", "dSN", "5b0", "4gp", "4hq", "5m1", "4e", "8ZG", "1mR", "1x3", "67v", "726", "4Km", "7no", "Sq", "04K", 
			
 
				+"1NN", "9U", "6Pb", "4eA", "adr", "5kb", "26", "21F", "Ms", "0nA", "4Uo", "74e", "79U", "bbl", "0cq", "1f1", "no", "396", "4vs", "5s3", 
			
 
				+"6LQ", "4yr", "367", "an", "OB", "0lp", "bmm", "76T", "6oM", "4Zn", "15i", "Br", "2zO", "0Ol", "40J", "6Aa", "6SM", "4fn", "1Ma", "2hc", 
			
 
				+"2FO", "07d", "4HB", "69i", "64Y", "4Er", "83L", "d5D", "7J", "0Pp", "bQm", "a0g", "456", "50v", "1OP", "8K", "Ro", "05U", "4Js", "5O3", 
			
 
				+"66h", "4GC", "08e", "2IN", "qs", "0RA", "4io", "7Lm", "43e", "6BN", "oq", "0LC", "0bo", "2WL", "6lb", "4YA", "4Tq", "5Q1", "Lm", "8fG", 
			
 
				+"0As", "bA", "ael", "cPO", "41T", "ajm", "1K2", "0Nr", "14w", "Cl", "6nS", "5KQ", "5Fa", "6cc", "2XM", "0mn", "0CB", "22i", "6MO", "4xl", 
			
 
				+"1og", "2Je", "65C", "4Dh", "4jD", "7OF", "6P", "g9", "3l9", "2iy", "5b4", "4gt", "4IX", "68s", "QD", "0rv", "1mV", "1x7", "4S8", "4FY", 
			
 
				+"4hu", "5m5", "4a", "1Cz", "h8", "9Q", "6Pf", "4eE", "4Ki", "7nk", "Su", "04O", "Mw", "0nE", "4Uk", "74a", "6Nd", "5kf", "22", "21B", 
			
 
				+"nk", "0MY", "4vw", "5s7", "6mx", "5Hz", "0cu", "1f5", "OF", "0lt", "4WZ", "6by", "6LU", "4yv", "0BX", "aj", "lZ", "0Oh", "40N", "6Ae", 
			
 
				+"6oI", "4Zj", "0aD", "Bv", "5f", "9Ke", "4ir", "5l2", "66u", "735", "08x", "1y0", "Rr", "05H", "4Jn", "7ol", "6Qa", "4dB", "1OM", "8V", 
			
 
				+"7W", "0Pm", "4kC", "7NA", "64D", "4Eo", "83Q", "2Kb", "PC", "07y", "b6d", "69t", "5c3", "4fs", "8TE", "dRM", "374", "22t", "599", "4xq", 
			
 
				+"bln", "77W", "NA", "0ms", "14j", "Cq", "6nN", "5KL", "41I", "7PC", "3km", "0No", "35", "20E", "6Oc", "5ja", "4Tl", "6aO", "Lp", "0oB", 
			
 
				+"0br", "1g2", "78V", "bco", "43x", "568", "ol", "385", "4Kt", "5N4", "Sh", "04R", "1NW", "9L", "441", "4eX", "4hh", "7Mj", "pt", "0SF", 
			
 
				+"K9", "2HI", "67o", "4FD", "4IE", "68n", "QY", "0", "1Lf", "2id", "6RJ", "4gi", "4jY", "auh", "6M", "0Qw", "1oz", "2Jx", "5A5", "4Du", 
			
 
				+"6oT", "4Zw", "0aY", "Bk", "lG", "0Ou", "40S", "6Ax", "6LH", "4yk", "0BE", "aw", "2YJ", "0li", "4WG", "6bd", "6me", "4XF", "0ch", "2VK", 
			
 
				+"nv", "0MD", "42b", "6CI", "6Ny", "7K9", "1PU", "cF", "Mj", "0nX", "4Uv", "5P6", "66q", "4GZ", "1lU", "1y4", "5b", "0RX", "4iv", "5l6", 
			
 
				+"6Qe", "4dF", "1OI", "8R", "Rv", "05L", "4Jj", "7oh", "6pH", "4Ek", "1nd", "2Kf", "7S", "0Pi", "4kG", "7NE", "5c7", "4fw", "1Mx", "0H8", 
			
 
				+"PG", "0su", "5Xz", "69p", "4VY", "4C8", "NE", "0mw", "1Sz", "22p", "6MV", "4xu", "41M", "7PG", "mY", "x8", "14n", "Cu", "6nJ", "5KH", 
			
 
				+"4Th", "6aK", "Lt", "0oF", "31", "bX", "6Og", "4zD", "4wt", "5r4", "oh", "0LZ", "0bv", "AD", "4L9", "4YX", "1NS", "9H", "445", "51u", 
			
 
				+"4Kp", "5N0", "Sl", "04V", "09f", "2HM", "67k", "5Va", "4hl", "7Mn", "4x", "0SB", "1Lb", "3yA", "6RN", "4gm", "4IA", "68j", "2GL", "4", 
			
 
				+"82O", "d4G", "5A1", "4Dq", "bPn", "a1d", "6I", "0Qs", "lC", "0Oq", "40W", "akn", "6oP", "4Zs", "15t", "Bo", "2YN", "0lm", "4WC", "76I", 
			
 
				+"6LL", "4yo", "0BA", "as", "nr", "8DX", "42f", "6CM", "6ma", "4XB", "0cl", "2VO", "Mn", "8gD", "4Ur", "5P2", "ado", "bAm", "1PQ", "cB", 
			
 
				+"Rz", "0qH", "4Jf", "7od", "6Qi", "4dJ", "i7", "2jG", "5n", "0RT", "4iz", "7Lx", "4R7", "4GV", "08p", "1y8", "PK", "07q", "4HW", "7mU", 
			
 
				+"6SX", "52R", "1Mt", "0H4", "sW", "f6", "4kK", "7NI", "64L", "4Eg", "1nh", "2Kj", "14b", "Cy", "6nF", "5KD", "41A", "7PK", "mU", "x4", 
			
 
				+"0CW", "0V6", "591", "4xy", "4VU", "4C4", "NI", "19R", "0bz", "AH", "4L5", "4YT", "43p", "560", "od", "0LV", "w5", "bT", "6Ok", "4zH", 
			
 
				+"4Td", "6aG", "Lx", "0oJ", "5xA", "7Mb", "4t", "0SN", "K1", "2HA", "67g", "4FL", "b5G", "aTM", "0e3", "04Z", "8Wf", "9D", "449", "4eP", 
			
 
				+"4jQ", "7OS", "6E", "255", "1or", "0j2", "65V", "cno", "4IM", "68f", "QQ", "8", "1Ln", "2il", "6RB", "4ga", "afR", "4yc", "0BM", "23f", 
			
 
				+"OS", "Z2", "4WO", "6bl", "aEN", "c4e", "0aQ", "Bc", "lO", "8Fe", "4tS", "4a2", "4n3", "5ks", "8Id", "cN", "Mb", "0nP", "614", "74t", 
			
 
				+"6mm", "4XN", "U3", "2VC", "2xo", "0ML", "42j", "6CA", "6Qm", "4dN", "i3", "8Z", "2Do", "05D", "4Jb", "aUS", "4R3", "4GR", "08t", "d7d", 
			
 
				+"5j", "0RP", "bSM", "a2G", "ayN", "52V", "1Mp", "0H0", "PO", "07u", "4HS", "69x", "64H", "4Ec", "1nl", "2Kn", "sS", "f2", "4kO", "7NM", 
			
 
				+"41E", "7PO", "mQ", "x0", "14f", "2Ul", "6nB", "aQ1", "4VQ", "4C0", "NM", "19V", "0CS", "0V2", "595", "bBN", "43t", "564", "0Y3", "0LR", 
			
 
				+"16W", "AL", "4L1", "4YP", "5DA", "6aC", "2Zm", "0oN", "39", "bP", "6Oo", "4zL", "K5", "2HE", "67c", "4FH", "4hd", "7Mf", "4p", "0SJ", 
			
 
				+"8Wb", "2kY", "4p5", "4eT", "4Kx", "5N8", "Sd", "0pV", "1ov", "0j6", "5A9", "4Dy", "4jU", "7OW", "6A", "1AZ", "1Lj", "2ih", "6RF", "4ge", 
			
 
				+"4II", "68b", "QU", "D4", "OW", "Z6", "4WK", "6bh", "6LD", "4yg", "0BI", "23b", "lK", "0Oy", "4tW", "4a6", "6oX", "5JZ", "0aU", "Bg", 
			
 
				+"Mf", "0nT", "4Uz", "74p", "4n7", "5kw", "1PY", "cJ", "nz", "0MH", "42n", "6CE", "6mi", "4XJ", "U7", "2VG", "4MP", "4X1", "UL", "02v", 
			
 
				+"0XR", "0M3", "a8E", "57U", "4nL", "7KN", "2X", "c1", "1ko", "2Nm", "61K", "5PA", "4Oa", "6zB", "2Al", "00G", "l0", "yQ", "6Tn", "4aM", 
			
 
				+"58T", "a7D", "0i", "0WS", "84o", "ZM", "4W0", "4BQ", "4I2", "5Lr", "13T", "G", "jc", "0IQ", "46w", "537", "6Jl", "5on", "r2", "gS", 
			
 
				+"3OO", "0jM", "4Qc", "70i", "6kA", "5NC", "0eL", "2Po", "hR", "8Bx", "44F", "6Em", "abO", "49v", "0FP", "eb", "KN", "8ad", "4SR", "4F3", 
			
 
				+"3B", "0Tx", "4oV", "4z7", "60Q", "4Az", "0zT", "Yf", "TV", "A7", "4LJ", "6yi", "6WE", "4bf", "0YH", "zz", "1s", "0VI", "4mg", "6XD", 
			
 
				+"6vh", "4CK", "N6", "2MF", "Vg", "0uU", "6n9", "7ky", "4u6", "5pv", "1KX", "xK", "1UZ", "fI", "4k4", "5nt", "4Py", "5U9", "He", "0kW", 
			
 
				+"P4", "EU", "6hj", "5Mh", "47m", "6FF", "ky", "0HK", "0GJ", "dx", "6IG", "48l", "4RH", "6gk", "JT", "0if", "0dV", "Gd", "5Z8", "5OY", 
			
 
				+"4qT", "4d5", "iH", "0Jz", "0XV", "0M7", "5f8", "4cx", "4MT", "4X5", "UH", "02r", "1kk", "Xx", "61O", "5PE", "4nH", "7KJ", "vT", "c5", 
			
 
				+"l4", "yU", "6Tj", "4aI", "4Oe", "6zF", "Wy", "00C", "1iZ", "ZI", "4W4", "4BU", "4ly", "5i9", "0m", "0WW", "jg", "0IU", "46s", "533", 
			
 
				+"4I6", "5Lv", "0gy", "C", "3OK", "0jI", "4Qg", "6dD", "6Jh", "5oj", "r6", "gW", "hV", "0Kd", "44B", "6Ei", "6kE", "5NG", "0eH", "Fz", 
			
 
				+"KJ", "0hx", "4SV", "4F7", "6HY", "49r", "0FT", "ef", "60U", "ckl", "0zP", "Yb", "3F", "206", "4oR", "4z3", "6WA", "4bb", "0YL", "2lo", 
			
 
				+"TR", "A3", "4LN", "6ym", "62d", "4CO", "N2", "2MB", "1w", "0VM", "4mc", "7Ha", "4u2", "54z", "8Re", "xO", "Vc", "01Y", "b0D", "aQN", 
			
 
				+"647", "71w", "Ha", "0kS", "8Lg", "fM", "4k0", "5np", "47i", "6FB", "29d", "0HO", "P0", "EQ", "6hn", "5Ml", "4RL", "6go", "JP", "0ib", 
			
 
				+"0GN", "26e", "6IC", "48h", "45X", "4d1", "iL", "8Cf", "0dR", "0q3", "hYt", "beO", "4nD", "7KF", "2P", "c9", "1kg", "Xt", "61C", "5PI", 
			
 
				+"4MX", "4X9", "UD", "0vv", "0XZ", "2my", "5f4", "4ct", "4lu", "5i5", "0a", "1Gz", "0yw", "ZE", "4W8", "4BY", "4Oi", "6zJ", "Wu", "00O", 
			
 
				+"l8", "yY", "6Tf", "4aE", "6Jd", "5of", "62", "25B", "Iw", "0jE", "4Qk", "6dH", "6ix", "5Lz", "0gu", "O", "jk", "0IY", "4rw", "5w7", 
			
 
				+"5x6", "5mW", "0FX", "ej", "KF", "0ht", "4SZ", "6fy", "6kI", "5NK", "0eD", "Fv", "hZ", "93", "44N", "6Ee", "2BO", "03d", "4LB", "6ya", 
			
 
				+"6WM", "4bn", "1Ia", "zr", "3J", "0Tp", "bUm", "a4g", "5D2", "4Ar", "87L", "Yn", "Vo", "01U", "4Ns", "5K3", "416", "54v", "1KP", "xC", 
			
 
				+"us", "0VA", "4mo", "6XL", "62h", "4CC", "0xm", "2MN", "0fo", "2SL", "6hb", "bgr", "47e", "6FN", "kq", "0HC", "0Es", "fA", "aal", "bDn", 
			
 
				+"4Pq", "5U1", "Hm", "8bG", "10w", "Gl", "5Z0", "5OQ", "45T", "anm", "1O2", "0Jr", "0GB", "dp", "6IO", "48d", "5Ba", "6gc", "3Ll", "0in", 
			
 
				+"1kc", "Xp", "61G", "5PM", "bTs", "7KB", "2T", "0Un", "8QF", "39T", "5f0", "4cp", "797", "aRm", "1s2", "02z", "0ys", "ZA", "63v", "766", 
			
 
				+"4lq", "5i1", "0e", "9Nf", "0Zo", "2oL", "6Tb", "4aA", "4Om", "6zN", "Wq", "00K", "Is", "0jA", "4Qo", "6dL", "7ZA", "5ob", "66", "25F", 
			
 
				+"jo", "9Pd", "4rs", "5w3", "aCn", "bfl", "0gq", "K", "KB", "0hp", "bim", "72T", "5x2", "49z", "327", "en", "3nn", "97", "44J", "6Ea", 
			
 
				+"6kM", "5NO", "11i", "Fr", "6WI", "4bj", "0YD", "zv", "TZ", "0wh", "4LF", "6ye", "5D6", "4Av", "0zX", "Yj", "3N", "0Tt", "4oZ", "6Zy", 
			
 
				+"412", "54r", "1KT", "xG", "Vk", "01Q", "4Nw", "5K7", "62l", "4CG", "0xi", "2MJ", "uw", "0VE", "4mk", "6XH", "47a", "6FJ", "ku", "0HG", 
			
 
				+"P8", "EY", "6hf", "5Md", "4Pu", "5U5", "Hi", "8bC", "0Ew", "fE", "4k8", "5nx", "45P", "4d9", "iD", "0Jv", "0dZ", "Gh", "5Z4", "5OU", 
			
 
				+"4RD", "6gg", "JX", "0ij", "0GF", "dt", "6IK", "5lI", "4Op", "5J0", "Wl", "00V", "0Zr", "2oQ", "405", "55u", "4ll", "6YO", "0x", "0WB", 
			
 
				+"0yn", "2LM", "63k", "5Ra", "4MA", "6xb", "2CL", "02g", "0XC", "39I", "6VN", "4cm", "bTn", "a5d", "2I", "0Us", "86O", "Xm", "5E1", "5PP", 
			
 
				+"6kP", "5NR", "11t", "Fo", "hC", "0Kq", "44W", "aon", "6HL", "49g", "0FA", "es", "3Mo", "0hm", "4SC", "72I", "6ia", "5Lc", "0gl", "V", 
			
 
				+"jr", "1Ya", "46f", "6GM", "hyV", "bEm", "0Dp", "gB", "In", "8cD", "4Qr", "5T2", "1b", "0VX", "4mv", "5h6", "62q", "4CZ", "0xt", "2MW", 
			
 
				+"Vv", "01L", "4Nj", "7kh", "6Ue", "54o", "1KI", "xZ", "3S", "0Ti", "4oG", "6Zd", "6tH", "4Ak", "0zE", "Yw", "TG", "0wu", "780", "6yx", 
			
 
				+"5g7", "4bw", "0YY", "zk", "1Wz", "di", "5y5", "5lT", "4RY", "4G8", "JE", "0iw", "0dG", "Gu", "6jJ", "5OH", "45M", "6Df", "iY", "80", 
			
 
				+"71", "fX", "6Kg", "5ne", "4Ph", "6eK", "Ht", "0kF", "0fv", "ED", "4H9", "5My", "4st", "5v4", "kh", "0HZ", "0Zv", "yD", "401", "4aX", 
			
 
				+"4Ot", "5J4", "Wh", "00R", "O9", "ZX", "63o", "4BD", "4lh", "6YK", "tt", "0WF", "0XG", "2md", "6VJ", "4ci", "4ME", "6xf", "UY", "02c", 
			
 
				+"1kz", "Xi", "5E5", "5PT", "4nY", "aqh", "2M", "0Uw", "hG", "0Ku", "44S", "6Ex", "6kT", "5NV", "0eY", "Fk", "3Mk", "0hi", "4SG", "6fd", 
			
 
				+"6HH", "49c", "0FE", "ew", "jv", "0ID", "46b", "6GI", "6ie", "5Lg", "0gh", "R", "Ij", "0jX", "4Qv", "5T6", "6Jy", "7O9", "0Dt", "gF", 
			
 
				+"62u", "775", "0xp", "198", "1f", "9Oe", "4mr", "5h2", "6Ua", "54k", "1KM", "2nO", "Vr", "01H", "4Nn", "7kl", "60D", "4Ao", "0zA", "Ys", 
			
 
				+"3W", "0Tm", "4oC", "7JA", "5g3", "4bs", "8PE", "zo", "TC", "03y", "784", "aSn", "bhn", "73W", "JA", "0is", "334", "dm", "5y1", "48y", 
			
 
				+"45I", "6Db", "3om", "84", "0dC", "Gq", "6jN", "5OL", "4Pl", "6eO", "Hp", "0kB", "75", "24E", "6Kc", "5na", "47x", "528", "kl", "8AF", 
			
 
				+"0fr", "1c2", "aBm", "bgo", "4ld", "6YG", "0p", "0WJ", "O5", "ZT", "63c", "4BH", "4Ox", "5J8", "Wd", "0tV", "0Zz", "yH", "4t5", "4aT", 
			
 
				+"4nU", "7KW", "2A", "1EZ", "1kv", "Xe", "5E9", "5PX", "4MI", "6xj", "UU", "02o", "0XK", "2mh", "6VF", "4ce", "6HD", "49o", "0FI", "27b", 
			
 
				+"KW", "0he", "4SK", "6fh", "6kX", "5NZ", "0eU", "Fg", "hK", "0Ky", "4pW", "4e6", "4j7", "5ow", "0Dx", "gJ", "If", "0jT", "4Qz", "6dY", 
			
 
				+"6ii", "5Lk", "Q7", "DV", "jz", "0IH", "46n", "6GE", "3PN", "01D", "4Nb", "aQS", "6Um", "54g", "m3", "xR", "1j", "0VP", "59W", "a6G", 
			
 
				+"4V3", "4CR", "85l", "194", "TO", "03u", "4LS", "4Y2", "a9F", "56V", "0YQ", "zc", "wS", "b2", "4oO", "6Zl", "60H", "4Ac", "0zM", "2On", 
			
 
				+"0dO", "2Ql", "6jB", "aU1", "45E", "6Dn", "iQ", "88", "0GS", "da", "acL", "48u", "4RQ", "4G0", "JM", "94N", "12W", "EL", "4H1", "5Mq", 
			
 
				+"47t", "524", "29y", "0HR", "79", "fP", "6Ko", "5nm", "aZ0", "6eC", "3NL", "0kN", "O1", "ZP", "63g", "4BL", "58I", "6YC", "0t", "0WN", 
			
 
				+"8Sf", "yL", "409", "4aP", "b1G", "aPM", "0a3", "00Z", "1kr", "Xa", "61V", "bzN", "4nQ", "7KS", "2E", "215", "0XO", "2ml", "6VB", "4ca", 
			
 
				+"4MM", "6xn", "UQ", "02k", "KS", "0ha", "4SO", "6fl", "7Xa", "49k", "0FM", "27f", "hO", "8Be", "4pS", "4e2", "aAN", "bdL", "0eQ", "Fc", 
			
 
				+"Ib", "0jP", "654", "70t", "4j3", "5os", "8Md", "gN", "28g", "0IL", "46j", "6GA", "6im", "5Lo", "Q3", "Z", "6Ui", "54c", "m7", "xV", 
			
 
				+"Vz", "0uH", "4Nf", "7kd", "4V7", "4CV", "0xx", "190", "1n", "0VT", "4mz", "6XY", "6WX", "56R", "0YU", "zg", "TK", "03q", "4LW", "4Y6", 
			
 
				+"60L", "4Ag", "0zI", "2Oj", "wW", "b6", "4oK", "6Zh", "45A", "6Dj", "iU", "0Jg", "0dK", "Gy", "6jF", "5OD", "4RU", "4G4", "JI", "1yZ", 
			
 
				+"0GW", "de", "5y9", "48q", "47p", "520", "kd", "0HV", "0fz", "EH", "4H5", "5Mu", "4Pd", "6eG", "Hx", "0kJ", "s5", "fT", "6Kk", "5ni", 
			
 
				+"5Y1", "5LP", "13v", "e", "jA", "0Is", "46U", "aml", "6JN", "5oL", "0DC", "gq", "3Om", "0jo", "4QA", "6db", "6kc", "5Na", "0en", "2PM", 
			
 
				+"hp", "0KB", "44d", "6EO", "abm", "49T", "0Fr", "1C2", "Kl", "8aF", "4Sp", "5V0", "4Mr", "5H2", "Un", "02T", "0Xp", "2mS", "427", "57w", 
			
 
				+"4nn", "7Kl", "2z", "1Ea", "1kM", "2NO", "61i", "5Pc", "4OC", "7jA", "2AN", "00e", "0ZA", "ys", "6TL", "4ao", "58v", "a7f", "0K", "0Wq", 
			
 
				+"84M", "Zo", "5G3", "4Bs", "0EY", "fk", "6KT", "5nV", "bjh", "6ex", "HG", "0ku", "0fE", "Ew", "6hH", "5MJ", "47O", "6Fd", "29B", "0Hi", 
			
 
				+"53", "dZ", "6Ie", "48N", "4Rj", "6gI", "Jv", "0iD", "0dt", "GF", "6jy", "7o9", "4qv", "5t6", "ij", "0JX", "wh", "0TZ", "4ot", "5j4", 
			
 
				+"4T9", "4AX", "0zv", "YD", "Tt", "03N", "4Lh", "6yK", "6Wg", "4bD", "o9", "zX", "1Q", "0Vk", "4mE", "6Xf", "62B", "4Ci", "0xG", "2Md", 
			
 
				+"VE", "0uw", "4NY", "aQh", "5e5", "5pT", "1Kz", "xi", "jE", "0Iw", "46Q", "4g8", "5Y5", "5LT", "13r", "a", "IY", "0jk", "4QE", "6df", 
			
 
				+"6JJ", "5oH", "0DG", "gu", "ht", "0KF", "4ph", "6EK", "6kg", "5Ne", "S9", "FX", "Kh", "0hZ", "4St", "5V4", "4h9", "49P", "0Fv", "eD", 
			
 
				+"0Xt", "2mW", "423", "4cZ", "4Mv", "5H6", "Uj", "02P", "1kI", "XZ", "61m", "5Pg", "4nj", "7Kh", "vv", "0UD", "0ZE", "yw", "6TH", "4ak", 
			
 
				+"4OG", "6zd", "2AJ", "00a", "0yY", "Zk", "5G7", "4Bw", "58r", "6Yx", "0O", "0Wu", "bjl", "71U", "HC", "0kq", "316", "fo", "6KP", "5nR", 
			
 
				+"47K", "7VA", "29F", "0Hm", "0fA", "Es", "6hL", "5MN", "4Rn", "6gM", "Jr", "1ya", "57", "26G", "6Ia", "48J", "45z", "5t2", "in", "8CD", 
			
 
				+"0dp", "GB", "hYV", "bem", "60w", "757", "0zr", "2OQ", "3d", "9Mg", "4op", "5j0", "6Wc", "56i", "0Yn", "2lM", "Tp", "03J", "4Ll", "6yO", 
			
 
				+"62F", "4Cm", "0xC", "dwS", "1U", "0Vo", "4mA", "6Xb", "5e1", "54X", "8RG", "xm", "VA", "0us", "b0f", "aQl", "6JF", "5oD", "0DK", "gy", 
			
 
				+"IU", "0jg", "4QI", "6dj", "5Y9", "5LX", "0gW", "m", "jI", "1YZ", "4rU", "4g4", "4h5", "5mu", "0Fz", "eH", "Kd", "0hV", "4Sx", "5V8", 
			
 
				+"6kk", "5Ni", "S5", "FT", "hx", "0KJ", "44l", "6EG", "4nf", "7Kd", "2r", "0UH", "M7", "XV", "61a", "5Pk", "4Mz", "6xY", "Uf", "0vT", 
			
 
				+"0Xx", "39r", "4v7", "4cV", "4lW", "4y6", "0C", "0Wy", "0yU", "Zg", "63P", "5RZ", "4OK", "6zh", "WW", "B6", "0ZI", "2oj", "6TD", "4ag", 
			
 
				+"0fM", "2Sn", "7xa", "5MB", "47G", "6Fl", "kS", "0Ha", "0EQ", "fc", "aaN", "bDL", "4PS", "4E2", "HO", "8be", "10U", "GN", "4J3", "5Os", 
			
 
				+"45v", "506", "ib", "0JP", "q3", "dR", "6Im", "48F", "4Rb", "6gA", "3LN", "0iL", "2Bm", "03F", "aF0", "6yC", "6Wo", "4bL", "o1", "zP", 
			
 
				+"3h", "0TR", "bUO", "a4E", "4T1", "4AP", "87n", "YL", "VM", "01w", "4NQ", "7kS", "hfu", "54T", "1Kr", "xa", "1Y", "0Vc", "4mM", "6Xn", 
			
 
				+"62J", "4Ca", "0xO", "2Ml", "IQ", "0jc", "4QM", "6dn", "6JB", "a19", "0DO", "25d", "jM", "9PF", "46Y", "4g0", "aCL", "687", "0gS", "i", 
			
 
				+"3MP", "0hR", "676", "72v", "4h1", "49X", "8Of", "eL", "3nL", "0KN", "44h", "6EC", "6ko", "5Nm", "S1", "FP", "M3", "XR", "61e", "5Po", 
			
 
				+"4nb", "aqS", "2v", "0UL", "8Qd", "39v", "4v3", "4cR", "b3E", "aRO", "Ub", "02X", "0yQ", "Zc", "63T", "bxL", "4lS", "4y2", "0G", "237", 
			
 
				+"0ZM", "2on", "7Da", "4ac", "4OO", "6zl", "WS", "B2", "47C", "6Fh", "kW", "0He", "0fI", "2Sj", "6hD", "5MF", "4PW", "4E6", "HK", "0ky", 
			
 
				+"0EU", "fg", "6KX", "5nZ", "45r", "502", "if", "0JT", "0dx", "GJ", "4J7", "5Ow", "4Rf", "6gE", "Jz", "0iH", "q7", "dV", "6Ii", "48B", 
			
 
				+"6Wk", "4bH", "o5", "zT", "Tx", "03B", "4Ld", "6yG", "4T5", "4AT", "0zz", "YH", "3l", "0TV", "4ox", "5j8", "5e9", "54P", "1Kv", "xe", 
			
 
				+"VI", "01s", "4NU", "7kW", "62N", "4Ce", "0xK", "2Mh", "uU", "0Vg", "4mI", "6Xj", "4K0", "5Np", "11V", "FM", "ha", "0KS", "44u", "515", 
			
 
				+"6Hn", "49E", "48", "eQ", "3MM", "0hO", "4Sa", "6fB", "6iC", "5LA", "0gN", "t", "jP", "0Ib", "46D", "6Go", "hyt", "bEO", "0DR", "0Q3", 
			
 
				+"IL", "8cf", "4QP", "4D1", "4OR", "4Z3", "WN", "00t", "0ZP", "yb", "hgv", "55W", "4lN", "6Ym", "0Z", "a3", "0yL", "2Lo", "63I", "4Bb", 
			
 
				+"4Mc", "7ha", "2Cn", "02E", "n2", "2mB", "6Vl", "4cO", "bTL", "a5F", "2k", "0UQ", "86m", "XO", "4U2", "5Pr", "0Gy", "dK", "4i6", "5lv", 
			
 
				+"5BZ", "6gX", "Jg", "0iU", "R6", "GW", "6jh", "5Oj", "45o", "6DD", "3oK", "0JI", "0EH", "fz", "6KE", "5nG", "4PJ", "6ei", "HV", "0kd", 
			
 
				+"0fT", "Ef", "6hY", "690", "4sV", "4f7", "kJ", "0Hx", "uH", "0Vz", "4mT", "4x5", "5F8", "4Cx", "0xV", "0m7", "VT", "C5", "4NH", "7kJ", 
			
 
				+"6UG", "54M", "1Kk", "xx", "3q", "0TK", "4oe", "6ZF", "60b", "4AI", "L4", "YU", "Te", "0wW", "4Ly", "5I9", "4w4", "4bU", "1IZ", "zI", 
			
 
				+"he", "0KW", "44q", "511", "4K4", "5Nt", "11R", "FI", "Ky", "0hK", "4Se", "6fF", "6Hj", "49A", "p4", "eU", "jT", "0If", "4rH", "6Gk", 
			
 
				+"6iG", "5LE", "0gJ", "p", "IH", "0jz", "4QT", "4D5", "5z8", "5oY", "0DV", "gd", "0ZT", "yf", "6TY", "4az", "4OV", "4Z7", "WJ", "00p", 
			
 
				+"0yH", "Zz", "63M", "4Bf", "4lJ", "6Yi", "tV", "a7", "n6", "2mF", "6Vh", "4cK", "4Mg", "6xD", "2Cj", "02A", "1kX", "XK", "4U6", "5Pv", 
			
 
				+"6N9", "7Ky", "2o", "0UU", "665", "73u", "Jc", "0iQ", "8Ne", "dO", "4i2", "5lr", "45k", "7Ta", "3oO", "0JM", "R2", "GS", "6jl", "5On", 
			
 
				+"4PN", "6em", "HR", "8bx", "0EL", "24g", "6KA", "5nC", "47Z", "4f3", "kN", "8Ad", "0fP", "Eb", "aBO", "694", "62W", "byO", "0xR", "0m3", 
			
 
				+"1D", "224", "4mP", "4x1", "6UC", "54I", "1Ko", "2nm", "VP", "C1", "4NL", "7kN", "60f", "4AM", "L0", "YQ", "3u", "0TO", "4oa", "6ZB", 
			
 
				+"438", "4bQ", "8Pg", "zM", "Ta", "0wS", "b2F", "aSL", "6Hf", "49M", "40", "eY", "Ku", "0hG", "4Si", "6fJ", "4K8", "5Nx", "0ew", "FE", 
			
 
				+"hi", "8BC", "4pu", "5u5", "5z4", "5oU", "0DZ", "gh", "ID", "0jv", "4QX", "4D9", "6iK", "5LI", "0gF", "Dt", "jX", "0Ij", "46L", "6Gg", 
			
 
				+"4lF", "6Ye", "0R", "0Wh", "0yD", "Zv", "63A", "4Bj", "4OZ", "6zy", "WF", "0tt", "0ZX", "yj", "5d6", "4av", "4nw", "5k7", "2c", "0UY", 
			
 
				+"1kT", "XG", "61p", "5Pz", "4Mk", "6xH", "Uw", "02M", "0Xi", "2mJ", "6Vd", "4cG", "0dm", "2QN", "7zA", "5Ob", "45g", "6DL", "is", "0JA", 
			
 
				+"0Gq", "dC", "acn", "48W", "4Rs", "5W3", "Jo", "94l", "12u", "En", "5X2", "5MS", "47V", "alo", "kB", "0Hp", "1Ua", "fr", "6KM", "5nO", 
			
 
				+"4PB", "6ea", "3Nn", "0kl", "3Pl", "01f", "bts", "7kB", "6UO", "54E", "1Kc", "xp", "1H", "0Vr", "59u", "a6e", "5F0", "4Cp", "85N", "d3F", 
			
 
				+"Tm", "03W", "4Lq", "5I1", "434", "56t", "0Ys", "zA", "3y", "0TC", "4om", "6ZN", "60j", "4AA", "0zo", "2OL", "Kq", "0hC", "4Sm", "6fN", 
			
 
				+"6Hb", "49I", "44", "27D", "hm", "8BG", "44y", "519", "aAl", "bdn", "0es", "FA", "1o2", "0jr", "bko", "70V", "5z0", "5oQ", "305", "gl", 
			
 
				+"28E", "0In", "46H", "6Gc", "6iO", "5LM", "0gB", "x", "1ia", "Zr", "63E", "4Bn", "4lB", "6Ya", "0V", "0Wl", "8SD", "yn", "5d2", "4ar", 
			
 
				+"b1e", "aPo", "WB", "00x", "1kP", "XC", "61t", "744", "4ns", "5k3", "2g", "9Ld", "0Xm", "2mN", "7FA", "4cC", "4Mo", "6xL", "Us", "02I", 
			
 
				+"45c", "6DH", "iw", "0JE", "0di", "2QJ", "6jd", "5Of", "4Rw", "5W7", "Jk", "0iY", "0Gu", "dG", "6Ix", "48S", "47R", "6Fy", "kF", "0Ht", 
			
 
				+"0fX", "Ej", "5X6", "5MW", "4PF", "6ee", "HZ", "0kh", "0ED", "fv", "6KI", "5nK", "6UK", "54A", "1Kg", "xt", "VX", "C9", "4ND", "7kF", 
			
 
				+"5F4", "4Ct", "0xZ", "2My", "1L", "0Vv", "4mX", "4x9", "430", "4bY", "0Yw", "zE", "Ti", "03S", "4Lu", "5I5", "60n", "4AE", "L8", "YY", 
			
 
				+"wu", "0TG", "4oi", "6ZJ" };
			
 
				+
			
 
				+
			
 
				+#endif
			
 
				+
			
--- a/src/crc64.c
+++ b/src/crc64.c
@@ -0,0 +1,161 @@
 
				+/* Copyright (c) 2014, Matt Stancliff <matt@genges.com>
			
 
				+ * Copyright (c) 2020, Amazon Web Services
			
 
				+ * 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. */
			
 
				+
			
 
				+#include "crc64.h"
			
 
				+#include "crcspeed.h"
			
 
				+static uint64_t crc64_table[8][256] = {{0}};
			
 
				+
			
 
				+#define POLY UINT64_C(0xad93d23594c935a9)
			
 
				+/******************** BEGIN GENERATED PYCRC FUNCTIONS ********************/
			
 
				+/**
			
 
				+ * Generated on Sun Dec 21 14:14:07 2014,
			
 
				+ * by pycrc v0.8.2, https://www.tty1.net/pycrc/
			
 
				+ *
			
 
				+ * LICENSE ON GENERATED CODE:
			
 
				+ * ==========================
			
 
				+ * As of version 0.6, pycrc is released under the terms of the MIT licence.
			
 
				+ * The code generated by pycrc is not considered a substantial portion of the
			
 
				+ * software, therefore the author of pycrc will not claim any copyright on
			
 
				+ * the generated code.
			
 
				+ * ==========================
			
 
				+ *
			
 
				+ * CRC configuration:
			
 
				+ *    Width        = 64
			
 
				+ *    Poly         = 0xad93d23594c935a9
			
 
				+ *    XorIn        = 0xffffffffffffffff
			
 
				+ *    ReflectIn    = True
			
 
				+ *    XorOut       = 0x0000000000000000
			
 
				+ *    ReflectOut   = True
			
 
				+ *    Algorithm    = bit-by-bit-fast
			
 
				+ *
			
 
				+ * Modifications after generation (by matt):
			
 
				+ *   - included finalize step in-line with update for single-call generation
			
 
				+ *   - re-worked some inner variable architectures
			
 
				+ *   - adjusted function parameters to match expected prototypes.
			
 
				+ *****************************************************************************/
			
 
				+
			
 
				+/**
			
 
				+ * Reflect all bits of a \a data word of \a data_len bytes.
			
 
				+ *
			
 
				+ * \param data         The data word to be reflected.
			
 
				+ * \param data_len     The width of \a data expressed in number of bits.
			
 
				+ * \return             The reflected data.
			
 
				+ *****************************************************************************/
			
 
				+static inline uint_fast64_t crc_reflect(uint_fast64_t data, size_t data_len) {
			
 
				+    uint_fast64_t ret = data & 0x01;
			
 
				+
			
 
				+    for (size_t i = 1; i < data_len; i++) {
			
 
				+        data >>= 1;
			
 
				+        ret = (ret << 1) | (data & 0x01);
			
 
				+    }
			
 
				+
			
 
				+    return ret;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ *  Update the crc value with new data.
			
 
				+ *
			
 
				+ * \param crc      The current crc value.
			
 
				+ * \param data     Pointer to a buffer of \a data_len bytes.
			
 
				+ * \param data_len Number of bytes in the \a data buffer.
			
 
				+ * \return         The updated crc value.
			
 
				+ ******************************************************************************/
			
 
				+uint64_t _crc64(uint_fast64_t crc, const void *in_data, const uint64_t len) {
			
 
				+    const uint8_t *data = in_data;
			
 
				+    unsigned long long bit;
			
 
				+
			
 
				+    for (uint64_t offset = 0; offset < len; offset++) {
			
 
				+        uint8_t c = data[offset];
			
 
				+        for (uint_fast8_t i = 0x01; i & 0xff; i <<= 1) {
			
 
				+            bit = crc & 0x8000000000000000;
			
 
				+            if (c & i) {
			
 
				+                bit = !bit;
			
 
				+            }
			
 
				+
			
 
				+            crc <<= 1;
			
 
				+            if (bit) {
			
 
				+                crc ^= POLY;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        crc &= 0xffffffffffffffff;
			
 
				+    }
			
 
				+
			
 
				+    crc = crc & 0xffffffffffffffff;
			
 
				+    return crc_reflect(crc, 64) ^ 0x0000000000000000;
			
 
				+}
			
 
				+
			
 
				+/******************** END GENERATED PYCRC FUNCTIONS ********************/
			
 
				+
			
 
				+/* Initializes the 16KB lookup tables. */
			
 
				+void crc64_init(void) {
			
 
				+    crcspeed64native_init(_crc64, crc64_table);
			
 
				+}
			
 
				+
			
 
				+/* Compute crc64 */
			
 
				+uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l) {
			
 
				+    return crcspeed64native(crc64_table, crc, (void *) s, l);
			
 
				+}
			
 
				+
			
 
				+/* Test main */
			
 
				+#ifdef REDIS_TEST
			
 
				+#include <stdio.h>
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+int crc64Test(int argc, char *argv[], int flags) {
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+    crc64_init();
			
 
				+    printf("[calcula]: e9c6d914c4b8d9ca == %016" PRIx64 "\n",
			
 
				+           (uint64_t)_crc64(0, "123456789", 9));
			
 
				+    printf("[64speed]: e9c6d914c4b8d9ca == %016" PRIx64 "\n",
			
 
				+           (uint64_t)crc64(0, (unsigned char*)"123456789", 9));
			
 
				+    char li[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed "
			
 
				+                "do eiusmod tempor incididunt ut labore et dolore magna "
			
 
				+                "aliqua. Ut enim ad minim veniam, quis nostrud exercitation "
			
 
				+                "ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis "
			
 
				+                "aute irure dolor in reprehenderit in voluptate velit esse "
			
 
				+                "cillum dolore eu fugiat nulla pariatur. Excepteur sint "
			
 
				+                "occaecat cupidatat non proident, sunt in culpa qui officia "
			
 
				+                "deserunt mollit anim id est laborum.";
			
 
				+    printf("[calcula]: c7794709e69683b3 == %016" PRIx64 "\n",
			
 
				+           (uint64_t)_crc64(0, li, sizeof(li)));
			
 
				+    printf("[64speed]: c7794709e69683b3 == %016" PRIx64 "\n",
			
 
				+           (uint64_t)crc64(0, (unsigned char*)li, sizeof(li)));
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+#endif
			
 
				+
			
 
				+#ifdef REDIS_TEST_MAIN
			
 
				+int main(int argc, char *argv[]) {
			
 
				+    return crc64Test(argc, argv);
			
 
				+}
			
 
				+
			
 
				+#endif
			
--- a/src/crc64.h
+++ b/src/crc64.h
@@ -0,0 +1,13 @@
 
				+#ifndef CRC64_H
			
 
				+#define CRC64_H
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+void crc64_init(void);
			
 
				+uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int crc64Test(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/crcspeed.c
+++ b/src/crcspeed.c
@@ -0,0 +1,282 @@
 
				+/*
			
 
				+ * Copyright (C) 2013 Mark Adler
			
 
				+ * Originally by: crc64.c Version 1.4  16 Dec 2013  Mark Adler
			
 
				+ * Modifications by Matt Stancliff <matt@genges.com>:
			
 
				+ *   - removed CRC64-specific behavior
			
 
				+ *   - added generation of lookup tables by parameters
			
 
				+ *   - removed inversion of CRC input/result
			
 
				+ *   - removed automatic initialization in favor of explicit initialization
			
 
				+
			
 
				+  This software is provided 'as-is', without any express or implied
			
 
				+  warranty.  In no event will the author be held liable for any damages
			
 
				+  arising from the use of this software.
			
 
				+
			
 
				+  Permission is granted to anyone to use this software for any purpose,
			
 
				+  including commercial applications, and to alter it and redistribute it
			
 
				+  freely, subject to the following restrictions:
			
 
				+
			
 
				+  1. The origin of this software must not be misrepresented; you must not
			
 
				+     claim that you wrote the original software. If you use this software
			
 
				+     in a product, an acknowledgment in the product documentation would be
			
 
				+     appreciated but is not required.
			
 
				+  2. Altered source versions must be plainly marked as such, and must not be
			
 
				+     misrepresented as being the original software.
			
 
				+  3. This notice may not be removed or altered from any source distribution.
			
 
				+
			
 
				+  Mark Adler
			
 
				+  madler@alumni.caltech.edu
			
 
				+ */
			
 
				+
			
 
				+#include "crcspeed.h"
			
 
				+
			
 
				+/* Fill in a CRC constants table. */
			
 
				+void crcspeed64little_init(crcfn64 crcfn, uint64_t table[8][256]) {
			
 
				+    uint64_t crc;
			
 
				+
			
 
				+    /* generate CRCs for all single byte sequences */
			
 
				+    for (int n = 0; n < 256; n++) {
			
 
				+        unsigned char v = n;
			
 
				+        table[0][n] = crcfn(0, &v, 1);
			
 
				+    }
			
 
				+
			
 
				+    /* generate nested CRC table for future slice-by-8 lookup */
			
 
				+    for (int n = 0; n < 256; n++) {
			
 
				+        crc = table[0][n];
			
 
				+        for (int k = 1; k < 8; k++) {
			
 
				+            crc = table[0][crc & 0xff] ^ (crc >> 8);
			
 
				+            table[k][n] = crc;
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+void crcspeed16little_init(crcfn16 crcfn, uint16_t table[8][256]) {
			
 
				+    uint16_t crc;
			
 
				+
			
 
				+    /* generate CRCs for all single byte sequences */
			
 
				+    for (int n = 0; n < 256; n++) {
			
 
				+        table[0][n] = crcfn(0, &n, 1);
			
 
				+    }
			
 
				+
			
 
				+    /* generate nested CRC table for future slice-by-8 lookup */
			
 
				+    for (int n = 0; n < 256; n++) {
			
 
				+        crc = table[0][n];
			
 
				+        for (int k = 1; k < 8; k++) {
			
 
				+            crc = table[0][(crc >> 8) & 0xff] ^ (crc << 8);
			
 
				+            table[k][n] = crc;
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Reverse the bytes in a 64-bit word. */
			
 
				+static inline uint64_t rev8(uint64_t a) {
			
 
				+#if defined(__GNUC__) || defined(__clang__)
			
 
				+    return __builtin_bswap64(a);
			
 
				+#else
			
 
				+    uint64_t m;
			
 
				+
			
 
				+    m = UINT64_C(0xff00ff00ff00ff);
			
 
				+    a = ((a >> 8) & m) | (a & m) << 8;
			
 
				+    m = UINT64_C(0xffff0000ffff);
			
 
				+    a = ((a >> 16) & m) | (a & m) << 16;
			
 
				+    return a >> 32 | a << 32;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* This function is called once to initialize the CRC table for use on a
			
 
				+   big-endian architecture. */
			
 
				+void crcspeed64big_init(crcfn64 fn, uint64_t big_table[8][256]) {
			
 
				+    /* Create the little endian table then reverse all the entries. */
			
 
				+    crcspeed64little_init(fn, big_table);
			
 
				+    for (int k = 0; k < 8; k++) {
			
 
				+        for (int n = 0; n < 256; n++) {
			
 
				+            big_table[k][n] = rev8(big_table[k][n]);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+void crcspeed16big_init(crcfn16 fn, uint16_t big_table[8][256]) {
			
 
				+    /* Create the little endian table then reverse all the entries. */
			
 
				+    crcspeed16little_init(fn, big_table);
			
 
				+    for (int k = 0; k < 8; k++) {
			
 
				+        for (int n = 0; n < 256; n++) {
			
 
				+            big_table[k][n] = rev8(big_table[k][n]);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Calculate a non-inverted CRC multiple bytes at a time on a little-endian
			
 
				+ * architecture. If you need inverted CRC, invert *before* calling and invert
			
 
				+ * *after* calling.
			
 
				+ * 64 bit crc = process 8 bytes at once;
			
 
				+ */
			
 
				+uint64_t crcspeed64little(uint64_t little_table[8][256], uint64_t crc,
			
 
				+                          void *buf, size_t len) {
			
 
				+    unsigned char *next = buf;
			
 
				+
			
 
				+    /* process individual bytes until we reach an 8-byte aligned pointer */
			
 
				+    while (len && ((uintptr_t)next & 7) != 0) {
			
 
				+        crc = little_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    /* fast middle processing, 8 bytes (aligned!) per loop */
			
 
				+    while (len >= 8) {
			
 
				+        crc ^= *(uint64_t *)next;
			
 
				+        crc = little_table[7][crc & 0xff] ^
			
 
				+              little_table[6][(crc >> 8) & 0xff] ^
			
 
				+              little_table[5][(crc >> 16) & 0xff] ^
			
 
				+              little_table[4][(crc >> 24) & 0xff] ^
			
 
				+              little_table[3][(crc >> 32) & 0xff] ^
			
 
				+              little_table[2][(crc >> 40) & 0xff] ^
			
 
				+              little_table[1][(crc >> 48) & 0xff] ^
			
 
				+              little_table[0][crc >> 56];
			
 
				+        next += 8;
			
 
				+        len -= 8;
			
 
				+    }
			
 
				+
			
 
				+    /* process remaining bytes (can't be larger than 8) */
			
 
				+    while (len) {
			
 
				+        crc = little_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    return crc;
			
 
				+}
			
 
				+
			
 
				+uint16_t crcspeed16little(uint16_t little_table[8][256], uint16_t crc,
			
 
				+                          void *buf, size_t len) {
			
 
				+    unsigned char *next = buf;
			
 
				+
			
 
				+    /* process individual bytes until we reach an 8-byte aligned pointer */
			
 
				+    while (len && ((uintptr_t)next & 7) != 0) {
			
 
				+        crc = little_table[0][((crc >> 8) ^ *next++) & 0xff] ^ (crc << 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    /* fast middle processing, 8 bytes (aligned!) per loop */
			
 
				+    while (len >= 8) {
			
 
				+        uint64_t n = *(uint64_t *)next;
			
 
				+        crc = little_table[7][(n & 0xff) ^ ((crc >> 8) & 0xff)] ^
			
 
				+              little_table[6][((n >> 8) & 0xff) ^ (crc & 0xff)] ^
			
 
				+              little_table[5][(n >> 16) & 0xff] ^
			
 
				+              little_table[4][(n >> 24) & 0xff] ^
			
 
				+              little_table[3][(n >> 32) & 0xff] ^
			
 
				+              little_table[2][(n >> 40) & 0xff] ^
			
 
				+              little_table[1][(n >> 48) & 0xff] ^
			
 
				+              little_table[0][n >> 56];
			
 
				+        next += 8;
			
 
				+        len -= 8;
			
 
				+    }
			
 
				+
			
 
				+    /* process remaining bytes (can't be larger than 8) */
			
 
				+    while (len) {
			
 
				+        crc = little_table[0][((crc >> 8) ^ *next++) & 0xff] ^ (crc << 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    return crc;
			
 
				+}
			
 
				+
			
 
				+/* Calculate a non-inverted CRC eight bytes at a time on a big-endian
			
 
				+ * architecture.
			
 
				+ */
			
 
				+uint64_t crcspeed64big(uint64_t big_table[8][256], uint64_t crc, void *buf,
			
 
				+                       size_t len) {
			
 
				+    unsigned char *next = buf;
			
 
				+
			
 
				+    crc = rev8(crc);
			
 
				+    while (len && ((uintptr_t)next & 7) != 0) {
			
 
				+        crc = big_table[0][(crc >> 56) ^ *next++] ^ (crc << 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    while (len >= 8) {
			
 
				+        crc ^= *(uint64_t *)next;
			
 
				+        crc = big_table[0][crc & 0xff] ^
			
 
				+              big_table[1][(crc >> 8) & 0xff] ^
			
 
				+              big_table[2][(crc >> 16) & 0xff] ^
			
 
				+              big_table[3][(crc >> 24) & 0xff] ^
			
 
				+              big_table[4][(crc >> 32) & 0xff] ^
			
 
				+              big_table[5][(crc >> 40) & 0xff] ^
			
 
				+              big_table[6][(crc >> 48) & 0xff] ^
			
 
				+              big_table[7][crc >> 56];
			
 
				+        next += 8;
			
 
				+        len -= 8;
			
 
				+    }
			
 
				+
			
 
				+    while (len) {
			
 
				+        crc = big_table[0][(crc >> 56) ^ *next++] ^ (crc << 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    return rev8(crc);
			
 
				+}
			
 
				+
			
 
				+/* WARNING: Completely untested on big endian architecture.  Possibly broken. */
			
 
				+uint16_t crcspeed16big(uint16_t big_table[8][256], uint16_t crc_in, void *buf,
			
 
				+                       size_t len) {
			
 
				+    unsigned char *next = buf;
			
 
				+    uint64_t crc = crc_in;
			
 
				+
			
 
				+    crc = rev8(crc);
			
 
				+    while (len && ((uintptr_t)next & 7) != 0) {
			
 
				+        crc = big_table[0][((crc >> (56 - 8)) ^ *next++) & 0xff] ^ (crc >> 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    while (len >= 8) {
			
 
				+        uint64_t n = *(uint64_t *)next;
			
 
				+        crc = big_table[0][(n & 0xff) ^ ((crc >> (56 - 8)) & 0xff)] ^
			
 
				+              big_table[1][((n >> 8) & 0xff) ^ (crc & 0xff)] ^
			
 
				+              big_table[2][(n >> 16) & 0xff] ^
			
 
				+              big_table[3][(n >> 24) & 0xff] ^
			
 
				+              big_table[4][(n >> 32) & 0xff] ^
			
 
				+              big_table[5][(n >> 40) & 0xff] ^
			
 
				+              big_table[6][(n >> 48) & 0xff] ^
			
 
				+              big_table[7][n >> 56];
			
 
				+        next += 8;
			
 
				+        len -= 8;
			
 
				+    }
			
 
				+
			
 
				+    while (len) {
			
 
				+        crc = big_table[0][((crc >> (56 - 8)) ^ *next++) & 0xff] ^ (crc >> 8);
			
 
				+        len--;
			
 
				+    }
			
 
				+
			
 
				+    return rev8(crc);
			
 
				+}
			
 
				+
			
 
				+/* Return the CRC of buf[0..len-1] with initial crc, processing eight bytes
			
 
				+   at a time using passed-in lookup table.
			
 
				+   This selects one of two routines depending on the endianness of
			
 
				+   the architecture. */
			
 
				+uint64_t crcspeed64native(uint64_t table[8][256], uint64_t crc, void *buf,
			
 
				+                          size_t len) {
			
 
				+    uint64_t n = 1;
			
 
				+
			
 
				+    return *(char *)&n ? crcspeed64little(table, crc, buf, len)
			
 
				+                       : crcspeed64big(table, crc, buf, len);
			
 
				+}
			
 
				+
			
 
				+uint16_t crcspeed16native(uint16_t table[8][256], uint16_t crc, void *buf,
			
 
				+                          size_t len) {
			
 
				+    uint64_t n = 1;
			
 
				+
			
 
				+    return *(char *)&n ? crcspeed16little(table, crc, buf, len)
			
 
				+                       : crcspeed16big(table, crc, buf, len);
			
 
				+}
			
 
				+
			
 
				+/* Initialize CRC lookup table in architecture-dependent manner. */
			
 
				+void crcspeed64native_init(crcfn64 fn, uint64_t table[8][256]) {
			
 
				+    uint64_t n = 1;
			
 
				+
			
 
				+    *(char *)&n ? crcspeed64little_init(fn, table)
			
 
				+                : crcspeed64big_init(fn, table);
			
 
				+}
			
 
				+
			
 
				+void crcspeed16native_init(crcfn16 fn, uint16_t table[8][256]) {
			
 
				+    uint64_t n = 1;
			
 
				+
			
 
				+    *(char *)&n ? crcspeed16little_init(fn, table)
			
 
				+                : crcspeed16big_init(fn, table);
			
 
				+}
			
--- a/src/crcspeed.h
+++ b/src/crcspeed.h
@@ -0,0 +1,60 @@
 
				+/* Copyright (c) 2014, Matt Stancliff <matt@genges.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. */
			
 
				+
			
 
				+#ifndef CRCSPEED_H
			
 
				+#define CRCSPEED_H
			
 
				+
			
 
				+#include <inttypes.h>
			
 
				+#include <stdio.h>
			
 
				+
			
 
				+typedef uint64_t (*crcfn64)(uint64_t, const void *, const uint64_t);
			
 
				+typedef uint16_t (*crcfn16)(uint16_t, const void *, const uint64_t);
			
 
				+
			
 
				+/* CRC-64 */
			
 
				+void crcspeed64little_init(crcfn64 fn, uint64_t table[8][256]);
			
 
				+void crcspeed64big_init(crcfn64 fn, uint64_t table[8][256]);
			
 
				+void crcspeed64native_init(crcfn64 fn, uint64_t table[8][256]);
			
 
				+
			
 
				+uint64_t crcspeed64little(uint64_t table[8][256], uint64_t crc, void *buf,
			
 
				+                          size_t len);
			
 
				+uint64_t crcspeed64big(uint64_t table[8][256], uint64_t crc, void *buf,
			
 
				+                       size_t len);
			
 
				+uint64_t crcspeed64native(uint64_t table[8][256], uint64_t crc, void *buf,
			
 
				+                          size_t len);
			
 
				+
			
 
				+/* CRC-16 */
			
 
				+void crcspeed16little_init(crcfn16 fn, uint16_t table[8][256]);
			
 
				+void crcspeed16big_init(crcfn16 fn, uint16_t table[8][256]);
			
 
				+void crcspeed16native_init(crcfn16 fn, uint16_t table[8][256]);
			
 
				+
			
 
				+uint16_t crcspeed16little(uint16_t table[8][256], uint16_t crc, void *buf,
			
 
				+                          size_t len);
			
 
				+uint16_t crcspeed16big(uint16_t table[8][256], uint16_t crc, void *buf,
			
 
				+                       size_t len);
			
 
				+uint16_t crcspeed16native(uint16_t table[8][256], uint16_t crc, void *buf,
			
 
				+                          size_t len);
			
 
				+#endif
			
--- a/src/dict.c
+++ b/src/dict.c
@@ -0,0 +1,1326 @@
 
				+/* Hash Tables Implementation.
			
 
				+ *
			
 
				+ * This file implements in memory hash tables with insert/del/replace/find/
			
 
				+ * get-random-element operations. Hash tables will auto resize if needed
			
 
				+ * tables of power of two in size are used, collisions are handled by
			
 
				+ * chaining. See the source code for more information... :)
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+// #include "fmacros.h"
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <stdint.h>
			
 
				+#include <string.h>
			
 
				+#include <stdarg.h>
			
 
				+#include <limits.h>
			
 
				+#include <sys/time.h>
			
 
				+
			
 
				+#include "dict.h"
			
 
				+#include "zmalloc.h"
			
 
				+#include "redisassert.h"
			
 
				+
			
 
				+/* Using dictEnableResize() / dictDisableResize() we make possible to
			
 
				+ * enable/disable resizing of the hash table as needed. This is very important
			
 
				+ * for Redis, as we use copy-on-write and don't want to move too much memory
			
 
				+ * around when there is a child performing saving operations.
			
 
				+ *
			
 
				+ * Note that even when dict_can_resize is set to 0, not all resizes are
			
 
				+ * prevented: a hash table is still allowed to grow if the ratio between
			
 
				+ * the number of elements and the buckets > dict_force_resize_ratio. */
			
 
				+static int dict_can_resize = 1;
			
 
				+static unsigned int dict_force_resize_ratio = 5;
			
 
				+
			
 
				+/* -------------------------- private prototypes ---------------------------- */
			
 
				+
			
 
				+static int _dictExpandIfNeeded(dict *d);
			
 
				+static signed char _dictNextExp(unsigned long size);
			
 
				+static long _dictKeyIndex(dict *d, const void *key, uint64_t hash, dictEntry **existing);
			
 
				+static int _dictInit(dict *d, dictType *type);
			
 
				+
			
 
				+/* -------------------------- hash functions -------------------------------- */
			
 
				+
			
 
				+static uint8_t dict_hash_function_seed[16];
			
 
				+
			
 
				+void dictSetHashFunctionSeed(uint8_t *seed) {
			
 
				+    memcpy(dict_hash_function_seed,seed,sizeof(dict_hash_function_seed));
			
 
				+}
			
 
				+
			
 
				+uint8_t *dictGetHashFunctionSeed(void) {
			
 
				+    return dict_hash_function_seed;
			
 
				+}
			
 
				+
			
 
				+/* The default hashing function uses SipHash implementation
			
 
				+ * in siphash.c. */
			
 
				+
			
 
				+uint64_t siphash(const uint8_t *in, const size_t inlen, const uint8_t *k);
			
 
				+uint64_t siphash_nocase(const uint8_t *in, const size_t inlen, const uint8_t *k);
			
 
				+
			
 
				+uint64_t dictGenHashFunction(const void *key, int len) {
			
 
				+    return siphash(key,len,dict_hash_function_seed);
			
 
				+}
			
 
				+
			
 
				+uint64_t dictGenCaseHashFunction(const unsigned char *buf, int len) {
			
 
				+    return siphash_nocase(buf,len,dict_hash_function_seed);
			
 
				+}
			
 
				+
			
 
				+/* ----------------------------- API implementation ------------------------- */
			
 
				+
			
 
				+/* Reset a hash table already initialized with ht_init().
			
 
				+ * NOTE: This function should only be called by ht_destroy(). */
			
 
				+static void _dictReset(dict *d, int htidx)
			
 
				+{
			
 
				+    d->ht_table[htidx] = NULL;
			
 
				+    d->ht_size_exp[htidx] = -1;
			
 
				+    d->ht_used[htidx] = 0;
			
 
				+}
			
 
				+
			
 
				+/* Create a new hash table */
			
 
				+dict *dictCreate(dictType *type)
			
 
				+{
			
 
				+    dict *d = zmalloc(sizeof(*d));
			
 
				+
			
 
				+    _dictInit(d,type);
			
 
				+    return d;
			
 
				+}
			
 
				+
			
 
				+/* Initialize the hash table */
			
 
				+int _dictInit(dict *d, dictType *type)
			
 
				+{
			
 
				+    _dictReset(d, 0);
			
 
				+    _dictReset(d, 1);
			
 
				+    d->type = type;
			
 
				+    d->rehashidx = -1;
			
 
				+    d->pauserehash = 0;
			
 
				+    return DICT_OK;
			
 
				+}
			
 
				+
			
 
				+/* Resize the table to the minimal size that contains all the elements,
			
 
				+ * but with the invariant of a USED/BUCKETS ratio near to <= 1 */
			
 
				+int dictResize(dict *d)
			
 
				+{
			
 
				+    unsigned long minimal;
			
 
				+
			
 
				+    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
			
 
				+    minimal = d->ht_used[0];
			
 
				+    if (minimal < DICT_HT_INITIAL_SIZE)
			
 
				+        minimal = DICT_HT_INITIAL_SIZE;
			
 
				+    return dictExpand(d, minimal);
			
 
				+}
			
 
				+
			
 
				+/* Expand or create the hash table,
			
 
				+ * when malloc_failed is non-NULL, it'll avoid panic if malloc fails (in which case it'll be set to 1).
			
 
				+ * Returns DICT_OK if expand was performed, and DICT_ERR if skipped. */
			
 
				+int _dictExpand(dict *d, unsigned long size, int* malloc_failed)
			
 
				+{
			
 
				+    if (malloc_failed) *malloc_failed = 0;
			
 
				+
			
 
				+    /* the size is invalid if it is smaller than the number of
			
 
				+     * elements already inside the hash table */
			
 
				+    if (dictIsRehashing(d) || d->ht_used[0] > size)
			
 
				+        return DICT_ERR;
			
 
				+
			
 
				+    /* the new hash table */
			
 
				+    dictEntry **new_ht_table;
			
 
				+    unsigned long new_ht_used;
			
 
				+    signed char new_ht_size_exp = _dictNextExp(size);
			
 
				+
			
 
				+    /* Detect overflows */
			
 
				+    size_t newsize = 1ul<<new_ht_size_exp;
			
 
				+    if (newsize < size || newsize * sizeof(dictEntry*) < newsize)
			
 
				+        return DICT_ERR;
			
 
				+
			
 
				+    /* Rehashing to the same table size is not useful. */
			
 
				+    if (new_ht_size_exp == d->ht_size_exp[0]) return DICT_ERR;
			
 
				+
			
 
				+    /* Allocate the new hash table and initialize all pointers to NULL */
			
 
				+    if (malloc_failed) {
			
 
				+        new_ht_table = ztrycalloc(newsize*sizeof(dictEntry*));
			
 
				+        *malloc_failed = new_ht_table == NULL;
			
 
				+        if (*malloc_failed)
			
 
				+            return DICT_ERR;
			
 
				+    } else
			
 
				+        new_ht_table = zcalloc(newsize*sizeof(dictEntry*));
			
 
				+
			
 
				+    new_ht_used = 0;
			
 
				+
			
 
				+    /* Is this the first initialization? If so it's not really a rehashing
			
 
				+     * we just set the first hash table so that it can accept keys. */
			
 
				+    if (d->ht_table[0] == NULL) {
			
 
				+        d->ht_size_exp[0] = new_ht_size_exp;
			
 
				+        d->ht_used[0] = new_ht_used;
			
 
				+        d->ht_table[0] = new_ht_table;
			
 
				+        return DICT_OK;
			
 
				+    }
			
 
				+
			
 
				+    /* Prepare a second hash table for incremental rehashing */
			
 
				+    d->ht_size_exp[1] = new_ht_size_exp;
			
 
				+    d->ht_used[1] = new_ht_used;
			
 
				+    d->ht_table[1] = new_ht_table;
			
 
				+    d->rehashidx = 0;
			
 
				+    return DICT_OK;
			
 
				+}
			
 
				+
			
 
				+/* return DICT_ERR if expand was not performed */
			
 
				+int dictExpand(dict *d, unsigned long size) {
			
 
				+    return _dictExpand(d, size, NULL);
			
 
				+}
			
 
				+
			
 
				+/* return DICT_ERR if expand failed due to memory allocation failure */
			
 
				+int dictTryExpand(dict *d, unsigned long size) {
			
 
				+    int malloc_failed;
			
 
				+    _dictExpand(d, size, &malloc_failed);
			
 
				+    return malloc_failed? DICT_ERR : DICT_OK;
			
 
				+}
			
 
				+
			
 
				+/* Performs N steps of incremental rehashing. Returns 1 if there are still
			
 
				+ * keys to move from the old to the new hash table, otherwise 0 is returned.
			
 
				+ *
			
 
				+ * Note that a rehashing step consists in moving a bucket (that may have more
			
 
				+ * than one key as we use chaining) from the old to the new hash table, however
			
 
				+ * since part of the hash table may be composed of empty spaces, it is not
			
 
				+ * guaranteed that this function will rehash even a single bucket, since it
			
 
				+ * will visit at max N*10 empty buckets in total, otherwise the amount of
			
 
				+ * work it does would be unbound and the function may block for a long time. */
			
 
				+int dictRehash(dict *d, int n) {
			
 
				+    int empty_visits = n*10; /* Max number of empty buckets to visit. */
			
 
				+    if (!dictIsRehashing(d)) return 0;
			
 
				+
			
 
				+    while(n-- && d->ht_used[0] != 0) {
			
 
				+        dictEntry *de, *nextde;
			
 
				+
			
 
				+        /* Note that rehashidx can't overflow as we are sure there are more
			
 
				+         * elements because ht[0].used != 0 */
			
 
				+        assert(DICTHT_SIZE(d->ht_size_exp[0]) > (unsigned long)d->rehashidx);
			
 
				+        while(d->ht_table[0][d->rehashidx] == NULL) {
			
 
				+            d->rehashidx++;
			
 
				+            if (--empty_visits == 0) return 1;
			
 
				+        }
			
 
				+        de = d->ht_table[0][d->rehashidx];
			
 
				+        /* Move all the keys in this bucket from the old to the new hash HT */
			
 
				+        while(de) {
			
 
				+            uint64_t h;
			
 
				+
			
 
				+            nextde = de->next;
			
 
				+            /* Get the index in the new hash table */
			
 
				+            h = dictHashKey(d, de->key) & DICTHT_SIZE_MASK(d->ht_size_exp[1]);
			
 
				+            de->next = d->ht_table[1][h];
			
 
				+            d->ht_table[1][h] = de;
			
 
				+            d->ht_used[0]--;
			
 
				+            d->ht_used[1]++;
			
 
				+            de = nextde;
			
 
				+        }
			
 
				+        d->ht_table[0][d->rehashidx] = NULL;
			
 
				+        d->rehashidx++;
			
 
				+    }
			
 
				+
			
 
				+    /* Check if we already rehashed the whole table... */
			
 
				+    if (d->ht_used[0] == 0) {
			
 
				+        zfree(d->ht_table[0]);
			
 
				+        /* Copy the new ht onto the old one */
			
 
				+        d->ht_table[0] = d->ht_table[1];
			
 
				+        d->ht_used[0] = d->ht_used[1];
			
 
				+        d->ht_size_exp[0] = d->ht_size_exp[1];
			
 
				+        _dictReset(d, 1);
			
 
				+        d->rehashidx = -1;
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    /* More to rehash... */
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+long long timeInMilliseconds(void) {
			
 
				+    struct timeval tv;
			
 
				+
			
 
				+    gettimeofday(&tv,NULL);
			
 
				+    return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000);
			
 
				+}
			
 
				+
			
 
				+/* Rehash in ms+"delta" milliseconds. The value of "delta" is larger 
			
 
				+ * than 0, and is smaller than 1 in most cases. The exact upper bound 
			
 
				+ * depends on the running time of dictRehash(d,100).*/
			
 
				+int dictRehashMilliseconds(dict *d, int ms) {
			
 
				+    if (d->pauserehash > 0) return 0;
			
 
				+
			
 
				+    long long start = timeInMilliseconds();
			
 
				+    int rehashes = 0;
			
 
				+
			
 
				+    while(dictRehash(d,100)) {
			
 
				+        rehashes += 100;
			
 
				+        if (timeInMilliseconds()-start > ms) break;
			
 
				+    }
			
 
				+    return rehashes;
			
 
				+}
			
 
				+
			
 
				+/* This function performs just a step of rehashing, and only if hashing has
			
 
				+ * not been paused for our hash table. When we have iterators in the
			
 
				+ * middle of a rehashing we can't mess with the two hash tables otherwise
			
 
				+ * some element can be missed or duplicated.
			
 
				+ *
			
 
				+ * This function is called by common lookup or update operations in the
			
 
				+ * dictionary so that the hash table automatically migrates from H1 to H2
			
 
				+ * while it is actively used. */
			
 
				+static void _dictRehashStep(dict *d) {
			
 
				+    if (d->pauserehash == 0) dictRehash(d,1);
			
 
				+}
			
 
				+
			
 
				+/* Add an element to the target hash table */
			
 
				+int dictAdd(dict *d, void *key, void *val)
			
 
				+{
			
 
				+    dictEntry *entry = dictAddRaw(d,key,NULL);
			
 
				+
			
 
				+    if (!entry) return DICT_ERR;
			
 
				+    dictSetVal(d, entry, val);
			
 
				+    return DICT_OK;
			
 
				+}
			
 
				+
			
 
				+/* Low level add or find:
			
 
				+ * This function adds the entry but instead of setting a value returns the
			
 
				+ * dictEntry structure to the user, that will make sure to fill the value
			
 
				+ * field as they wish.
			
 
				+ *
			
 
				+ * This function is also directly exposed to the user API to be called
			
 
				+ * mainly in order to store non-pointers inside the hash value, example:
			
 
				+ *
			
 
				+ * entry = dictAddRaw(dict,mykey,NULL);
			
 
				+ * if (entry != NULL) dictSetSignedIntegerVal(entry,1000);
			
 
				+ *
			
 
				+ * Return values:
			
 
				+ *
			
 
				+ * If key already exists NULL is returned, and "*existing" is populated
			
 
				+ * with the existing entry if existing is not NULL.
			
 
				+ *
			
 
				+ * If key was added, the hash entry is returned to be manipulated by the caller.
			
 
				+ */
			
 
				+dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
			
 
				+{
			
 
				+    long index;
			
 
				+    dictEntry *entry;
			
 
				+    int htidx;
			
 
				+
			
 
				+    if (dictIsRehashing(d)) _dictRehashStep(d);
			
 
				+
			
 
				+    /* Get the index of the new element, or -1 if
			
 
				+     * the element already exists. */
			
 
				+    if ((index = _dictKeyIndex(d, key, dictHashKey(d,key), existing)) == -1)
			
 
				+        return NULL;
			
 
				+
			
 
				+    /* Allocate the memory and store the new entry.
			
 
				+     * Insert the element in top, with the assumption that in a database
			
 
				+     * system it is more likely that recently added entries are accessed
			
 
				+     * more frequently. */
			
 
				+    htidx = dictIsRehashing(d) ? 1 : 0;
			
 
				+    size_t metasize = dictMetadataSize(d);
			
 
				+    entry = zmalloc(sizeof(*entry) + metasize);
			
 
				+    if (metasize > 0) {
			
 
				+        memset(dictMetadata(entry), 0, metasize);
			
 
				+    }
			
 
				+    entry->next = d->ht_table[htidx][index];
			
 
				+    d->ht_table[htidx][index] = entry;
			
 
				+    d->ht_used[htidx]++;
			
 
				+
			
 
				+    /* Set the hash entry fields. */
			
 
				+    dictSetKey(d, entry, key);
			
 
				+    return entry;
			
 
				+}
			
 
				+
			
 
				+/* Add or Overwrite:
			
 
				+ * Add an element, discarding the old value if the key already exists.
			
 
				+ * Return 1 if the key was added from scratch, 0 if there was already an
			
 
				+ * element with such key and dictReplace() just performed a value update
			
 
				+ * operation. */
			
 
				+int dictReplace(dict *d, void *key, void *val)
			
 
				+{
			
 
				+    dictEntry *entry, *existing, auxentry;
			
 
				+
			
 
				+    /* Try to add the element. If the key
			
 
				+     * does not exists dictAdd will succeed. */
			
 
				+    entry = dictAddRaw(d,key,&existing);
			
 
				+    if (entry) {
			
 
				+        dictSetVal(d, entry, val);
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Set the new value and free the old one. Note that it is important
			
 
				+     * to do that in this order, as the value may just be exactly the same
			
 
				+     * as the previous one. In this context, think to reference counting,
			
 
				+     * you want to increment (set), and then decrement (free), and not the
			
 
				+     * reverse. */
			
 
				+    auxentry = *existing;
			
 
				+    dictSetVal(d, existing, val);
			
 
				+    dictFreeVal(d, &auxentry);
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Add or Find:
			
 
				+ * dictAddOrFind() is simply a version of dictAddRaw() that always
			
 
				+ * returns the hash entry of the specified key, even if the key already
			
 
				+ * exists and can't be added (in that case the entry of the already
			
 
				+ * existing key is returned.)
			
 
				+ *
			
 
				+ * See dictAddRaw() for more information. */
			
 
				+dictEntry *dictAddOrFind(dict *d, void *key) {
			
 
				+    dictEntry *entry, *existing;
			
 
				+    entry = dictAddRaw(d,key,&existing);
			
 
				+    return entry ? entry : existing;
			
 
				+}
			
 
				+
			
 
				+/* Search and remove an element. This is a helper function for
			
 
				+ * dictDelete() and dictUnlink(), please check the top comment
			
 
				+ * of those functions. */
			
 
				+static dictEntry *dictGenericDelete(dict *d, const void *key, int nofree) {
			
 
				+    uint64_t h, idx;
			
 
				+    dictEntry *he, *prevHe;
			
 
				+    int table;
			
 
				+
			
 
				+    /* dict is empty */
			
 
				+    if (dictSize(d) == 0) return NULL;
			
 
				+
			
 
				+    if (dictIsRehashing(d)) _dictRehashStep(d);
			
 
				+    h = dictHashKey(d, key);
			
 
				+
			
 
				+    for (table = 0; table <= 1; table++) {
			
 
				+        idx = h & DICTHT_SIZE_MASK(d->ht_size_exp[table]);
			
 
				+        he = d->ht_table[table][idx];
			
 
				+        prevHe = NULL;
			
 
				+        while(he) {
			
 
				+            if (key==he->key || dictCompareKeys(d, key, he->key)) {
			
 
				+                /* Unlink the element from the list */
			
 
				+                if (prevHe)
			
 
				+                    prevHe->next = he->next;
			
 
				+                else
			
 
				+                    d->ht_table[table][idx] = he->next;
			
 
				+                if (!nofree) {
			
 
				+                    dictFreeUnlinkedEntry(d, he);
			
 
				+                }
			
 
				+                d->ht_used[table]--;
			
 
				+                return he;
			
 
				+            }
			
 
				+            prevHe = he;
			
 
				+            he = he->next;
			
 
				+        }
			
 
				+        if (!dictIsRehashing(d)) break;
			
 
				+    }
			
 
				+    return NULL; /* not found */
			
 
				+}
			
 
				+
			
 
				+/* Remove an element, returning DICT_OK on success or DICT_ERR if the
			
 
				+ * element was not found. */
			
 
				+int dictDelete(dict *ht, const void *key) {
			
 
				+    return dictGenericDelete(ht,key,0) ? DICT_OK : DICT_ERR;
			
 
				+}
			
 
				+
			
 
				+/* Remove an element from the table, but without actually releasing
			
 
				+ * the key, value and dictionary entry. The dictionary entry is returned
			
 
				+ * if the element was found (and unlinked from the table), and the user
			
 
				+ * should later call `dictFreeUnlinkedEntry()` with it in order to release it.
			
 
				+ * Otherwise if the key is not found, NULL is returned.
			
 
				+ *
			
 
				+ * This function is useful when we want to remove something from the hash
			
 
				+ * table but want to use its value before actually deleting the entry.
			
 
				+ * Without this function the pattern would require two lookups:
			
 
				+ *
			
 
				+ *  entry = dictFind(...);
			
 
				+ *  // Do something with entry
			
 
				+ *  dictDelete(dictionary,entry);
			
 
				+ *
			
 
				+ * Thanks to this function it is possible to avoid this, and use
			
 
				+ * instead:
			
 
				+ *
			
 
				+ * entry = dictUnlink(dictionary,entry);
			
 
				+ * // Do something with entry
			
 
				+ * dictFreeUnlinkedEntry(entry); // <- This does not need to lookup again.
			
 
				+ */
			
 
				+dictEntry *dictUnlink(dict *d, const void *key) {
			
 
				+    return dictGenericDelete(d,key,1);
			
 
				+}
			
 
				+
			
 
				+/* You need to call this function to really free the entry after a call
			
 
				+ * to dictUnlink(). It's safe to call this function with 'he' = NULL. */
			
 
				+void dictFreeUnlinkedEntry(dict *d, dictEntry *he) {
			
 
				+    if (he == NULL) return;
			
 
				+    dictFreeKey(d, he);
			
 
				+    dictFreeVal(d, he);
			
 
				+    zfree(he);
			
 
				+}
			
 
				+
			
 
				+/* Destroy an entire dictionary */
			
 
				+int _dictClear(dict *d, int htidx, void(callback)(dict*)) {
			
 
				+    unsigned long i;
			
 
				+
			
 
				+    /* Free all the elements */
			
 
				+    for (i = 0; i < DICTHT_SIZE(d->ht_size_exp[htidx]) && d->ht_used[htidx] > 0; i++) {
			
 
				+        dictEntry *he, *nextHe;
			
 
				+
			
 
				+        if (callback && (i & 65535) == 0) callback(d);
			
 
				+
			
 
				+        if ((he = d->ht_table[htidx][i]) == NULL) continue;
			
 
				+        while(he) {
			
 
				+            nextHe = he->next;
			
 
				+            dictFreeKey(d, he);
			
 
				+            dictFreeVal(d, he);
			
 
				+            zfree(he);
			
 
				+            d->ht_used[htidx]--;
			
 
				+            he = nextHe;
			
 
				+        }
			
 
				+    }
			
 
				+    /* Free the table and the allocated cache structure */
			
 
				+    zfree(d->ht_table[htidx]);
			
 
				+    /* Re-initialize the table */
			
 
				+    _dictReset(d, htidx);
			
 
				+    return DICT_OK; /* never fails */
			
 
				+}
			
 
				+
			
 
				+/* Clear & Release the hash table */
			
 
				+void dictRelease(dict *d)
			
 
				+{
			
 
				+    _dictClear(d,0,NULL);
			
 
				+    _dictClear(d,1,NULL);
			
 
				+    zfree(d);
			
 
				+}
			
 
				+
			
 
				+dictEntry *dictFind(dict *d, const void *key)
			
 
				+{
			
 
				+    dictEntry *he;
			
 
				+    uint64_t h, idx, table;
			
 
				+
			
 
				+    if (dictSize(d) == 0) return NULL; /* dict is empty */
			
 
				+    if (dictIsRehashing(d)) _dictRehashStep(d);
			
 
				+    h = dictHashKey(d, key);
			
 
				+    for (table = 0; table <= 1; table++) {
			
 
				+        idx = h & DICTHT_SIZE_MASK(d->ht_size_exp[table]);
			
 
				+        he = d->ht_table[table][idx];
			
 
				+        while(he) {
			
 
				+            if (key==he->key || dictCompareKeys(d, key, he->key))
			
 
				+                return he;
			
 
				+            he = he->next;
			
 
				+        }
			
 
				+        if (!dictIsRehashing(d)) return NULL;
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+void *dictFetchValue(dict *d, const void *key) {
			
 
				+    dictEntry *he;
			
 
				+
			
 
				+    he = dictFind(d,key);
			
 
				+    return he ? dictGetVal(he) : NULL;
			
 
				+}
			
 
				+
			
 
				+/* A fingerprint is a 64 bit number that represents the state of the dictionary
			
 
				+ * at a given time, it's just a few dict properties xored together.
			
 
				+ * When an unsafe iterator is initialized, we get the dict fingerprint, and check
			
 
				+ * the fingerprint again when the iterator is released.
			
 
				+ * If the two fingerprints are different it means that the user of the iterator
			
 
				+ * performed forbidden operations against the dictionary while iterating. */
			
 
				+unsigned long long dictFingerprint(dict *d) {
			
 
				+    unsigned long long integers[6], hash = 0;
			
 
				+    int j;
			
 
				+
			
 
				+    integers[0] = (long) d->ht_table[0];
			
 
				+    integers[1] = d->ht_size_exp[0];
			
 
				+    integers[2] = d->ht_used[0];
			
 
				+    integers[3] = (long) d->ht_table[1];
			
 
				+    integers[4] = d->ht_size_exp[1];
			
 
				+    integers[5] = d->ht_used[1];
			
 
				+
			
 
				+    /* We hash N integers by summing every successive integer with the integer
			
 
				+     * hashing of the previous sum. Basically:
			
 
				+     *
			
 
				+     * Result = hash(hash(hash(int1)+int2)+int3) ...
			
 
				+     *
			
 
				+     * This way the same set of integers in a different order will (likely) hash
			
 
				+     * to a different number. */
			
 
				+    for (j = 0; j < 6; j++) {
			
 
				+        hash += integers[j];
			
 
				+        /* For the hashing step we use Tomas Wang's 64 bit integer hash. */
			
 
				+        hash = (~hash) + (hash << 21); // hash = (hash << 21) - hash - 1;
			
 
				+        hash = hash ^ (hash >> 24);
			
 
				+        hash = (hash + (hash << 3)) + (hash << 8); // hash * 265
			
 
				+        hash = hash ^ (hash >> 14);
			
 
				+        hash = (hash + (hash << 2)) + (hash << 4); // hash * 21
			
 
				+        hash = hash ^ (hash >> 28);
			
 
				+        hash = hash + (hash << 31);
			
 
				+    }
			
 
				+    return hash;
			
 
				+}
			
 
				+
			
 
				+dictIterator *dictGetIterator(dict *d)
			
 
				+{
			
 
				+    dictIterator *iter = zmalloc(sizeof(*iter));
			
 
				+
			
 
				+    iter->d = d;
			
 
				+    iter->table = 0;
			
 
				+    iter->index = -1;
			
 
				+    iter->safe = 0;
			
 
				+    iter->entry = NULL;
			
 
				+    iter->nextEntry = NULL;
			
 
				+    return iter;
			
 
				+}
			
 
				+
			
 
				+dictIterator *dictGetSafeIterator(dict *d) {
			
 
				+    dictIterator *i = dictGetIterator(d);
			
 
				+
			
 
				+    i->safe = 1;
			
 
				+    return i;
			
 
				+}
			
 
				+
			
 
				+dictEntry *dictNext(dictIterator *iter)
			
 
				+{
			
 
				+    while (1) {
			
 
				+        if (iter->entry == NULL) {
			
 
				+            if (iter->index == -1 && iter->table == 0) {
			
 
				+                if (iter->safe)
			
 
				+                    dictPauseRehashing(iter->d);
			
 
				+                else
			
 
				+                    iter->fingerprint = dictFingerprint(iter->d);
			
 
				+            }
			
 
				+            iter->index++;
			
 
				+            if (iter->index >= (long) DICTHT_SIZE(iter->d->ht_size_exp[iter->table])) {
			
 
				+                if (dictIsRehashing(iter->d) && iter->table == 0) {
			
 
				+                    iter->table++;
			
 
				+                    iter->index = 0;
			
 
				+                } else {
			
 
				+                    break;
			
 
				+                }
			
 
				+            }
			
 
				+            iter->entry = iter->d->ht_table[iter->table][iter->index];
			
 
				+        } else {
			
 
				+            iter->entry = iter->nextEntry;
			
 
				+        }
			
 
				+        if (iter->entry) {
			
 
				+            /* We need to save the 'next' here, the iterator user
			
 
				+             * may delete the entry we are returning. */
			
 
				+            iter->nextEntry = iter->entry->next;
			
 
				+            return iter->entry;
			
 
				+        }
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+void dictReleaseIterator(dictIterator *iter)
			
 
				+{
			
 
				+    if (!(iter->index == -1 && iter->table == 0)) {
			
 
				+        if (iter->safe)
			
 
				+            dictResumeRehashing(iter->d);
			
 
				+        else
			
 
				+            assert(iter->fingerprint == dictFingerprint(iter->d));
			
 
				+    }
			
 
				+    zfree(iter);
			
 
				+}
			
 
				+
			
 
				+/* Return a random entry from the hash table. Useful to
			
 
				+ * implement randomized algorithms */
			
 
				+dictEntry *dictGetRandomKey(dict *d)
			
 
				+{
			
 
				+    dictEntry *he, *orighe;
			
 
				+    unsigned long h;
			
 
				+    int listlen, listele;
			
 
				+
			
 
				+    if (dictSize(d) == 0) return NULL;
			
 
				+    if (dictIsRehashing(d)) _dictRehashStep(d);
			
 
				+    if (dictIsRehashing(d)) {
			
 
				+        unsigned long s0 = DICTHT_SIZE(d->ht_size_exp[0]);
			
 
				+        do {
			
 
				+            /* We are sure there are no elements in indexes from 0
			
 
				+             * to rehashidx-1 */
			
 
				+            h = d->rehashidx + (randomULong() % (dictSlots(d) - d->rehashidx));
			
 
				+            he = (h >= s0) ? d->ht_table[1][h - s0] : d->ht_table[0][h];
			
 
				+        } while(he == NULL);
			
 
				+    } else {
			
 
				+        unsigned long m = DICTHT_SIZE_MASK(d->ht_size_exp[0]);
			
 
				+        do {
			
 
				+            h = randomULong() & m;
			
 
				+            he = d->ht_table[0][h];
			
 
				+        } while(he == NULL);
			
 
				+    }
			
 
				+
			
 
				+    /* Now we found a non empty bucket, but it is a linked
			
 
				+     * list and we need to get a random element from the list.
			
 
				+     * The only sane way to do so is counting the elements and
			
 
				+     * select a random index. */
			
 
				+    listlen = 0;
			
 
				+    orighe = he;
			
 
				+    while(he) {
			
 
				+        he = he->next;
			
 
				+        listlen++;
			
 
				+    }
			
 
				+    listele = random() % listlen;
			
 
				+    he = orighe;
			
 
				+    while(listele--) he = he->next;
			
 
				+    return he;
			
 
				+}
			
 
				+
			
 
				+/* This function samples the dictionary to return a few keys from random
			
 
				+ * locations.
			
 
				+ *
			
 
				+ * It does not guarantee to return all the keys specified in 'count', nor
			
 
				+ * it does guarantee to return non-duplicated elements, however it will make
			
 
				+ * some effort to do both things.
			
 
				+ *
			
 
				+ * Returned pointers to hash table entries are stored into 'des' that
			
 
				+ * points to an array of dictEntry pointers. The array must have room for
			
 
				+ * at least 'count' elements, that is the argument we pass to the function
			
 
				+ * to tell how many random elements we need.
			
 
				+ *
			
 
				+ * The function returns the number of items stored into 'des', that may
			
 
				+ * be less than 'count' if the hash table has less than 'count' elements
			
 
				+ * inside, or if not enough elements were found in a reasonable amount of
			
 
				+ * steps.
			
 
				+ *
			
 
				+ * Note that this function is not suitable when you need a good distribution
			
 
				+ * of the returned items, but only when you need to "sample" a given number
			
 
				+ * of continuous elements to run some kind of algorithm or to produce
			
 
				+ * statistics. However the function is much faster than dictGetRandomKey()
			
 
				+ * at producing N elements. */
			
 
				+unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count) {
			
 
				+    unsigned long j; /* internal hash table id, 0 or 1. */
			
 
				+    unsigned long tables; /* 1 or 2 tables? */
			
 
				+    unsigned long stored = 0, maxsizemask;
			
 
				+    unsigned long maxsteps;
			
 
				+
			
 
				+    if (dictSize(d) < count) count = dictSize(d);
			
 
				+    maxsteps = count*10;
			
 
				+
			
 
				+    /* Try to do a rehashing work proportional to 'count'. */
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        if (dictIsRehashing(d))
			
 
				+            _dictRehashStep(d);
			
 
				+        else
			
 
				+            break;
			
 
				+    }
			
 
				+
			
 
				+    tables = dictIsRehashing(d) ? 2 : 1;
			
 
				+    maxsizemask = DICTHT_SIZE_MASK(d->ht_size_exp[0]);
			
 
				+    if (tables > 1 && maxsizemask < DICTHT_SIZE_MASK(d->ht_size_exp[1]))
			
 
				+        maxsizemask = DICTHT_SIZE_MASK(d->ht_size_exp[1]);
			
 
				+
			
 
				+    /* Pick a random point inside the larger table. */
			
 
				+    unsigned long i = randomULong() & maxsizemask;
			
 
				+    unsigned long emptylen = 0; /* Continuous empty entries so far. */
			
 
				+    while(stored < count && maxsteps--) {
			
 
				+        for (j = 0; j < tables; j++) {
			
 
				+            /* Invariant of the dict.c rehashing: up to the indexes already
			
 
				+             * visited in ht[0] during the rehashing, there are no populated
			
 
				+             * buckets, so we can skip ht[0] for indexes between 0 and idx-1. */
			
 
				+            if (tables == 2 && j == 0 && i < (unsigned long) d->rehashidx) {
			
 
				+                /* Moreover, if we are currently out of range in the second
			
 
				+                 * table, there will be no elements in both tables up to
			
 
				+                 * the current rehashing index, so we jump if possible.
			
 
				+                 * (this happens when going from big to small table). */
			
 
				+                if (i >= DICTHT_SIZE(d->ht_size_exp[1]))
			
 
				+                    i = d->rehashidx;
			
 
				+                else
			
 
				+                    continue;
			
 
				+            }
			
 
				+            if (i >= DICTHT_SIZE(d->ht_size_exp[j])) continue; /* Out of range for this table. */
			
 
				+            dictEntry *he = d->ht_table[j][i];
			
 
				+
			
 
				+            /* Count contiguous empty buckets, and jump to other
			
 
				+             * locations if they reach 'count' (with a minimum of 5). */
			
 
				+            if (he == NULL) {
			
 
				+                emptylen++;
			
 
				+                if (emptylen >= 5 && emptylen > count) {
			
 
				+                    i = randomULong() & maxsizemask;
			
 
				+                    emptylen = 0;
			
 
				+                }
			
 
				+            } else {
			
 
				+                emptylen = 0;
			
 
				+                while (he) {
			
 
				+                    /* Collect all the elements of the buckets found non
			
 
				+                     * empty while iterating. */
			
 
				+                    *des = he;
			
 
				+                    des++;
			
 
				+                    he = he->next;
			
 
				+                    stored++;
			
 
				+                    if (stored == count) return stored;
			
 
				+                }
			
 
				+            }
			
 
				+        }
			
 
				+        i = (i+1) & maxsizemask;
			
 
				+    }
			
 
				+    return stored;
			
 
				+}
			
 
				+
			
 
				+/* This is like dictGetRandomKey() from the POV of the API, but will do more
			
 
				+ * work to ensure a better distribution of the returned element.
			
 
				+ *
			
 
				+ * This function improves the distribution because the dictGetRandomKey()
			
 
				+ * problem is that it selects a random bucket, then it selects a random
			
 
				+ * element from the chain in the bucket. However elements being in different
			
 
				+ * chain lengths will have different probabilities of being reported. With
			
 
				+ * this function instead what we do is to consider a "linear" range of the table
			
 
				+ * that may be constituted of N buckets with chains of different lengths
			
 
				+ * appearing one after the other. Then we report a random element in the range.
			
 
				+ * In this way we smooth away the problem of different chain lengths. */
			
 
				+#define GETFAIR_NUM_ENTRIES 15
			
 
				+dictEntry *dictGetFairRandomKey(dict *d) {
			
 
				+    dictEntry *entries[GETFAIR_NUM_ENTRIES];
			
 
				+    unsigned int count = dictGetSomeKeys(d,entries,GETFAIR_NUM_ENTRIES);
			
 
				+    /* Note that dictGetSomeKeys() may return zero elements in an unlucky
			
 
				+     * run() even if there are actually elements inside the hash table. So
			
 
				+     * when we get zero, we call the true dictGetRandomKey() that will always
			
 
				+     * yield the element if the hash table has at least one. */
			
 
				+    if (count == 0) return dictGetRandomKey(d);
			
 
				+    unsigned int idx = rand() % count;
			
 
				+    return entries[idx];
			
 
				+}
			
 
				+
			
 
				+/* Function to reverse bits. Algorithm from:
			
 
				+ * http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */
			
 
				+static unsigned long rev(unsigned long v) {
			
 
				+    unsigned long s = CHAR_BIT * sizeof(v); // bit size; must be power of 2
			
 
				+    unsigned long mask = ~0UL;
			
 
				+    while ((s >>= 1) > 0) {
			
 
				+        mask ^= (mask << s);
			
 
				+        v = ((v >> s) & mask) | ((v << s) & ~mask);
			
 
				+    }
			
 
				+    return v;
			
 
				+}
			
 
				+
			
 
				+/* dictScan() is used to iterate over the elements of a dictionary.
			
 
				+ *
			
 
				+ * Iterating works the following way:
			
 
				+ *
			
 
				+ * 1) Initially you call the function using a cursor (v) value of 0.
			
 
				+ * 2) The function performs one step of the iteration, and returns the
			
 
				+ *    new cursor value you must use in the next call.
			
 
				+ * 3) When the returned cursor is 0, the iteration is complete.
			
 
				+ *
			
 
				+ * The function guarantees all elements present in the
			
 
				+ * dictionary get returned between the start and end of the iteration.
			
 
				+ * However it is possible some elements get returned multiple times.
			
 
				+ *
			
 
				+ * For every element returned, the callback argument 'fn' is
			
 
				+ * called with 'privdata' as first argument and the dictionary entry
			
 
				+ * 'de' as second argument.
			
 
				+ *
			
 
				+ * HOW IT WORKS.
			
 
				+ *
			
 
				+ * The iteration algorithm was designed by Pieter Noordhuis.
			
 
				+ * The main idea is to increment a cursor starting from the higher order
			
 
				+ * bits. That is, instead of incrementing the cursor normally, the bits
			
 
				+ * of the cursor are reversed, then the cursor is incremented, and finally
			
 
				+ * the bits are reversed again.
			
 
				+ *
			
 
				+ * This strategy is needed because the hash table may be resized between
			
 
				+ * iteration calls.
			
 
				+ *
			
 
				+ * dict.c hash tables are always power of two in size, and they
			
 
				+ * use chaining, so the position of an element in a given table is given
			
 
				+ * by computing the bitwise AND between Hash(key) and SIZE-1
			
 
				+ * (where SIZE-1 is always the mask that is equivalent to taking the rest
			
 
				+ *  of the division between the Hash of the key and SIZE).
			
 
				+ *
			
 
				+ * For example if the current hash table size is 16, the mask is
			
 
				+ * (in binary) 1111. The position of a key in the hash table will always be
			
 
				+ * the last four bits of the hash output, and so forth.
			
 
				+ *
			
 
				+ * WHAT HAPPENS IF THE TABLE CHANGES IN SIZE?
			
 
				+ *
			
 
				+ * If the hash table grows, elements can go anywhere in one multiple of
			
 
				+ * the old bucket: for example let's say we already iterated with
			
 
				+ * a 4 bit cursor 1100 (the mask is 1111 because hash table size = 16).
			
 
				+ *
			
 
				+ * If the hash table will be resized to 64 elements, then the new mask will
			
 
				+ * be 111111. The new buckets you obtain by substituting in ??1100
			
 
				+ * with either 0 or 1 can be targeted only by keys we already visited
			
 
				+ * when scanning the bucket 1100 in the smaller hash table.
			
 
				+ *
			
 
				+ * By iterating the higher bits first, because of the inverted counter, the
			
 
				+ * cursor does not need to restart if the table size gets bigger. It will
			
 
				+ * continue iterating using cursors without '1100' at the end, and also
			
 
				+ * without any other combination of the final 4 bits already explored.
			
 
				+ *
			
 
				+ * Similarly when the table size shrinks over time, for example going from
			
 
				+ * 16 to 8, if a combination of the lower three bits (the mask for size 8
			
 
				+ * is 111) were already completely explored, it would not be visited again
			
 
				+ * because we are sure we tried, for example, both 0111 and 1111 (all the
			
 
				+ * variations of the higher bit) so we don't need to test it again.
			
 
				+ *
			
 
				+ * WAIT... YOU HAVE *TWO* TABLES DURING REHASHING!
			
 
				+ *
			
 
				+ * Yes, this is true, but we always iterate the smaller table first, then
			
 
				+ * we test all the expansions of the current cursor into the larger
			
 
				+ * table. For example if the current cursor is 101 and we also have a
			
 
				+ * larger table of size 16, we also test (0)101 and (1)101 inside the larger
			
 
				+ * table. This reduces the problem back to having only one table, where
			
 
				+ * the larger one, if it exists, is just an expansion of the smaller one.
			
 
				+ *
			
 
				+ * LIMITATIONS
			
 
				+ *
			
 
				+ * This iterator is completely stateless, and this is a huge advantage,
			
 
				+ * including no additional memory used.
			
 
				+ *
			
 
				+ * The disadvantages resulting from this design are:
			
 
				+ *
			
 
				+ * 1) It is possible we return elements more than once. However this is usually
			
 
				+ *    easy to deal with in the application level.
			
 
				+ * 2) The iterator must return multiple elements per call, as it needs to always
			
 
				+ *    return all the keys chained in a given bucket, and all the expansions, so
			
 
				+ *    we are sure we don't miss keys moving during rehashing.
			
 
				+ * 3) The reverse cursor is somewhat hard to understand at first, but this
			
 
				+ *    comment is supposed to help.
			
 
				+ */
			
 
				+unsigned long dictScan(dict *d,
			
 
				+                       unsigned long v,
			
 
				+                       dictScanFunction *fn,
			
 
				+                       dictScanBucketFunction* bucketfn,
			
 
				+                       void *privdata)
			
 
				+{
			
 
				+    int htidx0, htidx1;
			
 
				+    const dictEntry *de, *next;
			
 
				+    unsigned long m0, m1;
			
 
				+
			
 
				+    if (dictSize(d) == 0) return 0;
			
 
				+
			
 
				+    /* This is needed in case the scan callback tries to do dictFind or alike. */
			
 
				+    dictPauseRehashing(d);
			
 
				+
			
 
				+    if (!dictIsRehashing(d)) {
			
 
				+        htidx0 = 0;
			
 
				+        m0 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx0]);
			
 
				+
			
 
				+        /* Emit entries at cursor */
			
 
				+        if (bucketfn) bucketfn(d, &d->ht_table[htidx0][v & m0]);
			
 
				+        de = d->ht_table[htidx0][v & m0];
			
 
				+        while (de) {
			
 
				+            next = de->next;
			
 
				+            fn(privdata, de);
			
 
				+            de = next;
			
 
				+        }
			
 
				+
			
 
				+        /* Set unmasked bits so incrementing the reversed cursor
			
 
				+         * operates on the masked bits */
			
 
				+        v |= ~m0;
			
 
				+
			
 
				+        /* Increment the reverse cursor */
			
 
				+        v = rev(v);
			
 
				+        v++;
			
 
				+        v = rev(v);
			
 
				+
			
 
				+    } else {
			
 
				+        htidx0 = 0;
			
 
				+        htidx1 = 1;
			
 
				+
			
 
				+        /* Make sure t0 is the smaller and t1 is the bigger table */
			
 
				+        if (DICTHT_SIZE(d->ht_size_exp[htidx0]) > DICTHT_SIZE(d->ht_size_exp[htidx1])) {
			
 
				+            htidx0 = 1;
			
 
				+            htidx1 = 0;
			
 
				+        }
			
 
				+
			
 
				+        m0 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx0]);
			
 
				+        m1 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx1]);
			
 
				+
			
 
				+        /* Emit entries at cursor */
			
 
				+        if (bucketfn) bucketfn(d, &d->ht_table[htidx0][v & m0]);
			
 
				+        de = d->ht_table[htidx0][v & m0];
			
 
				+        while (de) {
			
 
				+            next = de->next;
			
 
				+            fn(privdata, de);
			
 
				+            de = next;
			
 
				+        }
			
 
				+
			
 
				+        /* Iterate over indices in larger table that are the expansion
			
 
				+         * of the index pointed to by the cursor in the smaller table */
			
 
				+        do {
			
 
				+            /* Emit entries at cursor */
			
 
				+            if (bucketfn) bucketfn(d, &d->ht_table[htidx1][v & m1]);
			
 
				+            de = d->ht_table[htidx1][v & m1];
			
 
				+            while (de) {
			
 
				+                next = de->next;
			
 
				+                fn(privdata, de);
			
 
				+                de = next;
			
 
				+            }
			
 
				+
			
 
				+            /* Increment the reverse cursor not covered by the smaller mask.*/
			
 
				+            v |= ~m1;
			
 
				+            v = rev(v);
			
 
				+            v++;
			
 
				+            v = rev(v);
			
 
				+
			
 
				+            /* Continue while bits covered by mask difference is non-zero */
			
 
				+        } while (v & (m0 ^ m1));
			
 
				+    }
			
 
				+
			
 
				+    dictResumeRehashing(d);
			
 
				+
			
 
				+    return v;
			
 
				+}
			
 
				+
			
 
				+/* ------------------------- private functions ------------------------------ */
			
 
				+
			
 
				+/* Because we may need to allocate huge memory chunk at once when dict
			
 
				+ * expands, we will check this allocation is allowed or not if the dict
			
 
				+ * type has expandAllowed member function. */
			
 
				+static int dictTypeExpandAllowed(dict *d) {
			
 
				+    if (d->type->expandAllowed == NULL) return 1;
			
 
				+    return d->type->expandAllowed(
			
 
				+                    DICTHT_SIZE(_dictNextExp(d->ht_used[0] + 1)) * sizeof(dictEntry*),
			
 
				+                    (double)d->ht_used[0] / DICTHT_SIZE(d->ht_size_exp[0]));
			
 
				+}
			
 
				+
			
 
				+/* Expand the hash table if needed */
			
 
				+static int _dictExpandIfNeeded(dict *d)
			
 
				+{
			
 
				+    /* Incremental rehashing already in progress. Return. */
			
 
				+    if (dictIsRehashing(d)) return DICT_OK;
			
 
				+
			
 
				+    /* If the hash table is empty expand it to the initial size. */
			
 
				+    if (DICTHT_SIZE(d->ht_size_exp[0]) == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
			
 
				+
			
 
				+    /* If we reached the 1:1 ratio, and we are allowed to resize the hash
			
 
				+     * table (global setting) or we should avoid it but the ratio between
			
 
				+     * elements/buckets is over the "safe" threshold, we resize doubling
			
 
				+     * the number of buckets. */
			
 
				+    if (d->ht_used[0] >= DICTHT_SIZE(d->ht_size_exp[0]) &&
			
 
				+        (dict_can_resize ||
			
 
				+         d->ht_used[0]/ DICTHT_SIZE(d->ht_size_exp[0]) > dict_force_resize_ratio) &&
			
 
				+        dictTypeExpandAllowed(d))
			
 
				+    {
			
 
				+        return dictExpand(d, d->ht_used[0] + 1);
			
 
				+    }
			
 
				+    return DICT_OK;
			
 
				+}
			
 
				+
			
 
				+/* TODO: clz optimization */
			
 
				+/* Our hash table capability is a power of two */
			
 
				+static signed char _dictNextExp(unsigned long size)
			
 
				+{
			
 
				+    unsigned char e = DICT_HT_INITIAL_EXP;
			
 
				+
			
 
				+    if (size >= LONG_MAX) return (8*sizeof(long)-1);
			
 
				+    while(1) {
			
 
				+        if (((unsigned long)1<<e) >= size)
			
 
				+            return e;
			
 
				+        e++;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Returns the index of a free slot that can be populated with
			
 
				+ * a hash entry for the given 'key'.
			
 
				+ * If the key already exists, -1 is returned
			
 
				+ * and the optional output parameter may be filled.
			
 
				+ *
			
 
				+ * Note that if we are in the process of rehashing the hash table, the
			
 
				+ * index is always returned in the context of the second (new) hash table. */
			
 
				+static long _dictKeyIndex(dict *d, const void *key, uint64_t hash, dictEntry **existing)
			
 
				+{
			
 
				+    unsigned long idx, table;
			
 
				+    dictEntry *he;
			
 
				+    if (existing) *existing = NULL;
			
 
				+
			
 
				+    /* Expand the hash table if needed */
			
 
				+    if (_dictExpandIfNeeded(d) == DICT_ERR)
			
 
				+        return -1;
			
 
				+    for (table = 0; table <= 1; table++) {
			
 
				+        idx = hash & DICTHT_SIZE_MASK(d->ht_size_exp[table]);
			
 
				+        /* Search if this slot does not already contain the given key */
			
 
				+        he = d->ht_table[table][idx];
			
 
				+        while(he) {
			
 
				+            if (key==he->key || dictCompareKeys(d, key, he->key)) {
			
 
				+                if (existing) *existing = he;
			
 
				+                return -1;
			
 
				+            }
			
 
				+            he = he->next;
			
 
				+        }
			
 
				+        if (!dictIsRehashing(d)) break;
			
 
				+    }
			
 
				+    return idx;
			
 
				+}
			
 
				+
			
 
				+void dictEmpty(dict *d, void(callback)(dict*)) {
			
 
				+    _dictClear(d,0,callback);
			
 
				+    _dictClear(d,1,callback);
			
 
				+    d->rehashidx = -1;
			
 
				+    d->pauserehash = 0;
			
 
				+}
			
 
				+
			
 
				+void dictEnableResize(void) {
			
 
				+    dict_can_resize = 1;
			
 
				+}
			
 
				+
			
 
				+void dictDisableResize(void) {
			
 
				+    dict_can_resize = 0;
			
 
				+}
			
 
				+
			
 
				+uint64_t dictGetHash(dict *d, const void *key) {
			
 
				+    return dictHashKey(d, key);
			
 
				+}
			
 
				+
			
 
				+/* Finds the dictEntry reference by using pointer and pre-calculated hash.
			
 
				+ * oldkey is a dead pointer and should not be accessed.
			
 
				+ * the hash value should be provided using dictGetHash.
			
 
				+ * no string / key comparison is performed.
			
 
				+ * return value is the reference to the dictEntry if found, or NULL if not found. */
			
 
				+dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, uint64_t hash) {
			
 
				+    dictEntry *he, **heref;
			
 
				+    unsigned long idx, table;
			
 
				+
			
 
				+    if (dictSize(d) == 0) return NULL; /* dict is empty */
			
 
				+    for (table = 0; table <= 1; table++) {
			
 
				+        idx = hash & DICTHT_SIZE_MASK(d->ht_size_exp[table]);
			
 
				+        heref = &d->ht_table[table][idx];
			
 
				+        he = *heref;
			
 
				+        while(he) {
			
 
				+            if (oldptr==he->key)
			
 
				+                return heref;
			
 
				+            heref = &he->next;
			
 
				+            he = *heref;
			
 
				+        }
			
 
				+        if (!dictIsRehashing(d)) return NULL;
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* ------------------------------- Debugging ---------------------------------*/
			
 
				+
			
 
				+#define DICT_STATS_VECTLEN 50
			
 
				+size_t _dictGetStatsHt(char *buf, size_t bufsize, dict *d, int htidx) {
			
 
				+    unsigned long i, slots = 0, chainlen, maxchainlen = 0;
			
 
				+    unsigned long totchainlen = 0;
			
 
				+    unsigned long clvector[DICT_STATS_VECTLEN];
			
 
				+    size_t l = 0;
			
 
				+
			
 
				+    if (d->ht_used[htidx] == 0) {
			
 
				+        return snprintf(buf,bufsize,
			
 
				+            "No stats available for empty dictionaries\n");
			
 
				+    }
			
 
				+
			
 
				+    /* Compute stats. */
			
 
				+    for (i = 0; i < DICT_STATS_VECTLEN; i++) clvector[i] = 0;
			
 
				+    for (i = 0; i < DICTHT_SIZE(d->ht_size_exp[htidx]); i++) {
			
 
				+        dictEntry *he;
			
 
				+
			
 
				+        if (d->ht_table[htidx][i] == NULL) {
			
 
				+            clvector[0]++;
			
 
				+            continue;
			
 
				+        }
			
 
				+        slots++;
			
 
				+        /* For each hash entry on this slot... */
			
 
				+        chainlen = 0;
			
 
				+        he = d->ht_table[htidx][i];
			
 
				+        while(he) {
			
 
				+            chainlen++;
			
 
				+            he = he->next;
			
 
				+        }
			
 
				+        clvector[(chainlen < DICT_STATS_VECTLEN) ? chainlen : (DICT_STATS_VECTLEN-1)]++;
			
 
				+        if (chainlen > maxchainlen) maxchainlen = chainlen;
			
 
				+        totchainlen += chainlen;
			
 
				+    }
			
 
				+
			
 
				+    /* Generate human readable stats. */
			
 
				+    l += snprintf(buf+l,bufsize-l,
			
 
				+        "Hash table %d stats (%s):\n"
			
 
				+        " table size: %lu\n"
			
 
				+        " number of elements: %lu\n"
			
 
				+        " different slots: %lu\n"
			
 
				+        " max chain length: %lu\n"
			
 
				+        " avg chain length (counted): %.02f\n"
			
 
				+        " avg chain length (computed): %.02f\n"
			
 
				+        " Chain length distribution:\n",
			
 
				+        htidx, (htidx == 0) ? "main hash table" : "rehashing target",
			
 
				+        DICTHT_SIZE(d->ht_size_exp[htidx]), d->ht_used[htidx], slots, maxchainlen,
			
 
				+        (float)totchainlen/slots, (float)d->ht_used[htidx]/slots);
			
 
				+
			
 
				+    for (i = 0; i < DICT_STATS_VECTLEN-1; i++) {
			
 
				+        if (clvector[i] == 0) continue;
			
 
				+        if (l >= bufsize) break;
			
 
				+        l += snprintf(buf+l,bufsize-l,
			
 
				+            "   %s%ld: %ld (%.02f%%)\n",
			
 
				+            (i == DICT_STATS_VECTLEN-1)?">= ":"",
			
 
				+            i, clvector[i], ((float)clvector[i]/DICTHT_SIZE(d->ht_size_exp[htidx]))*100);
			
 
				+    }
			
 
				+
			
 
				+    /* Unlike snprintf(), return the number of characters actually written. */
			
 
				+    if (bufsize) buf[bufsize-1] = '\0';
			
 
				+    return strlen(buf);
			
 
				+}
			
 
				+
			
 
				+void dictGetStats(char *buf, size_t bufsize, dict *d) {
			
 
				+    size_t l;
			
 
				+    char *orig_buf = buf;
			
 
				+    size_t orig_bufsize = bufsize;
			
 
				+
			
 
				+    l = _dictGetStatsHt(buf,bufsize,d,0);
			
 
				+    buf += l;
			
 
				+    bufsize -= l;
			
 
				+    if (dictIsRehashing(d) && bufsize > 0) {
			
 
				+        _dictGetStatsHt(buf,bufsize,d,1);
			
 
				+    }
			
 
				+    /* Make sure there is a NULL term at the end. */
			
 
				+    if (orig_bufsize) orig_buf[orig_bufsize-1] = '\0';
			
 
				+}
			
 
				+
			
 
				+/* ------------------------------- Benchmark ---------------------------------*/
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#include "testhelp.h"
			
 
				+
			
 
				+#define UNUSED(V) ((void) V)
			
 
				+
			
 
				+uint64_t hashCallback(const void *key) {
			
 
				+    return dictGenHashFunction((unsigned char*)key, strlen((char*)key));
			
 
				+}
			
 
				+
			
 
				+int compareCallback(dict *d, const void *key1, const void *key2) {
			
 
				+    int l1,l2;
			
 
				+    UNUSED(d);
			
 
				+
			
 
				+    l1 = strlen((char*)key1);
			
 
				+    l2 = strlen((char*)key2);
			
 
				+    if (l1 != l2) return 0;
			
 
				+    return memcmp(key1, key2, l1) == 0;
			
 
				+}
			
 
				+
			
 
				+void freeCallback(dict *d, void *val) {
			
 
				+    UNUSED(d);
			
 
				+
			
 
				+    zfree(val);
			
 
				+}
			
 
				+
			
 
				+char *stringFromLongLong(long long value) {
			
 
				+    char buf[32];
			
 
				+    int len;
			
 
				+    char *s;
			
 
				+
			
 
				+    len = sprintf(buf,"%lld",value);
			
 
				+    s = zmalloc(len+1);
			
 
				+    memcpy(s, buf, len);
			
 
				+    s[len] = '\0';
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+dictType BenchmarkDictType = {
			
 
				+    hashCallback,
			
 
				+    NULL,
			
 
				+    NULL,
			
 
				+    compareCallback,
			
 
				+    freeCallback,
			
 
				+    NULL,
			
 
				+    NULL
			
 
				+};
			
 
				+
			
 
				+#define start_benchmark() start = timeInMilliseconds()
			
 
				+#define end_benchmark(msg) do { \
			
 
				+    elapsed = timeInMilliseconds()-start; \
			
 
				+    printf(msg ": %ld items in %lld ms\n", count, elapsed); \
			
 
				+} while(0)
			
 
				+
			
 
				+/* ./redis-server test dict [<count> | --accurate] */
			
 
				+int dictTest(int argc, char **argv, int flags) {
			
 
				+    long j;
			
 
				+    long long start, elapsed;
			
 
				+    dict *dict = dictCreate(&BenchmarkDictType);
			
 
				+    long count = 0;
			
 
				+    int accurate = (flags & REDIS_TEST_ACCURATE);
			
 
				+
			
 
				+    if (argc == 4) {
			
 
				+        if (accurate) {
			
 
				+            count = 5000000;
			
 
				+        } else {
			
 
				+            count = strtol(argv[3],NULL,10);
			
 
				+        }
			
 
				+    } else {
			
 
				+        count = 5000;
			
 
				+    }
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        int retval = dictAdd(dict,stringFromLongLong(j),(void*)j);
			
 
				+        assert(retval == DICT_OK);
			
 
				+    }
			
 
				+    end_benchmark("Inserting");
			
 
				+    assert((long)dictSize(dict) == count);
			
 
				+
			
 
				+    /* Wait for rehashing. */
			
 
				+    while (dictIsRehashing(dict)) {
			
 
				+        dictRehashMilliseconds(dict,100);
			
 
				+    }
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        char *key = stringFromLongLong(j);
			
 
				+        dictEntry *de = dictFind(dict,key);
			
 
				+        assert(de != NULL);
			
 
				+        zfree(key);
			
 
				+    }
			
 
				+    end_benchmark("Linear access of existing elements");
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        char *key = stringFromLongLong(j);
			
 
				+        dictEntry *de = dictFind(dict,key);
			
 
				+        assert(de != NULL);
			
 
				+        zfree(key);
			
 
				+    }
			
 
				+    end_benchmark("Linear access of existing elements (2nd round)");
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        char *key = stringFromLongLong(rand() % count);
			
 
				+        dictEntry *de = dictFind(dict,key);
			
 
				+        assert(de != NULL);
			
 
				+        zfree(key);
			
 
				+    }
			
 
				+    end_benchmark("Random access of existing elements");
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        dictEntry *de = dictGetRandomKey(dict);
			
 
				+        assert(de != NULL);
			
 
				+    }
			
 
				+    end_benchmark("Accessing random keys");
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        char *key = stringFromLongLong(rand() % count);
			
 
				+        key[0] = 'X';
			
 
				+        dictEntry *de = dictFind(dict,key);
			
 
				+        assert(de == NULL);
			
 
				+        zfree(key);
			
 
				+    }
			
 
				+    end_benchmark("Accessing missing");
			
 
				+
			
 
				+    start_benchmark();
			
 
				+    for (j = 0; j < count; j++) {
			
 
				+        char *key = stringFromLongLong(j);
			
 
				+        int retval = dictDelete(dict,key);
			
 
				+        assert(retval == DICT_OK);
			
 
				+        key[0] += 17; /* Change first number to letter. */
			
 
				+        retval = dictAdd(dict,key,(void*)j);
			
 
				+        assert(retval == DICT_OK);
			
 
				+    }
			
 
				+    end_benchmark("Removing and adding");
			
 
				+    dictRelease(dict);
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/dict.h
+++ b/src/dict.h
@@ -0,0 +1,212 @@
 
				+/* Hash Tables Implementation.
			
 
				+ *
			
 
				+ * This file implements in-memory hash tables with insert/del/replace/find/
			
 
				+ * get-random-element operations. Hash tables will auto-resize if needed
			
 
				+ * tables of power of two in size are used, collisions are handled by
			
 
				+ * chaining. See the source code for more information... :)
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __DICT_H
			
 
				+#define __DICT_H
			
 
				+
			
 
				+#include "mt19937-64.h"
			
 
				+#include <limits.h>
			
 
				+#include <stdint.h>
			
 
				+#include <stdlib.h>
			
 
				+
			
 
				+#define DICT_OK 0
			
 
				+#define DICT_ERR 1
			
 
				+
			
 
				+typedef struct dictEntry {
			
 
				+    void *key;
			
 
				+    union {
			
 
				+        void *val;
			
 
				+        uint64_t u64;
			
 
				+        int64_t s64;
			
 
				+        double d;
			
 
				+    } v;
			
 
				+    struct dictEntry *next;     /* Next entry in the same hash bucket. */
			
 
				+    void *metadata[];           /* An arbitrary number of bytes (starting at a
			
 
				+                                 * pointer-aligned address) of size as returned
			
 
				+                                 * by dictType's dictEntryMetadataBytes(). */
			
 
				+} dictEntry;
			
 
				+
			
 
				+typedef struct dict dict;
			
 
				+
			
 
				+typedef struct dictType {
			
 
				+    uint64_t (*hashFunction)(const void *key);
			
 
				+    void *(*keyDup)(dict *d, const void *key);
			
 
				+    void *(*valDup)(dict *d, const void *obj);
			
 
				+    int (*keyCompare)(dict *d, const void *key1, const void *key2);
			
 
				+    void (*keyDestructor)(dict *d, void *key);
			
 
				+    void (*valDestructor)(dict *d, void *obj);
			
 
				+    int (*expandAllowed)(size_t moreMem, double usedRatio);
			
 
				+    /* Allow a dictEntry to carry extra caller-defined metadata.  The
			
 
				+     * extra memory is initialized to 0 when a dictEntry is allocated. */
			
 
				+    size_t (*dictEntryMetadataBytes)(dict *d);
			
 
				+} dictType;
			
 
				+
			
 
				+#define DICTHT_SIZE(exp) ((exp) == -1 ? 0 : (unsigned long)1<<(exp))
			
 
				+#define DICTHT_SIZE_MASK(exp) ((exp) == -1 ? 0 : (DICTHT_SIZE(exp))-1)
			
 
				+
			
 
				+struct dict {
			
 
				+    dictType *type;
			
 
				+
			
 
				+    dictEntry **ht_table[2];
			
 
				+    unsigned long ht_used[2];
			
 
				+
			
 
				+    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
			
 
				+
			
 
				+    /* Keep small vars at end for optimal (minimal) struct padding */
			
 
				+    int16_t pauserehash; /* If >0 rehashing is paused (<0 indicates coding error) */
			
 
				+    signed char ht_size_exp[2]; /* exponent of size. (size = 1<<exp) */
			
 
				+};
			
 
				+
			
 
				+/* If safe is set to 1 this is a safe iterator, that means, you can call
			
 
				+ * dictAdd, dictFind, and other functions against the dictionary even while
			
 
				+ * iterating. Otherwise it is a non safe iterator, and only dictNext()
			
 
				+ * should be called while iterating. */
			
 
				+typedef struct dictIterator {
			
 
				+    dict *d;
			
 
				+    long index;
			
 
				+    int table, safe;
			
 
				+    dictEntry *entry, *nextEntry;
			
 
				+    /* unsafe iterator fingerprint for misuse detection. */
			
 
				+    unsigned long long fingerprint;
			
 
				+} dictIterator;
			
 
				+
			
 
				+typedef void (dictScanFunction)(void *privdata, const dictEntry *de);
			
 
				+typedef void (dictScanBucketFunction)(dict *d, dictEntry **bucketref);
			
 
				+
			
 
				+/* This is the initial size of every hash table */
			
 
				+#define DICT_HT_INITIAL_EXP      2
			
 
				+#define DICT_HT_INITIAL_SIZE     (1<<(DICT_HT_INITIAL_EXP))
			
 
				+
			
 
				+/* ------------------------------- Macros ------------------------------------*/
			
 
				+#define dictFreeVal(d, entry) \
			
 
				+    if ((d)->type->valDestructor) \
			
 
				+        (d)->type->valDestructor((d), (entry)->v.val)
			
 
				+
			
 
				+#define dictSetVal(d, entry, _val_) do { \
			
 
				+    if ((d)->type->valDup) \
			
 
				+        (entry)->v.val = (d)->type->valDup((d), _val_); \
			
 
				+    else \
			
 
				+        (entry)->v.val = (_val_); \
			
 
				+} while(0)
			
 
				+
			
 
				+#define dictSetSignedIntegerVal(entry, _val_) \
			
 
				+    do { (entry)->v.s64 = _val_; } while(0)
			
 
				+
			
 
				+#define dictSetUnsignedIntegerVal(entry, _val_) \
			
 
				+    do { (entry)->v.u64 = _val_; } while(0)
			
 
				+
			
 
				+#define dictSetDoubleVal(entry, _val_) \
			
 
				+    do { (entry)->v.d = _val_; } while(0)
			
 
				+
			
 
				+#define dictFreeKey(d, entry) \
			
 
				+    if ((d)->type->keyDestructor) \
			
 
				+        (d)->type->keyDestructor((d), (entry)->key)
			
 
				+
			
 
				+#define dictSetKey(d, entry, _key_) do { \
			
 
				+    if ((d)->type->keyDup) \
			
 
				+        (entry)->key = (d)->type->keyDup((d), _key_); \
			
 
				+    else \
			
 
				+        (entry)->key = (_key_); \
			
 
				+} while(0)
			
 
				+
			
 
				+#define dictCompareKeys(d, key1, key2) \
			
 
				+    (((d)->type->keyCompare) ? \
			
 
				+        (d)->type->keyCompare((d), key1, key2) : \
			
 
				+        (key1) == (key2))
			
 
				+
			
 
				+#define dictMetadata(entry) (&(entry)->metadata)
			
 
				+#define dictMetadataSize(d) ((d)->type->dictEntryMetadataBytes \
			
 
				+                             ? (d)->type->dictEntryMetadataBytes(d) : 0)
			
 
				+
			
 
				+#define dictHashKey(d, key) (d)->type->hashFunction(key)
			
 
				+#define dictGetKey(he) ((he)->key)
			
 
				+#define dictGetVal(he) ((he)->v.val)
			
 
				+#define dictGetSignedIntegerVal(he) ((he)->v.s64)
			
 
				+#define dictGetUnsignedIntegerVal(he) ((he)->v.u64)
			
 
				+#define dictGetDoubleVal(he) ((he)->v.d)
			
 
				+#define dictSlots(d) (DICTHT_SIZE((d)->ht_size_exp[0])+DICTHT_SIZE((d)->ht_size_exp[1]))
			
 
				+#define dictSize(d) ((d)->ht_used[0]+(d)->ht_used[1])
			
 
				+#define dictIsRehashing(d) ((d)->rehashidx != -1)
			
 
				+#define dictPauseRehashing(d) (d)->pauserehash++
			
 
				+#define dictResumeRehashing(d) (d)->pauserehash--
			
 
				+
			
 
				+/* If our unsigned long type can store a 64 bit number, use a 64 bit PRNG. */
			
 
				+#if ULONG_MAX >= 0xffffffffffffffff
			
 
				+#define randomULong() ((unsigned long) genrand64_int64())
			
 
				+#else
			
 
				+#define randomULong() random()
			
 
				+#endif
			
 
				+
			
 
				+/* API */
			
 
				+dict *dictCreate(dictType *type);
			
 
				+int dictExpand(dict *d, unsigned long size);
			
 
				+int dictTryExpand(dict *d, unsigned long size);
			
 
				+int dictAdd(dict *d, void *key, void *val);
			
 
				+dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing);
			
 
				+dictEntry *dictAddOrFind(dict *d, void *key);
			
 
				+int dictReplace(dict *d, void *key, void *val);
			
 
				+int dictDelete(dict *d, const void *key);
			
 
				+dictEntry *dictUnlink(dict *d, const void *key);
			
 
				+void dictFreeUnlinkedEntry(dict *d, dictEntry *he);
			
 
				+void dictRelease(dict *d);
			
 
				+dictEntry * dictFind(dict *d, const void *key);
			
 
				+void *dictFetchValue(dict *d, const void *key);
			
 
				+int dictResize(dict *d);
			
 
				+dictIterator *dictGetIterator(dict *d);
			
 
				+dictIterator *dictGetSafeIterator(dict *d);
			
 
				+dictEntry *dictNext(dictIterator *iter);
			
 
				+void dictReleaseIterator(dictIterator *iter);
			
 
				+dictEntry *dictGetRandomKey(dict *d);
			
 
				+dictEntry *dictGetFairRandomKey(dict *d);
			
 
				+unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count);
			
 
				+void dictGetStats(char *buf, size_t bufsize, dict *d);
			
 
				+uint64_t dictGenHashFunction(const void *key, int len);
			
 
				+uint64_t dictGenCaseHashFunction(const unsigned char *buf, int len);
			
 
				+void dictEmpty(dict *d, void(callback)(dict*));
			
 
				+void dictEnableResize(void);
			
 
				+void dictDisableResize(void);
			
 
				+int dictRehash(dict *d, int n);
			
 
				+int dictRehashMilliseconds(dict *d, int ms);
			
 
				+void dictSetHashFunctionSeed(uint8_t *seed);
			
 
				+uint8_t *dictGetHashFunctionSeed(void);
			
 
				+unsigned long dictScan(dict *d, unsigned long v, dictScanFunction *fn, dictScanBucketFunction *bucketfn, void *privdata);
			
 
				+uint64_t dictGetHash(dict *d, const void *key);
			
 
				+dictEntry **dictFindEntryRefByPtrAndHash(dict *d, const void *oldptr, uint64_t hash);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int dictTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif /* __DICT_H */
			
--- a/src/endianconv.c
+++ b/src/endianconv.c
@@ -0,0 +1,129 @@
 
				+/* endinconv.c -- Endian conversions utilities.
			
 
				+ *
			
 
				+ * This functions are never called directly, but always using the macros
			
 
				+ * defined into endianconv.h, this way we define everything is a non-operation
			
 
				+ * if the arch is already little endian.
			
 
				+ *
			
 
				+ * Redis tries to encode everything as little endian (but a few things that need
			
 
				+ * to be backward compatible are still in big endian) because most of the
			
 
				+ * production environments are little endian, and we have a lot of conversions
			
 
				+ * in a few places because ziplists, intsets, zipmaps, need to be endian-neutral
			
 
				+ * even in memory, since they are serialized on RDB files directly with a single
			
 
				+ * write(2) without other additional steps.
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2011-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+/* Toggle the 16 bit unsigned integer pointed by *p from little endian to
			
 
				+ * big endian */
			
 
				+void memrev16(void *p) {
			
 
				+    unsigned char *x = p, t;
			
 
				+
			
 
				+    t = x[0];
			
 
				+    x[0] = x[1];
			
 
				+    x[1] = t;
			
 
				+}
			
 
				+
			
 
				+/* Toggle the 32 bit unsigned integer pointed by *p from little endian to
			
 
				+ * big endian */
			
 
				+void memrev32(void *p) {
			
 
				+    unsigned char *x = p, t;
			
 
				+
			
 
				+    t = x[0];
			
 
				+    x[0] = x[3];
			
 
				+    x[3] = t;
			
 
				+    t = x[1];
			
 
				+    x[1] = x[2];
			
 
				+    x[2] = t;
			
 
				+}
			
 
				+
			
 
				+/* Toggle the 64 bit unsigned integer pointed by *p from little endian to
			
 
				+ * big endian */
			
 
				+void memrev64(void *p) {
			
 
				+    unsigned char *x = p, t;
			
 
				+
			
 
				+    t = x[0];
			
 
				+    x[0] = x[7];
			
 
				+    x[7] = t;
			
 
				+    t = x[1];
			
 
				+    x[1] = x[6];
			
 
				+    x[6] = t;
			
 
				+    t = x[2];
			
 
				+    x[2] = x[5];
			
 
				+    x[5] = t;
			
 
				+    t = x[3];
			
 
				+    x[3] = x[4];
			
 
				+    x[4] = t;
			
 
				+}
			
 
				+
			
 
				+uint16_t intrev16(uint16_t v) {
			
 
				+    memrev16(&v);
			
 
				+    return v;
			
 
				+}
			
 
				+
			
 
				+uint32_t intrev32(uint32_t v) {
			
 
				+    memrev32(&v);
			
 
				+    return v;
			
 
				+}
			
 
				+
			
 
				+uint64_t intrev64(uint64_t v) {
			
 
				+    memrev64(&v);
			
 
				+    return v;
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#include <stdio.h>
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+int endianconvTest(int argc, char *argv[], int flags) {
			
 
				+    char buf[32];
			
 
				+
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+
			
 
				+    sprintf(buf,"ciaoroma");
			
 
				+    memrev16(buf);
			
 
				+    printf("%s\n", buf);
			
 
				+
			
 
				+    sprintf(buf,"ciaoroma");
			
 
				+    memrev32(buf);
			
 
				+    printf("%s\n", buf);
			
 
				+
			
 
				+    sprintf(buf,"ciaoroma");
			
 
				+    memrev64(buf);
			
 
				+    printf("%s\n", buf);
			
 
				+
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/endianconv.h
+++ b/src/endianconv.h
@@ -0,0 +1,78 @@
 
				+/* See endianconv.c top comments for more information
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2011-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __ENDIANCONV_H
			
 
				+#define __ENDIANCONV_H
			
 
				+
			
 
				+#include "config.h"
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+void memrev16(void *p);
			
 
				+void memrev32(void *p);
			
 
				+void memrev64(void *p);
			
 
				+uint16_t intrev16(uint16_t v);
			
 
				+uint32_t intrev32(uint32_t v);
			
 
				+uint64_t intrev64(uint64_t v);
			
 
				+
			
 
				+/* variants of the function doing the actual conversion only if the target
			
 
				+ * host is big endian */
			
 
				+#if (BYTE_ORDER == LITTLE_ENDIAN)
			
 
				+#define memrev16ifbe(p) ((void)(0))
			
 
				+#define memrev32ifbe(p) ((void)(0))
			
 
				+#define memrev64ifbe(p) ((void)(0))
			
 
				+#define intrev16ifbe(v) (v)
			
 
				+#define intrev32ifbe(v) (v)
			
 
				+#define intrev64ifbe(v) (v)
			
 
				+#else
			
 
				+#define memrev16ifbe(p) memrev16(p)
			
 
				+#define memrev32ifbe(p) memrev32(p)
			
 
				+#define memrev64ifbe(p) memrev64(p)
			
 
				+#define intrev16ifbe(v) intrev16(v)
			
 
				+#define intrev32ifbe(v) intrev32(v)
			
 
				+#define intrev64ifbe(v) intrev64(v)
			
 
				+#endif
			
 
				+
			
 
				+/* The functions htonu64() and ntohu64() convert the specified value to
			
 
				+ * network byte ordering and back. In big endian systems they are no-ops. */
			
 
				+#if (BYTE_ORDER == BIG_ENDIAN)
			
 
				+#define htonu64(v) (v)
			
 
				+#define ntohu64(v) (v)
			
 
				+#else
			
 
				+#define htonu64(v) intrev64(v)
			
 
				+#define ntohu64(v) intrev64(v)
			
 
				+#endif
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int endianconvTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/http_parser.c
+++ b/src/http_parser.c
--- a/src/http_parser.h
+++ b/src/http_parser.h
@@ -0,0 +1,23 @@
 
				+/* Parse incoming(Request) HTTP by llhttp.
			
 
				+ * 
			
 
				+ */
			
 
				+#ifndef HTTP_PARSER
			
 
				+#define HTTP_PARSER
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+struct _HTTP_data {
			
 
				+    uint8_t ver_major;
			
 
				+    uint8_t ver_minor;
			
 
				+    char url[256];
			
 
				+    char host[256];
			
 
				+    char method[8];
			
 
				+
			
 
				+    uint8_t header_parsing_flag;
			
 
				+};
			
 
				+
			
 
				+
			
 
				+int parseHTTP(const char* data, int data_len);
			
 
				+
			
 
				+
			
 
				+#endif
			
--- a/src/listpack.c
+++ b/src/listpack.c
@@ -0,0 +1,2413 @@
 
				+/* Listpack -- A lists of strings serialization format
			
 
				+ *
			
 
				+ * This file implements the specification you can find at:
			
 
				+ *
			
 
				+ *  https://github.com/antirez/listpack
			
 
				+ *
			
 
				+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez at gmail dot com>
			
 
				+ * Copyright (c) 2020, Redis Labs, Inc
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+#include <limits.h>
			
 
				+#include <sys/types.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+#include <stdio.h>
			
 
				+
			
 
				+#include "listpack.h"
			
 
				+#include "listpack_malloc.h"
			
 
				+#include "redisassert.h"
			
 
				+#include "util.h"
			
 
				+
			
 
				+#define LP_HDR_SIZE 6       /* 32 bit total len + 16 bit number of elements. */
			
 
				+#define LP_HDR_NUMELE_UNKNOWN UINT16_MAX
			
 
				+#define LP_MAX_INT_ENCODING_LEN 9
			
 
				+#define LP_MAX_BACKLEN_SIZE 5
			
 
				+#define LP_MAX_ENTRY_BACKLEN 34359738367ULL
			
 
				+#define LP_ENCODING_INT 0
			
 
				+#define LP_ENCODING_STRING 1
			
 
				+
			
 
				+#define LP_ENCODING_7BIT_UINT 0
			
 
				+#define LP_ENCODING_7BIT_UINT_MASK 0x80
			
 
				+#define LP_ENCODING_IS_7BIT_UINT(byte) (((byte)&LP_ENCODING_7BIT_UINT_MASK)==LP_ENCODING_7BIT_UINT)
			
 
				+#define LP_ENCODING_7BIT_UINT_ENTRY_SIZE 2
			
 
				+
			
 
				+#define LP_ENCODING_6BIT_STR 0x80
			
 
				+#define LP_ENCODING_6BIT_STR_MASK 0xC0
			
 
				+#define LP_ENCODING_IS_6BIT_STR(byte) (((byte)&LP_ENCODING_6BIT_STR_MASK)==LP_ENCODING_6BIT_STR)
			
 
				+
			
 
				+#define LP_ENCODING_13BIT_INT 0xC0
			
 
				+#define LP_ENCODING_13BIT_INT_MASK 0xE0
			
 
				+#define LP_ENCODING_IS_13BIT_INT(byte) (((byte)&LP_ENCODING_13BIT_INT_MASK)==LP_ENCODING_13BIT_INT)
			
 
				+#define LP_ENCODING_13BIT_INT_ENTRY_SIZE 3
			
 
				+
			
 
				+#define LP_ENCODING_12BIT_STR 0xE0
			
 
				+#define LP_ENCODING_12BIT_STR_MASK 0xF0
			
 
				+#define LP_ENCODING_IS_12BIT_STR(byte) (((byte)&LP_ENCODING_12BIT_STR_MASK)==LP_ENCODING_12BIT_STR)
			
 
				+
			
 
				+#define LP_ENCODING_16BIT_INT 0xF1
			
 
				+#define LP_ENCODING_16BIT_INT_MASK 0xFF
			
 
				+#define LP_ENCODING_IS_16BIT_INT(byte) (((byte)&LP_ENCODING_16BIT_INT_MASK)==LP_ENCODING_16BIT_INT)
			
 
				+#define LP_ENCODING_16BIT_INT_ENTRY_SIZE 4
			
 
				+
			
 
				+#define LP_ENCODING_24BIT_INT 0xF2
			
 
				+#define LP_ENCODING_24BIT_INT_MASK 0xFF
			
 
				+#define LP_ENCODING_IS_24BIT_INT(byte) (((byte)&LP_ENCODING_24BIT_INT_MASK)==LP_ENCODING_24BIT_INT)
			
 
				+#define LP_ENCODING_24BIT_INT_ENTRY_SIZE 5
			
 
				+
			
 
				+#define LP_ENCODING_32BIT_INT 0xF3
			
 
				+#define LP_ENCODING_32BIT_INT_MASK 0xFF
			
 
				+#define LP_ENCODING_IS_32BIT_INT(byte) (((byte)&LP_ENCODING_32BIT_INT_MASK)==LP_ENCODING_32BIT_INT)
			
 
				+#define LP_ENCODING_32BIT_INT_ENTRY_SIZE 6
			
 
				+
			
 
				+#define LP_ENCODING_64BIT_INT 0xF4
			
 
				+#define LP_ENCODING_64BIT_INT_MASK 0xFF
			
 
				+#define LP_ENCODING_IS_64BIT_INT(byte) (((byte)&LP_ENCODING_64BIT_INT_MASK)==LP_ENCODING_64BIT_INT)
			
 
				+#define LP_ENCODING_64BIT_INT_ENTRY_SIZE 10
			
 
				+
			
 
				+#define LP_ENCODING_32BIT_STR 0xF0
			
 
				+#define LP_ENCODING_32BIT_STR_MASK 0xFF
			
 
				+#define LP_ENCODING_IS_32BIT_STR(byte) (((byte)&LP_ENCODING_32BIT_STR_MASK)==LP_ENCODING_32BIT_STR)
			
 
				+
			
 
				+#define LP_EOF 0xFF
			
 
				+
			
 
				+#define LP_ENCODING_6BIT_STR_LEN(p) ((p)[0] & 0x3F)
			
 
				+#define LP_ENCODING_12BIT_STR_LEN(p) ((((p)[0] & 0xF) << 8) | (p)[1])
			
 
				+#define LP_ENCODING_32BIT_STR_LEN(p) (((uint32_t)(p)[1]<<0) | \
			
 
				+                                      ((uint32_t)(p)[2]<<8) | \
			
 
				+                                      ((uint32_t)(p)[3]<<16) | \
			
 
				+                                      ((uint32_t)(p)[4]<<24))
			
 
				+
			
 
				+#define lpGetTotalBytes(p)           (((uint32_t)(p)[0]<<0) | \
			
 
				+                                      ((uint32_t)(p)[1]<<8) | \
			
 
				+                                      ((uint32_t)(p)[2]<<16) | \
			
 
				+                                      ((uint32_t)(p)[3]<<24))
			
 
				+
			
 
				+#define lpGetNumElements(p)          (((uint32_t)(p)[4]<<0) | \
			
 
				+                                      ((uint32_t)(p)[5]<<8))
			
 
				+#define lpSetTotalBytes(p,v) do { \
			
 
				+    (p)[0] = (v)&0xff; \
			
 
				+    (p)[1] = ((v)>>8)&0xff; \
			
 
				+    (p)[2] = ((v)>>16)&0xff; \
			
 
				+    (p)[3] = ((v)>>24)&0xff; \
			
 
				+} while(0)
			
 
				+
			
 
				+#define lpSetNumElements(p,v) do { \
			
 
				+    (p)[4] = (v)&0xff; \
			
 
				+    (p)[5] = ((v)>>8)&0xff; \
			
 
				+} while(0)
			
 
				+
			
 
				+/* Validates that 'p' is not outside the listpack.
			
 
				+ * All function that return a pointer to an element in the listpack will assert
			
 
				+ * that this element is valid, so it can be freely used.
			
 
				+ * Generally functions such lpNext and lpDelete assume the input pointer is
			
 
				+ * already validated (since it's the return value of another function). */
			
 
				+#define ASSERT_INTEGRITY(lp, p) do { \
			
 
				+    assert((p) >= (lp)+LP_HDR_SIZE && (p) < (lp)+lpGetTotalBytes((lp))); \
			
 
				+} while (0)
			
 
				+
			
 
				+/* Similar to the above, but validates the entire element length rather than just
			
 
				+ * it's pointer. */
			
 
				+#define ASSERT_INTEGRITY_LEN(lp, p, len) do { \
			
 
				+    assert((p) >= (lp)+LP_HDR_SIZE && (p)+(len) < (lp)+lpGetTotalBytes((lp))); \
			
 
				+} while (0)
			
 
				+
			
 
				+static inline void lpAssertValidEntry(unsigned char* lp, size_t lpbytes, unsigned char *p);
			
 
				+
			
 
				+/* Don't let listpacks grow over 1GB in any case, don't wanna risk overflow in
			
 
				+ * Total Bytes header field */
			
 
				+#define LISTPACK_MAX_SAFETY_SIZE (1<<30)
			
 
				+int lpSafeToAdd(unsigned char* lp, size_t add) {
			
 
				+    size_t len = lp? lpGetTotalBytes(lp): 0;
			
 
				+    if (len + add > LISTPACK_MAX_SAFETY_SIZE)
			
 
				+        return 0;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Convert a string into a signed 64 bit integer.
			
 
				+ * The function returns 1 if the string could be parsed into a (non-overflowing)
			
 
				+ * signed 64 bit int, 0 otherwise. The 'value' will be set to the parsed value
			
 
				+ * when the function returns success.
			
 
				+ *
			
 
				+ * Note that this function demands that the string strictly represents
			
 
				+ * a int64 value: no spaces or other characters before or after the string
			
 
				+ * representing the number are accepted, nor zeroes at the start if not
			
 
				+ * for the string "0" representing the zero number.
			
 
				+ *
			
 
				+ * Because of its strictness, it is safe to use this function to check if
			
 
				+ * you can convert a string into a long long, and obtain back the string
			
 
				+ * from the number without any loss in the string representation. *
			
 
				+ *
			
 
				+ * -----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Credits: this function was adapted from the Redis source code, file
			
 
				+ * "utils.c", function string2ll(), and is copyright:
			
 
				+ *
			
 
				+ * Copyright(C) 2011, Pieter Noordhuis
			
 
				+ * Copyright(C) 2011, Salvatore Sanfilippo
			
 
				+ *
			
 
				+ * The function is released under the BSD 3-clause license.
			
 
				+ */
			
 
				+int lpStringToInt64(const char *s, unsigned long slen, int64_t *value) {
			
 
				+    const char *p = s;
			
 
				+    unsigned long plen = 0;
			
 
				+    int negative = 0;
			
 
				+    uint64_t v;
			
 
				+
			
 
				+    if (plen == slen)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Special case: first and only digit is 0. */
			
 
				+    if (slen == 1 && p[0] == '0') {
			
 
				+        if (value != NULL) *value = 0;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    if (p[0] == '-') {
			
 
				+        negative = 1;
			
 
				+        p++; plen++;
			
 
				+
			
 
				+        /* Abort on only a negative sign. */
			
 
				+        if (plen == slen)
			
 
				+            return 0;
			
 
				+    }
			
 
				+
			
 
				+    /* First digit should be 1-9, otherwise the string should just be 0. */
			
 
				+    if (p[0] >= '1' && p[0] <= '9') {
			
 
				+        v = p[0]-'0';
			
 
				+        p++; plen++;
			
 
				+    } else {
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
			
 
				+        if (v > (UINT64_MAX / 10)) /* Overflow. */
			
 
				+            return 0;
			
 
				+        v *= 10;
			
 
				+
			
 
				+        if (v > (UINT64_MAX - (p[0]-'0'))) /* Overflow. */
			
 
				+            return 0;
			
 
				+        v += p[0]-'0';
			
 
				+
			
 
				+        p++; plen++;
			
 
				+    }
			
 
				+
			
 
				+    /* Return if not all bytes were used. */
			
 
				+    if (plen < slen)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (negative) {
			
 
				+        if (v > ((uint64_t)(-(INT64_MIN+1))+1)) /* Overflow. */
			
 
				+            return 0;
			
 
				+        if (value != NULL) *value = -v;
			
 
				+    } else {
			
 
				+        if (v > INT64_MAX) /* Overflow. */
			
 
				+            return 0;
			
 
				+        if (value != NULL) *value = v;
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Create a new, empty listpack.
			
 
				+ * On success the new listpack is returned, otherwise an error is returned.
			
 
				+ * Pre-allocate at least `capacity` bytes of memory,
			
 
				+ * over-allocated memory can be shrunk by `lpShrinkToFit`.
			
 
				+ * */
			
 
				+unsigned char *lpNew(size_t capacity) {
			
 
				+    unsigned char *lp = lp_malloc(capacity > LP_HDR_SIZE+1 ? capacity : LP_HDR_SIZE+1);
			
 
				+    if (lp == NULL) return NULL;
			
 
				+    lpSetTotalBytes(lp,LP_HDR_SIZE+1);
			
 
				+    lpSetNumElements(lp,0);
			
 
				+    lp[LP_HDR_SIZE] = LP_EOF;
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+/* Free the specified listpack. */
			
 
				+void lpFree(unsigned char *lp) {
			
 
				+    lp_free(lp);
			
 
				+}
			
 
				+
			
 
				+/* Shrink the memory to fit. */
			
 
				+unsigned char* lpShrinkToFit(unsigned char *lp) {
			
 
				+    size_t size = lpGetTotalBytes(lp);
			
 
				+    if (size < lp_malloc_size(lp)) {
			
 
				+        return lp_realloc(lp, size);
			
 
				+    } else {
			
 
				+        return lp;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Stores the integer encoded representation of 'v' in the 'intenc' buffer. */
			
 
				+static inline void lpEncodeIntegerGetType(int64_t v, unsigned char *intenc, uint64_t *enclen) {
			
 
				+    if (v >= 0 && v <= 127) {
			
 
				+        /* Single byte 0-127 integer. */
			
 
				+        intenc[0] = v;
			
 
				+        *enclen = 1;
			
 
				+    } else if (v >= -4096 && v <= 4095) {
			
 
				+        /* 13 bit integer. */
			
 
				+        if (v < 0) v = ((int64_t)1<<13)+v;
			
 
				+        intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
			
 
				+        intenc[1] = v&0xff;
			
 
				+        *enclen = 2;
			
 
				+    } else if (v >= -32768 && v <= 32767) {
			
 
				+        /* 16 bit integer. */
			
 
				+        if (v < 0) v = ((int64_t)1<<16)+v;
			
 
				+        intenc[0] = LP_ENCODING_16BIT_INT;
			
 
				+        intenc[1] = v&0xff;
			
 
				+        intenc[2] = v>>8;
			
 
				+        *enclen = 3;
			
 
				+    } else if (v >= -8388608 && v <= 8388607) {
			
 
				+        /* 24 bit integer. */
			
 
				+        if (v < 0) v = ((int64_t)1<<24)+v;
			
 
				+        intenc[0] = LP_ENCODING_24BIT_INT;
			
 
				+        intenc[1] = v&0xff;
			
 
				+        intenc[2] = (v>>8)&0xff;
			
 
				+        intenc[3] = v>>16;
			
 
				+        *enclen = 4;
			
 
				+    } else if (v >= -2147483648 && v <= 2147483647) {
			
 
				+        /* 32 bit integer. */
			
 
				+        if (v < 0) v = ((int64_t)1<<32)+v;
			
 
				+        intenc[0] = LP_ENCODING_32BIT_INT;
			
 
				+        intenc[1] = v&0xff;
			
 
				+        intenc[2] = (v>>8)&0xff;
			
 
				+        intenc[3] = (v>>16)&0xff;
			
 
				+        intenc[4] = v>>24;
			
 
				+        *enclen = 5;
			
 
				+    } else {
			
 
				+        /* 64 bit integer. */
			
 
				+        uint64_t uv = v;
			
 
				+        intenc[0] = LP_ENCODING_64BIT_INT;
			
 
				+        intenc[1] = uv&0xff;
			
 
				+        intenc[2] = (uv>>8)&0xff;
			
 
				+        intenc[3] = (uv>>16)&0xff;
			
 
				+        intenc[4] = (uv>>24)&0xff;
			
 
				+        intenc[5] = (uv>>32)&0xff;
			
 
				+        intenc[6] = (uv>>40)&0xff;
			
 
				+        intenc[7] = (uv>>48)&0xff;
			
 
				+        intenc[8] = uv>>56;
			
 
				+        *enclen = 9;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Given an element 'ele' of size 'size', determine if the element can be
			
 
				+ * represented inside the listpack encoded as integer, and returns
			
 
				+ * LP_ENCODING_INT if so. Otherwise returns LP_ENCODING_STR if no integer
			
 
				+ * encoding is possible.
			
 
				+ *
			
 
				+ * If the LP_ENCODING_INT is returned, the function stores the integer encoded
			
 
				+ * representation of the element in the 'intenc' buffer.
			
 
				+ *
			
 
				+ * Regardless of the returned encoding, 'enclen' is populated by reference to
			
 
				+ * the number of bytes that the string or integer encoded element will require
			
 
				+ * in order to be represented. */
			
 
				+static inline int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
			
 
				+    int64_t v;
			
 
				+    if (lpStringToInt64((const char*)ele, size, &v)) {
			
 
				+        lpEncodeIntegerGetType(v, intenc, enclen);
			
 
				+        return LP_ENCODING_INT;
			
 
				+    } else {
			
 
				+        if (size < 64) *enclen = 1+size;
			
 
				+        else if (size < 4096) *enclen = 2+size;
			
 
				+        else *enclen = 5+(uint64_t)size;
			
 
				+        return LP_ENCODING_STRING;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Store a reverse-encoded variable length field, representing the length
			
 
				+ * of the previous element of size 'l', in the target buffer 'buf'.
			
 
				+ * The function returns the number of bytes used to encode it, from
			
 
				+ * 1 to 5. If 'buf' is NULL the function just returns the number of bytes
			
 
				+ * needed in order to encode the backlen. */
			
 
				+static inline unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
			
 
				+    if (l <= 127) {
			
 
				+        if (buf) buf[0] = l;
			
 
				+        return 1;
			
 
				+    } else if (l < 16383) {
			
 
				+        if (buf) {
			
 
				+            buf[0] = l>>7;
			
 
				+            buf[1] = (l&127)|128;
			
 
				+        }
			
 
				+        return 2;
			
 
				+    } else if (l < 2097151) {
			
 
				+        if (buf) {
			
 
				+            buf[0] = l>>14;
			
 
				+            buf[1] = ((l>>7)&127)|128;
			
 
				+            buf[2] = (l&127)|128;
			
 
				+        }
			
 
				+        return 3;
			
 
				+    } else if (l < 268435455) {
			
 
				+        if (buf) {
			
 
				+            buf[0] = l>>21;
			
 
				+            buf[1] = ((l>>14)&127)|128;
			
 
				+            buf[2] = ((l>>7)&127)|128;
			
 
				+            buf[3] = (l&127)|128;
			
 
				+        }
			
 
				+        return 4;
			
 
				+    } else {
			
 
				+        if (buf) {
			
 
				+            buf[0] = l>>28;
			
 
				+            buf[1] = ((l>>21)&127)|128;
			
 
				+            buf[2] = ((l>>14)&127)|128;
			
 
				+            buf[3] = ((l>>7)&127)|128;
			
 
				+            buf[4] = (l&127)|128;
			
 
				+        }
			
 
				+        return 5;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Decode the backlen and returns it. If the encoding looks invalid (more than
			
 
				+ * 5 bytes are used), UINT64_MAX is returned to report the problem. */
			
 
				+static inline uint64_t lpDecodeBacklen(unsigned char *p) {
			
 
				+    uint64_t val = 0;
			
 
				+    uint64_t shift = 0;
			
 
				+    do {
			
 
				+        val |= (uint64_t)(p[0] & 127) << shift;
			
 
				+        if (!(p[0] & 128)) break;
			
 
				+        shift += 7;
			
 
				+        p--;
			
 
				+        if (shift > 28) return UINT64_MAX;
			
 
				+    } while(1);
			
 
				+    return val;
			
 
				+}
			
 
				+
			
 
				+/* Encode the string element pointed by 's' of size 'len' in the target
			
 
				+ * buffer 's'. The function should be called with 'buf' having always enough
			
 
				+ * space for encoding the string. This is done by calling lpEncodeGetType()
			
 
				+ * before calling this function. */
			
 
				+static inline void lpEncodeString(unsigned char *buf, unsigned char *s, uint32_t len) {
			
 
				+    if (len < 64) {
			
 
				+        buf[0] = len | LP_ENCODING_6BIT_STR;
			
 
				+        memcpy(buf+1,s,len);
			
 
				+    } else if (len < 4096) {
			
 
				+        buf[0] = (len >> 8) | LP_ENCODING_12BIT_STR;
			
 
				+        buf[1] = len & 0xff;
			
 
				+        memcpy(buf+2,s,len);
			
 
				+    } else {
			
 
				+        buf[0] = LP_ENCODING_32BIT_STR;
			
 
				+        buf[1] = len & 0xff;
			
 
				+        buf[2] = (len >> 8) & 0xff;
			
 
				+        buf[3] = (len >> 16) & 0xff;
			
 
				+        buf[4] = (len >> 24) & 0xff;
			
 
				+        memcpy(buf+5,s,len);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Return the encoded length of the listpack element pointed by 'p'.
			
 
				+ * This includes the encoding byte, length bytes, and the element data itself.
			
 
				+ * If the element encoding is wrong then 0 is returned.
			
 
				+ * Note that this method may access additional bytes (in case of 12 and 32 bit
			
 
				+ * str), so should only be called when we know 'p' was already validated by
			
 
				+ * lpCurrentEncodedSizeBytes or ASSERT_INTEGRITY_LEN (possibly since 'p' is
			
 
				+ * a return value of another function that validated its return. */
			
 
				+static inline uint32_t lpCurrentEncodedSizeUnsafe(unsigned char *p) {
			
 
				+    if (LP_ENCODING_IS_7BIT_UINT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_6BIT_STR(p[0])) return 1+LP_ENCODING_6BIT_STR_LEN(p);
			
 
				+    if (LP_ENCODING_IS_13BIT_INT(p[0])) return 2;
			
 
				+    if (LP_ENCODING_IS_16BIT_INT(p[0])) return 3;
			
 
				+    if (LP_ENCODING_IS_24BIT_INT(p[0])) return 4;
			
 
				+    if (LP_ENCODING_IS_32BIT_INT(p[0])) return 5;
			
 
				+    if (LP_ENCODING_IS_64BIT_INT(p[0])) return 9;
			
 
				+    if (LP_ENCODING_IS_12BIT_STR(p[0])) return 2+LP_ENCODING_12BIT_STR_LEN(p);
			
 
				+    if (LP_ENCODING_IS_32BIT_STR(p[0])) return 5+LP_ENCODING_32BIT_STR_LEN(p);
			
 
				+    if (p[0] == LP_EOF) return 1;
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Return bytes needed to encode the length of the listpack element pointed by 'p'.
			
 
				+ * This includes just the encoding byte, and the bytes needed to encode the length
			
 
				+ * of the element (excluding the element data itself)
			
 
				+ * If the element encoding is wrong then 0 is returned. */
			
 
				+static inline uint32_t lpCurrentEncodedSizeBytes(unsigned char *p) {
			
 
				+    if (LP_ENCODING_IS_7BIT_UINT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_6BIT_STR(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_13BIT_INT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_16BIT_INT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_24BIT_INT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_32BIT_INT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_64BIT_INT(p[0])) return 1;
			
 
				+    if (LP_ENCODING_IS_12BIT_STR(p[0])) return 2;
			
 
				+    if (LP_ENCODING_IS_32BIT_STR(p[0])) return 5;
			
 
				+    if (p[0] == LP_EOF) return 1;
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Skip the current entry returning the next. It is invalid to call this
			
 
				+ * function if the current element is the EOF element at the end of the
			
 
				+ * listpack, however, while this function is used to implement lpNext(),
			
 
				+ * it does not return NULL when the EOF element is encountered. */
			
 
				+unsigned char *lpSkip(unsigned char *p) {
			
 
				+    unsigned long entrylen = lpCurrentEncodedSizeUnsafe(p);
			
 
				+    entrylen += lpEncodeBacklen(NULL,entrylen);
			
 
				+    p += entrylen;
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* If 'p' points to an element of the listpack, calling lpNext() will return
			
 
				+ * the pointer to the next element (the one on the right), or NULL if 'p'
			
 
				+ * already pointed to the last element of the listpack. */
			
 
				+unsigned char *lpNext(unsigned char *lp, unsigned char *p) {
			
 
				+    assert(p);
			
 
				+    p = lpSkip(p);
			
 
				+    if (p[0] == LP_EOF) return NULL;
			
 
				+    lpAssertValidEntry(lp, lpBytes(lp), p);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* If 'p' points to an element of the listpack, calling lpPrev() will return
			
 
				+ * the pointer to the previous element (the one on the left), or NULL if 'p'
			
 
				+ * already pointed to the first element of the listpack. */
			
 
				+unsigned char *lpPrev(unsigned char *lp, unsigned char *p) {
			
 
				+    assert(p);
			
 
				+    if (p-lp == LP_HDR_SIZE) return NULL;
			
 
				+    p--; /* Seek the first backlen byte of the last element. */
			
 
				+    uint64_t prevlen = lpDecodeBacklen(p);
			
 
				+    prevlen += lpEncodeBacklen(NULL,prevlen);
			
 
				+    p -= prevlen-1; /* Seek the first byte of the previous entry. */
			
 
				+    lpAssertValidEntry(lp, lpBytes(lp), p);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* Return a pointer to the first element of the listpack, or NULL if the
			
 
				+ * listpack has no elements. */
			
 
				+unsigned char *lpFirst(unsigned char *lp) {
			
 
				+    unsigned char *p = lp + LP_HDR_SIZE; /* Skip the header. */
			
 
				+    if (p[0] == LP_EOF) return NULL;
			
 
				+    lpAssertValidEntry(lp, lpBytes(lp), p);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* Return a pointer to the last element of the listpack, or NULL if the
			
 
				+ * listpack has no elements. */
			
 
				+unsigned char *lpLast(unsigned char *lp) {
			
 
				+    unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
			
 
				+    return lpPrev(lp,p); /* Will return NULL if EOF is the only element. */
			
 
				+}
			
 
				+
			
 
				+/* Return the number of elements inside the listpack. This function attempts
			
 
				+ * to use the cached value when within range, otherwise a full scan is
			
 
				+ * needed. As a side effect of calling this function, the listpack header
			
 
				+ * could be modified, because if the count is found to be already within
			
 
				+ * the 'numele' header field range, the new value is set. */
			
 
				+unsigned long lpLength(unsigned char *lp) {
			
 
				+    uint32_t numele = lpGetNumElements(lp);
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN) return numele;
			
 
				+
			
 
				+    /* Too many elements inside the listpack. We need to scan in order
			
 
				+     * to get the total number. */
			
 
				+    uint32_t count = 0;
			
 
				+    unsigned char *p = lpFirst(lp);
			
 
				+    while(p) {
			
 
				+        count++;
			
 
				+        p = lpNext(lp,p);
			
 
				+    }
			
 
				+
			
 
				+    /* If the count is again within range of the header numele field,
			
 
				+     * set it. */
			
 
				+    if (count < LP_HDR_NUMELE_UNKNOWN) lpSetNumElements(lp,count);
			
 
				+    return count;
			
 
				+}
			
 
				+
			
 
				+/* Return the listpack element pointed by 'p'.
			
 
				+ *
			
 
				+ * The function changes behavior depending on the passed 'intbuf' value.
			
 
				+ * Specifically, if 'intbuf' is NULL:
			
 
				+ *
			
 
				+ * If the element is internally encoded as an integer, the function returns
			
 
				+ * NULL and populates the integer value by reference in 'count'. Otherwise if
			
 
				+ * the element is encoded as a string a pointer to the string (pointing inside
			
 
				+ * the listpack itself) is returned, and 'count' is set to the length of the
			
 
				+ * string.
			
 
				+ *
			
 
				+ * If instead 'intbuf' points to a buffer passed by the caller, that must be
			
 
				+ * at least LP_INTBUF_SIZE bytes, the function always returns the element as
			
 
				+ * it was a string (returning the pointer to the string and setting the
			
 
				+ * 'count' argument to the string length by reference). However if the element
			
 
				+ * is encoded as an integer, the 'intbuf' buffer is used in order to store
			
 
				+ * the string representation.
			
 
				+ *
			
 
				+ * The user should use one or the other form depending on what the value will
			
 
				+ * be used for. If there is immediate usage for an integer value returned
			
 
				+ * by the function, than to pass a buffer (and convert it back to a number)
			
 
				+ * is of course useless.
			
 
				+ *
			
 
				+ * If 'entry_size' is not NULL, *entry_size is set to the entry length of the
			
 
				+ * listpack element pointed by 'p'. This includes the encoding bytes, length
			
 
				+ * bytes, the element data itself, and the backlen bytes.
			
 
				+ *
			
 
				+ * If the function is called against a badly encoded ziplist, so that there
			
 
				+ * is no valid way to parse it, the function returns like if there was an
			
 
				+ * integer encoded with value 12345678900000000 + <unrecognized byte>, this may
			
 
				+ * be an hint to understand that something is wrong. To crash in this case is
			
 
				+ * not sensible because of the different requirements of the application using
			
 
				+ * this lib.
			
 
				+ *
			
 
				+ * Similarly, there is no error returned since the listpack normally can be
			
 
				+ * assumed to be valid, so that would be a very high API cost. However a function
			
 
				+ * in order to check the integrity of the listpack at load time is provided,
			
 
				+ * check lpIsValid(). */
			
 
				+static inline unsigned char *lpGetWithSize(unsigned char *p, int64_t *count, unsigned char *intbuf, uint64_t *entry_size) {
			
 
				+    int64_t val;
			
 
				+    uint64_t uval, negstart, negmax;
			
 
				+
			
 
				+    assert(p); /* assertion for valgrind (avoid NPD) */
			
 
				+    if (LP_ENCODING_IS_7BIT_UINT(p[0])) {
			
 
				+        negstart = UINT64_MAX; /* 7 bit ints are always positive. */
			
 
				+        negmax = 0;
			
 
				+        uval = p[0] & 0x7f;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_7BIT_UINT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_6BIT_STR(p[0])) {
			
 
				+        *count = LP_ENCODING_6BIT_STR_LEN(p);
			
 
				+        if (entry_size) *entry_size = 1 + *count + lpEncodeBacklen(NULL, *count + 1);
			
 
				+        return p+1;
			
 
				+    } else if (LP_ENCODING_IS_13BIT_INT(p[0])) {
			
 
				+        uval = ((p[0]&0x1f)<<8) | p[1];
			
 
				+        negstart = (uint64_t)1<<12;
			
 
				+        negmax = 8191;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_13BIT_INT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_16BIT_INT(p[0])) {
			
 
				+        uval = (uint64_t)p[1] |
			
 
				+               (uint64_t)p[2]<<8;
			
 
				+        negstart = (uint64_t)1<<15;
			
 
				+        negmax = UINT16_MAX;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_16BIT_INT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_24BIT_INT(p[0])) {
			
 
				+        uval = (uint64_t)p[1] |
			
 
				+               (uint64_t)p[2]<<8 |
			
 
				+               (uint64_t)p[3]<<16;
			
 
				+        negstart = (uint64_t)1<<23;
			
 
				+        negmax = UINT32_MAX>>8;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_24BIT_INT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_32BIT_INT(p[0])) {
			
 
				+        uval = (uint64_t)p[1] |
			
 
				+               (uint64_t)p[2]<<8 |
			
 
				+               (uint64_t)p[3]<<16 |
			
 
				+               (uint64_t)p[4]<<24;
			
 
				+        negstart = (uint64_t)1<<31;
			
 
				+        negmax = UINT32_MAX;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_32BIT_INT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_64BIT_INT(p[0])) {
			
 
				+        uval = (uint64_t)p[1] |
			
 
				+               (uint64_t)p[2]<<8 |
			
 
				+               (uint64_t)p[3]<<16 |
			
 
				+               (uint64_t)p[4]<<24 |
			
 
				+               (uint64_t)p[5]<<32 |
			
 
				+               (uint64_t)p[6]<<40 |
			
 
				+               (uint64_t)p[7]<<48 |
			
 
				+               (uint64_t)p[8]<<56;
			
 
				+        negstart = (uint64_t)1<<63;
			
 
				+        negmax = UINT64_MAX;
			
 
				+        if (entry_size) *entry_size = LP_ENCODING_64BIT_INT_ENTRY_SIZE;
			
 
				+    } else if (LP_ENCODING_IS_12BIT_STR(p[0])) {
			
 
				+        *count = LP_ENCODING_12BIT_STR_LEN(p);
			
 
				+        if (entry_size) *entry_size = 2 + *count + lpEncodeBacklen(NULL, *count + 2);
			
 
				+        return p+2;
			
 
				+    } else if (LP_ENCODING_IS_32BIT_STR(p[0])) {
			
 
				+        *count = LP_ENCODING_32BIT_STR_LEN(p);
			
 
				+        if (entry_size) *entry_size = 5 + *count + lpEncodeBacklen(NULL, *count + 5);
			
 
				+        return p+5;
			
 
				+    } else {
			
 
				+        uval = 12345678900000000ULL + p[0];
			
 
				+        negstart = UINT64_MAX;
			
 
				+        negmax = 0;
			
 
				+    }
			
 
				+
			
 
				+    /* We reach this code path only for integer encodings.
			
 
				+     * Convert the unsigned value to the signed one using two's complement
			
 
				+     * rule. */
			
 
				+    if (uval >= negstart) {
			
 
				+        /* This three steps conversion should avoid undefined behaviors
			
 
				+         * in the unsigned -> signed conversion. */
			
 
				+        uval = negmax-uval;
			
 
				+        val = uval;
			
 
				+        val = -val-1;
			
 
				+    } else {
			
 
				+        val = uval;
			
 
				+    }
			
 
				+
			
 
				+    /* Return the string representation of the integer or the value itself
			
 
				+     * depending on intbuf being NULL or not. */
			
 
				+    if (intbuf) {
			
 
				+        *count = ll2string((char*)intbuf,LP_INTBUF_SIZE,(long long)val);
			
 
				+        return intbuf;
			
 
				+    } else {
			
 
				+        *count = val;
			
 
				+        return NULL;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
			
 
				+    return lpGetWithSize(p, count, intbuf, NULL);
			
 
				+}
			
 
				+
			
 
				+/* This is just a wrapper to lpGet() that is able to get entry value directly.
			
 
				+ * When the function returns NULL, it populates the integer value by reference in 'lval'.
			
 
				+ * Otherwise if the element is encoded as a string a pointer to the string (pointing
			
 
				+ * inside the listpack itself) is returned, and 'slen' is set to the length of the
			
 
				+ * string. */
			
 
				+unsigned char *lpGetValue(unsigned char *p, unsigned int *slen, long long *lval) {
			
 
				+    unsigned char *vstr;
			
 
				+    int64_t ele_len;
			
 
				+
			
 
				+    vstr = lpGet(p, &ele_len, NULL);
			
 
				+    if (vstr) {
			
 
				+        *slen = ele_len;
			
 
				+    } else {
			
 
				+        *lval = ele_len;
			
 
				+    }
			
 
				+    return vstr;
			
 
				+}
			
 
				+
			
 
				+/* Find pointer to the entry equal to the specified entry. Skip 'skip' entries
			
 
				+ * between every comparison. Returns NULL when the field could not be found. */
			
 
				+unsigned char *lpFind(unsigned char *lp, unsigned char *p, unsigned char *s, 
			
 
				+                      uint32_t slen, unsigned int skip) {
			
 
				+    int skipcnt = 0;
			
 
				+    unsigned char vencoding = 0;
			
 
				+    unsigned char *value;
			
 
				+    int64_t ll, vll;
			
 
				+    uint64_t entry_size = 123456789; /* initialized to avoid warning. */
			
 
				+    uint32_t lp_bytes = lpBytes(lp);
			
 
				+
			
 
				+    assert(p);
			
 
				+    while (p) {
			
 
				+        if (skipcnt == 0) {
			
 
				+            value = lpGetWithSize(p, &ll, NULL, &entry_size);
			
 
				+            if (value) {
			
 
				+                /* check the value doesn't reach outside the listpack before accessing it */
			
 
				+                assert(p >= lp + LP_HDR_SIZE && p + entry_size < lp + lp_bytes);
			
 
				+                if (slen == ll && memcmp(value, s, slen) == 0) {
			
 
				+                    return p;
			
 
				+                }
			
 
				+            } else {
			
 
				+                /* Find out if the searched field can be encoded. Note that
			
 
				+                 * we do it only the first time, once done vencoding is set
			
 
				+                 * to non-zero and vll is set to the integer value. */
			
 
				+                if (vencoding == 0) {
			
 
				+                    /* If the entry can be encoded as integer we set it to
			
 
				+                     * 1, else set it to UCHAR_MAX, so that we don't retry
			
 
				+                     * again the next time. */
			
 
				+                    if (slen >= 32 || slen == 0 || !lpStringToInt64((const char*)s, slen, &vll)) {
			
 
				+                        vencoding = UCHAR_MAX;
			
 
				+                    } else {
			
 
				+                        vencoding = 1;
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                /* Compare current entry with specified entry, do it only
			
 
				+                 * if vencoding != UCHAR_MAX because if there is no encoding
			
 
				+                 * possible for the field it can't be a valid integer. */
			
 
				+                if (vencoding != UCHAR_MAX && ll == vll) {
			
 
				+                    return p;
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            /* Reset skip count */
			
 
				+            skipcnt = skip;
			
 
				+            p += entry_size;
			
 
				+        } else {
			
 
				+            /* Skip entry */
			
 
				+            skipcnt--;
			
 
				+
			
 
				+            /* Move to next entry, avoid use `lpNext` due to `ASSERT_INTEGRITY` in
			
 
				+            * `lpNext` will call `lpBytes`, will cause performance degradation */
			
 
				+            p = lpSkip(p);
			
 
				+        }
			
 
				+
			
 
				+        /* The next call to lpGetWithSize could read at most 8 bytes past `p`
			
 
				+         * We use the slower validation call only when necessary. */
			
 
				+        if (p + 8 >= lp + lp_bytes)
			
 
				+            lpAssertValidEntry(lp, lp_bytes, p);
			
 
				+        else
			
 
				+            assert(p >= lp + LP_HDR_SIZE && p < lp + lp_bytes);
			
 
				+        if (p[0] == LP_EOF) break;
			
 
				+    }
			
 
				+
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* Insert, delete or replace the specified string element 'elestr' of length
			
 
				+ * 'size' or integer element 'eleint' at the specified position 'p', with 'p'
			
 
				+ * being a listpack element pointer obtained with lpFirst(), lpLast(), lpNext(),
			
 
				+ * lpPrev() or lpSeek().
			
 
				+ *
			
 
				+ * The element is inserted before, after, or replaces the element pointed
			
 
				+ * by 'p' depending on the 'where' argument, that can be LP_BEFORE, LP_AFTER
			
 
				+ * or LP_REPLACE.
			
 
				+ * 
			
 
				+ * If both 'elestr' and `eleint` are NULL, the function removes the element
			
 
				+ * pointed by 'p' instead of inserting one.
			
 
				+ * If `eleint` is non-NULL, 'size' is the length of 'eleint', the function insert
			
 
				+ * or replace with a 64 bit integer, which is stored in the 'eleint' buffer.
			
 
				+ * If 'elestr` is non-NULL, 'size' is the length of 'elestr', the function insert
			
 
				+ * or replace with a string, which is stored in the 'elestr' buffer.
			
 
				+ * 
			
 
				+ * Returns NULL on out of memory or when the listpack total length would exceed
			
 
				+ * the max allowed size of 2^32-1, otherwise the new pointer to the listpack
			
 
				+ * holding the new element is returned (and the old pointer passed is no longer
			
 
				+ * considered valid)
			
 
				+ *
			
 
				+ * If 'newp' is not NULL, at the end of a successful call '*newp' will be set
			
 
				+ * to the address of the element just added, so that it will be possible to
			
 
				+ * continue an interaction with lpNext() and lpPrev().
			
 
				+ *
			
 
				+ * For deletion operations (both 'elestr' and 'eleint' set to NULL) 'newp' is
			
 
				+ * set to the next element, on the right of the deleted one, or to NULL if the
			
 
				+ * deleted element was the last one. */
			
 
				+unsigned char *lpInsert(unsigned char *lp, unsigned char *elestr, unsigned char *eleint,
			
 
				+                        uint32_t size, unsigned char *p, int where, unsigned char **newp)
			
 
				+{
			
 
				+    unsigned char intenc[LP_MAX_INT_ENCODING_LEN];
			
 
				+    unsigned char backlen[LP_MAX_BACKLEN_SIZE];
			
 
				+
			
 
				+    uint64_t enclen; /* The length of the encoded element. */
			
 
				+    int delete = (elestr == NULL && eleint == NULL);
			
 
				+
			
 
				+    /* when deletion, it is conceptually replacing the element with a
			
 
				+     * zero-length element. So whatever we get passed as 'where', set
			
 
				+     * it to LP_REPLACE. */
			
 
				+    if (delete) where = LP_REPLACE;
			
 
				+
			
 
				+    /* If we need to insert after the current element, we just jump to the
			
 
				+     * next element (that could be the EOF one) and handle the case of
			
 
				+     * inserting before. So the function will actually deal with just two
			
 
				+     * cases: LP_BEFORE and LP_REPLACE. */
			
 
				+    if (where == LP_AFTER) {
			
 
				+        p = lpSkip(p);
			
 
				+        where = LP_BEFORE;
			
 
				+        ASSERT_INTEGRITY(lp, p);
			
 
				+    }
			
 
				+
			
 
				+    /* Store the offset of the element 'p', so that we can obtain its
			
 
				+     * address again after a reallocation. */
			
 
				+    unsigned long poff = p-lp;
			
 
				+
			
 
				+    int enctype;
			
 
				+    if (elestr) {
			
 
				+        /* Calling lpEncodeGetType() results into the encoded version of the
			
 
				+        * element to be stored into 'intenc' in case it is representable as
			
 
				+        * an integer: in that case, the function returns LP_ENCODING_INT.
			
 
				+        * Otherwise if LP_ENCODING_STR is returned, we'll have to call
			
 
				+        * lpEncodeString() to actually write the encoded string on place later.
			
 
				+        *
			
 
				+        * Whatever the returned encoding is, 'enclen' is populated with the
			
 
				+        * length of the encoded element. */
			
 
				+        enctype = lpEncodeGetType(elestr,size,intenc,&enclen);
			
 
				+        if (enctype == LP_ENCODING_INT) eleint = intenc;
			
 
				+    } else if (eleint) {
			
 
				+        enctype = LP_ENCODING_INT;
			
 
				+        enclen = size; /* 'size' is the length of the encoded integer element. */
			
 
				+    } else {
			
 
				+        enctype = -1;
			
 
				+        enclen = 0;
			
 
				+    }
			
 
				+
			
 
				+    /* We need to also encode the backward-parsable length of the element
			
 
				+     * and append it to the end: this allows to traverse the listpack from
			
 
				+     * the end to the start. */
			
 
				+    unsigned long backlen_size = (!delete) ? lpEncodeBacklen(backlen,enclen) : 0;
			
 
				+    uint64_t old_listpack_bytes = lpGetTotalBytes(lp);
			
 
				+    uint32_t replaced_len  = 0;
			
 
				+    if (where == LP_REPLACE) {
			
 
				+        replaced_len = lpCurrentEncodedSizeUnsafe(p);
			
 
				+        replaced_len += lpEncodeBacklen(NULL,replaced_len);
			
 
				+        ASSERT_INTEGRITY_LEN(lp, p, replaced_len);
			
 
				+    }
			
 
				+
			
 
				+    uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
			
 
				+                                  - replaced_len;
			
 
				+    if (new_listpack_bytes > UINT32_MAX) return NULL;
			
 
				+
			
 
				+    /* We now need to reallocate in order to make space or shrink the
			
 
				+     * allocation (in case 'when' value is LP_REPLACE and the new element is
			
 
				+     * smaller). However we do that before memmoving the memory to
			
 
				+     * make room for the new element if the final allocation will get
			
 
				+     * larger, or we do it after if the final allocation will get smaller. */
			
 
				+
			
 
				+    unsigned char *dst = lp + poff; /* May be updated after reallocation. */
			
 
				+
			
 
				+    /* Realloc before: we need more room. */
			
 
				+    if (new_listpack_bytes > old_listpack_bytes &&
			
 
				+        new_listpack_bytes > lp_malloc_size(lp)) {
			
 
				+        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
			
 
				+        dst = lp + poff;
			
 
				+    }
			
 
				+
			
 
				+    /* Setup the listpack relocating the elements to make the exact room
			
 
				+     * we need to store the new one. */
			
 
				+    if (where == LP_BEFORE) {
			
 
				+        memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
			
 
				+    } else { /* LP_REPLACE. */
			
 
				+        long lendiff = (enclen+backlen_size)-replaced_len;
			
 
				+        memmove(dst+replaced_len+lendiff,
			
 
				+                dst+replaced_len,
			
 
				+                old_listpack_bytes-poff-replaced_len);
			
 
				+    }
			
 
				+
			
 
				+    /* Realloc after: we need to free space. */
			
 
				+    if (new_listpack_bytes < old_listpack_bytes) {
			
 
				+        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
			
 
				+        dst = lp + poff;
			
 
				+    }
			
 
				+
			
 
				+    /* Store the entry. */
			
 
				+    if (newp) {
			
 
				+        *newp = dst;
			
 
				+        /* In case of deletion, set 'newp' to NULL if the next element is
			
 
				+         * the EOF element. */
			
 
				+        if (delete && dst[0] == LP_EOF) *newp = NULL;
			
 
				+    }
			
 
				+    if (!delete) {
			
 
				+        if (enctype == LP_ENCODING_INT) {
			
 
				+            memcpy(dst,eleint,enclen);
			
 
				+        } else {
			
 
				+            lpEncodeString(dst,elestr,size);
			
 
				+        }
			
 
				+        dst += enclen;
			
 
				+        memcpy(dst,backlen,backlen_size);
			
 
				+        dst += backlen_size;
			
 
				+    }
			
 
				+
			
 
				+    /* Update header. */
			
 
				+    if (where != LP_REPLACE || delete) {
			
 
				+        uint32_t num_elements = lpGetNumElements(lp);
			
 
				+        if (num_elements != LP_HDR_NUMELE_UNKNOWN) {
			
 
				+            if (!delete)
			
 
				+                lpSetNumElements(lp,num_elements+1);
			
 
				+            else
			
 
				+                lpSetNumElements(lp,num_elements-1);
			
 
				+        }
			
 
				+    }
			
 
				+    lpSetTotalBytes(lp,new_listpack_bytes);
			
 
				+
			
 
				+#if 0
			
 
				+    /* This code path is normally disabled: what it does is to force listpack
			
 
				+     * to return *always* a new pointer after performing some modification to
			
 
				+     * the listpack, even if the previous allocation was enough. This is useful
			
 
				+     * in order to spot bugs in code using listpacks: by doing so we can find
			
 
				+     * if the caller forgets to set the new pointer where the listpack reference
			
 
				+     * is stored, after an update. */
			
 
				+    unsigned char *oldlp = lp;
			
 
				+    lp = lp_malloc(new_listpack_bytes);
			
 
				+    memcpy(lp,oldlp,new_listpack_bytes);
			
 
				+    if (newp) {
			
 
				+        unsigned long offset = (*newp)-oldlp;
			
 
				+        *newp = lp + offset;
			
 
				+    }
			
 
				+    /* Make sure the old allocation contains garbage. */
			
 
				+    memset(oldlp,'A',new_listpack_bytes);
			
 
				+    lp_free(oldlp);
			
 
				+#endif
			
 
				+
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+/* This is just a wrapper for lpInsert() to directly use a string. */
			
 
				+unsigned char *lpInsertString(unsigned char *lp, unsigned char *s, uint32_t slen,
			
 
				+                              unsigned char *p, int where, unsigned char **newp)
			
 
				+{
			
 
				+    return lpInsert(lp, s, NULL, slen, p, where, newp);
			
 
				+}
			
 
				+
			
 
				+/* This is just a wrapper for lpInsert() to directly use a 64 bit integer
			
 
				+ * instead of a string. */
			
 
				+unsigned char *lpInsertInteger(unsigned char *lp, long long lval, unsigned char *p, int where, unsigned char **newp) {
			
 
				+    uint64_t enclen; /* The length of the encoded element. */
			
 
				+    unsigned char intenc[LP_MAX_INT_ENCODING_LEN];
			
 
				+
			
 
				+    lpEncodeIntegerGetType(lval, intenc, &enclen);
			
 
				+    return lpInsert(lp, NULL, intenc, enclen, p, where, newp);
			
 
				+}
			
 
				+
			
 
				+/* Append the specified element 's' of length 'slen' at the head of the listpack. */
			
 
				+unsigned char *lpPrepend(unsigned char *lp, unsigned char *s, uint32_t slen) {
			
 
				+    unsigned char *p = lpFirst(lp);
			
 
				+    if (!p) return lpAppend(lp, s, slen);
			
 
				+    return lpInsert(lp, s, NULL, slen, p, LP_BEFORE, NULL);
			
 
				+}
			
 
				+
			
 
				+/* Append the specified integer element 'lval' at the head of the listpack. */
			
 
				+unsigned char *lpPrependInteger(unsigned char *lp, long long lval) {
			
 
				+    unsigned char *p = lpFirst(lp);
			
 
				+    if (!p) return lpAppendInteger(lp, lval);
			
 
				+    return lpInsertInteger(lp, lval, p, LP_BEFORE, NULL);
			
 
				+}
			
 
				+
			
 
				+/* Append the specified element 'ele' of length 'len' at the end of the
			
 
				+ * listpack. It is implemented in terms of lpInsert(), so the return value is
			
 
				+ * the same as lpInsert(). */
			
 
				+unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size) {
			
 
				+    uint64_t listpack_bytes = lpGetTotalBytes(lp);
			
 
				+    unsigned char *eofptr = lp + listpack_bytes - 1;
			
 
				+    return lpInsert(lp,ele,NULL,size,eofptr,LP_BEFORE,NULL);
			
 
				+}
			
 
				+
			
 
				+/* Append the specified integer element 'lval' at the end of the listpack. */
			
 
				+unsigned char *lpAppendInteger(unsigned char *lp, long long lval) {
			
 
				+    uint64_t listpack_bytes = lpGetTotalBytes(lp);
			
 
				+    unsigned char *eofptr = lp + listpack_bytes - 1;
			
 
				+    return lpInsertInteger(lp, lval, eofptr, LP_BEFORE, NULL);
			
 
				+}
			
 
				+
			
 
				+/* This is just a wrapper for lpInsert() to directly use a string to replace
			
 
				+ * the current element. The function returns the new listpack as return
			
 
				+ * value, and also updates the current cursor by updating '*p'. */
			
 
				+unsigned char *lpReplace(unsigned char *lp, unsigned char **p, unsigned char *s, uint32_t slen) {
			
 
				+    return lpInsert(lp, s, NULL, slen, *p, LP_REPLACE, p);
			
 
				+}
			
 
				+
			
 
				+/* This is just a wrapper for lpInsertInteger() to directly use a 64 bit integer
			
 
				+ * instead of a string to replace the current element. The function returns
			
 
				+ * the new listpack as return value, and also updates the current cursor
			
 
				+ * by updating '*p'. */
			
 
				+unsigned char *lpReplaceInteger(unsigned char *lp, unsigned char **p, long long lval) {
			
 
				+    return lpInsertInteger(lp, lval, *p, LP_REPLACE, p);
			
 
				+}
			
 
				+
			
 
				+/* Remove the element pointed by 'p', and return the resulting listpack.
			
 
				+ * If 'newp' is not NULL, the next element pointer (to the right of the
			
 
				+ * deleted one) is returned by reference. If the deleted element was the
			
 
				+ * last one, '*newp' is set to NULL. */
			
 
				+unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp) {
			
 
				+    return lpInsert(lp,NULL,NULL,0,p,LP_REPLACE,newp);
			
 
				+}
			
 
				+
			
 
				+/* Delete a range of entries from the listpack start with the element pointed by 'p'. */
			
 
				+unsigned char *lpDeleteRangeWithEntry(unsigned char *lp, unsigned char **p, unsigned long num) {
			
 
				+    size_t bytes = lpBytes(lp);
			
 
				+    unsigned long deleted = 0;
			
 
				+    unsigned char *eofptr = lp + bytes - 1;
			
 
				+    unsigned char *first, *tail;
			
 
				+    first = tail = *p;
			
 
				+
			
 
				+    if (num == 0) return lp;  /* Nothing to delete, return ASAP. */
			
 
				+
			
 
				+    /* Find the next entry to the last entry that needs to be deleted.
			
 
				+     * lpLength may be unreliable due to corrupt data, so we cannot
			
 
				+     * treat 'num' as the number of elements to be deleted. */
			
 
				+    while (num--) {
			
 
				+        deleted++;
			
 
				+        tail = lpSkip(tail);
			
 
				+        if (tail[0] == LP_EOF) break;
			
 
				+        lpAssertValidEntry(lp, bytes, tail);
			
 
				+    }
			
 
				+
			
 
				+    /* Store the offset of the element 'first', so that we can obtain its
			
 
				+     * address again after a reallocation. */
			
 
				+    unsigned long poff = first-lp;
			
 
				+
			
 
				+    /* Move tail to the front of the listpack */
			
 
				+    memmove(first, tail, eofptr - tail + 1);
			
 
				+    lpSetTotalBytes(lp, bytes - (tail - first));
			
 
				+    uint32_t numele = lpGetNumElements(lp);
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN)
			
 
				+        lpSetNumElements(lp, numele-deleted);
			
 
				+    lp = lpShrinkToFit(lp);
			
 
				+
			
 
				+    /* Store the entry. */
			
 
				+    *p = lp+poff;
			
 
				+    if ((*p)[0] == LP_EOF) *p = NULL;
			
 
				+
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+/* Delete a range of entries from the listpack. */
			
 
				+unsigned char *lpDeleteRange(unsigned char *lp, long index, unsigned long num) {
			
 
				+    unsigned char *p;
			
 
				+    uint32_t numele = lpGetNumElements(lp);
			
 
				+
			
 
				+    if (num == 0) return lp; /* Nothing to delete, return ASAP. */
			
 
				+    if ((p = lpSeek(lp, index)) == NULL) return lp;
			
 
				+
			
 
				+    /* If we know we're gonna delete beyond the end of the listpack, we can just move
			
 
				+     * the EOF marker, and there's no need to iterate through the entries,
			
 
				+     * but if we can't be sure how many entries there are, we rather avoid calling lpLength
			
 
				+     * since that means an additional iteration on all elements.
			
 
				+     *
			
 
				+     * Note that index could overflow, but we use the value after seek, so when we
			
 
				+     * use it no overflow happens. */
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN && index < 0) index = (long)numele + index;
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN && (numele - (unsigned long)index) <= num) {
			
 
				+        p[0] = LP_EOF;
			
 
				+        lpSetTotalBytes(lp, p - lp + 1);
			
 
				+        lpSetNumElements(lp, index);
			
 
				+        lp = lpShrinkToFit(lp);
			
 
				+    } else {
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &p, num);
			
 
				+    }
			
 
				+
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+/* Merge listpacks 'first' and 'second' by appending 'second' to 'first'.
			
 
				+ *
			
 
				+ * NOTE: The larger listpack is reallocated to contain the new merged listpack.
			
 
				+ * Either 'first' or 'second' can be used for the result.  The parameter not
			
 
				+ * used will be free'd and set to NULL.
			
 
				+ *
			
 
				+ * After calling this function, the input parameters are no longer valid since
			
 
				+ * they are changed and free'd in-place.
			
 
				+ *
			
 
				+ * The result listpack is the contents of 'first' followed by 'second'.
			
 
				+ *
			
 
				+ * On failure: returns NULL if the merge is impossible.
			
 
				+ * On success: returns the merged listpack (which is expanded version of either
			
 
				+ * 'first' or 'second', also frees the other unused input listpack, and sets the
			
 
				+ * input listpack argument equal to newly reallocated listpack return value. */
			
 
				+unsigned char *lpMerge(unsigned char **first, unsigned char **second) {
			
 
				+    /* If any params are null, we can't merge, so NULL. */
			
 
				+    if (first == NULL || *first == NULL || second == NULL || *second == NULL)
			
 
				+        return NULL;
			
 
				+
			
 
				+    /* Can't merge same list into itself. */
			
 
				+    if (*first == *second)
			
 
				+        return NULL;
			
 
				+
			
 
				+    size_t first_bytes = lpBytes(*first);
			
 
				+    unsigned long first_len = lpLength(*first);
			
 
				+
			
 
				+    size_t second_bytes = lpBytes(*second);
			
 
				+    unsigned long second_len = lpLength(*second);
			
 
				+
			
 
				+    int append;
			
 
				+    unsigned char *source, *target;
			
 
				+    size_t target_bytes, source_bytes;
			
 
				+    /* Pick the largest listpack so we can resize easily in-place.
			
 
				+     * We must also track if we are now appending or prepending to
			
 
				+     * the target listpack. */
			
 
				+    if (first_bytes >= second_bytes) {
			
 
				+        /* retain first, append second to first. */
			
 
				+        target = *first;
			
 
				+        target_bytes = first_bytes;
			
 
				+        source = *second;
			
 
				+        source_bytes = second_bytes;
			
 
				+        append = 1;
			
 
				+    } else {
			
 
				+        /* else, retain second, prepend first to second. */
			
 
				+        target = *second;
			
 
				+        target_bytes = second_bytes;
			
 
				+        source = *first;
			
 
				+        source_bytes = first_bytes;
			
 
				+        append = 0;
			
 
				+    }
			
 
				+
			
 
				+    /* Calculate final bytes (subtract one pair of metadata) */
			
 
				+    unsigned long long lpbytes = (unsigned long long)first_bytes + second_bytes - LP_HDR_SIZE - 1;
			
 
				+    assert(lpbytes < UINT32_MAX); /* larger values can't be stored */
			
 
				+    unsigned long lplength = first_len + second_len;
			
 
				+
			
 
				+    /* Combined lp length should be limited within UINT16_MAX */
			
 
				+    lplength = lplength < UINT16_MAX ? lplength : UINT16_MAX;
			
 
				+
			
 
				+    /* Extend target to new lpbytes then append or prepend source. */
			
 
				+    target = zrealloc(target, lpbytes);
			
 
				+    if (append) {
			
 
				+        /* append == appending to target */
			
 
				+        /* Copy source after target (copying over original [END]):
			
 
				+         *   [TARGET - END, SOURCE - HEADER] */
			
 
				+        memcpy(target + target_bytes - 1,
			
 
				+               source + LP_HDR_SIZE,
			
 
				+               source_bytes - LP_HDR_SIZE);
			
 
				+    } else {
			
 
				+        /* !append == prepending to target */
			
 
				+        /* Move target *contents* exactly size of (source - [END]),
			
 
				+         * then copy source into vacated space (source - [END]):
			
 
				+         *   [SOURCE - END, TARGET - HEADER] */
			
 
				+        memmove(target + source_bytes - 1,
			
 
				+                target + LP_HDR_SIZE,
			
 
				+                target_bytes - LP_HDR_SIZE);
			
 
				+        memcpy(target, source, source_bytes - 1);
			
 
				+    }
			
 
				+
			
 
				+    lpSetNumElements(target, lplength);
			
 
				+    lpSetTotalBytes(target, lpbytes);
			
 
				+
			
 
				+    /* Now free and NULL out what we didn't realloc */
			
 
				+    if (append) {
			
 
				+        zfree(*second);
			
 
				+        *second = NULL;
			
 
				+        *first = target;
			
 
				+    } else {
			
 
				+        zfree(*first);
			
 
				+        *first = NULL;
			
 
				+        *second = target;
			
 
				+    }
			
 
				+
			
 
				+    return target;
			
 
				+}
			
 
				+
			
 
				+/* Return the total number of bytes the listpack is composed of. */
			
 
				+size_t lpBytes(unsigned char *lp) {
			
 
				+    return lpGetTotalBytes(lp);
			
 
				+}
			
 
				+
			
 
				+/* Seek the specified element and returns the pointer to the seeked element.
			
 
				+ * Positive indexes specify the zero-based element to seek from the head to
			
 
				+ * the tail, negative indexes specify elements starting from the tail, where
			
 
				+ * -1 means the last element, -2 the penultimate and so forth. If the index
			
 
				+ * is out of range, NULL is returned. */
			
 
				+unsigned char *lpSeek(unsigned char *lp, long index) {
			
 
				+    int forward = 1; /* Seek forward by default. */
			
 
				+
			
 
				+    /* We want to seek from left to right or the other way around
			
 
				+     * depending on the listpack length and the element position.
			
 
				+     * However if the listpack length cannot be obtained in constant time,
			
 
				+     * we always seek from left to right. */
			
 
				+    uint32_t numele = lpGetNumElements(lp);
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN) {
			
 
				+        if (index < 0) index = (long)numele+index;
			
 
				+        if (index < 0) return NULL; /* Index still < 0 means out of range. */
			
 
				+        if (index >= (long)numele) return NULL; /* Out of range the other side. */
			
 
				+        /* We want to scan right-to-left if the element we are looking for
			
 
				+         * is past the half of the listpack. */
			
 
				+        if (index > (long)numele/2) {
			
 
				+            forward = 0;
			
 
				+            /* Right to left scanning always expects a negative index. Convert
			
 
				+             * our index to negative form. */
			
 
				+            index -= numele;
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* If the listpack length is unspecified, for negative indexes we
			
 
				+         * want to always scan right-to-left. */
			
 
				+        if (index < 0) forward = 0;
			
 
				+    }
			
 
				+
			
 
				+    /* Forward and backward scanning is trivially based on lpNext()/lpPrev(). */
			
 
				+    if (forward) {
			
 
				+        unsigned char *ele = lpFirst(lp);
			
 
				+        while (index > 0 && ele) {
			
 
				+            ele = lpNext(lp,ele);
			
 
				+            index--;
			
 
				+        }
			
 
				+        return ele;
			
 
				+    } else {
			
 
				+        unsigned char *ele = lpLast(lp);
			
 
				+        while (index < -1 && ele) {
			
 
				+            ele = lpPrev(lp,ele);
			
 
				+            index++;
			
 
				+        }
			
 
				+        return ele;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Same as lpFirst but without validation assert, to be used right before lpValidateNext. */
			
 
				+unsigned char *lpValidateFirst(unsigned char *lp) {
			
 
				+    unsigned char *p = lp + LP_HDR_SIZE; /* Skip the header. */
			
 
				+    if (p[0] == LP_EOF) return NULL;
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* Validate the integrity of a single listpack entry and move to the next one.
			
 
				+ * The input argument 'pp' is a reference to the current record and is advanced on exit.
			
 
				+ * Returns 1 if valid, 0 if invalid. */
			
 
				+int lpValidateNext(unsigned char *lp, unsigned char **pp, size_t lpbytes) {
			
 
				+#define OUT_OF_RANGE(p) ( \
			
 
				+        (p) < lp + LP_HDR_SIZE || \
			
 
				+        (p) > lp + lpbytes - 1)
			
 
				+    unsigned char *p = *pp;
			
 
				+    if (!p)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Before accessing p, make sure it's valid. */
			
 
				+    if (OUT_OF_RANGE(p))
			
 
				+        return 0;
			
 
				+
			
 
				+    if (*p == LP_EOF) {
			
 
				+        *pp = NULL;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* check that we can read the encoded size */
			
 
				+    uint32_t lenbytes = lpCurrentEncodedSizeBytes(p);
			
 
				+    if (!lenbytes)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* make sure the encoded entry length doesn't reach outside the edge of the listpack */
			
 
				+    if (OUT_OF_RANGE(p + lenbytes))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* get the entry length and encoded backlen. */
			
 
				+    unsigned long entrylen = lpCurrentEncodedSizeUnsafe(p);
			
 
				+    unsigned long encodedBacklen = lpEncodeBacklen(NULL,entrylen);
			
 
				+    entrylen += encodedBacklen;
			
 
				+
			
 
				+    /* make sure the entry doesn't reach outside the edge of the listpack */
			
 
				+    if (OUT_OF_RANGE(p + entrylen))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* move to the next entry */
			
 
				+    p += entrylen;
			
 
				+
			
 
				+    /* make sure the encoded length at the end patches the one at the beginning. */
			
 
				+    uint64_t prevlen = lpDecodeBacklen(p-1);
			
 
				+    if (prevlen + encodedBacklen != entrylen)
			
 
				+        return 0;
			
 
				+
			
 
				+    *pp = p;
			
 
				+    return 1;
			
 
				+#undef OUT_OF_RANGE
			
 
				+}
			
 
				+
			
 
				+/* Validate that the entry doesn't reach outside the listpack allocation. */
			
 
				+static inline void lpAssertValidEntry(unsigned char* lp, size_t lpbytes, unsigned char *p) {
			
 
				+    assert(lpValidateNext(lp, &p, lpbytes));
			
 
				+}
			
 
				+
			
 
				+/* Validate the integrity of the data structure.
			
 
				+ * when `deep` is 0, only the integrity of the header is validated.
			
 
				+ * when `deep` is 1, we scan all the entries one by one. */
			
 
				+int lpValidateIntegrity(unsigned char *lp, size_t size, int deep, 
			
 
				+                        listpackValidateEntryCB entry_cb, void *cb_userdata) {
			
 
				+    /* Check that we can actually read the header. (and EOF) */
			
 
				+    if (size < LP_HDR_SIZE + 1)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Check that the encoded size in the header must match the allocated size. */
			
 
				+    size_t bytes = lpGetTotalBytes(lp);
			
 
				+    if (bytes != size)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* The last byte must be the terminator. */
			
 
				+    if (lp[size-1] != LP_EOF)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (!deep)
			
 
				+        return 1;
			
 
				+
			
 
				+    /* Validate the individual entries. */
			
 
				+    uint32_t count = 0;
			
 
				+    uint32_t numele = lpGetNumElements(lp);
			
 
				+    unsigned char *p = lp + LP_HDR_SIZE;
			
 
				+    while(p && p[0] != LP_EOF) {
			
 
				+        unsigned char *prev = p;
			
 
				+
			
 
				+        /* Validate this entry and move to the next entry in advance
			
 
				+         * to avoid callback crash due to corrupt listpack. */
			
 
				+        if (!lpValidateNext(lp, &p, bytes))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* Optionally let the caller validate the entry too. */
			
 
				+        if (entry_cb && !entry_cb(prev, numele, cb_userdata))
			
 
				+            return 0;
			
 
				+
			
 
				+        count++;
			
 
				+    }
			
 
				+
			
 
				+    /* Check that the count in the header is correct */
			
 
				+    if (numele != LP_HDR_NUMELE_UNKNOWN && numele != count)
			
 
				+        return 0;
			
 
				+
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Compare entry pointer to by 'p' with string 's' of length 'slen'.
			
 
				+ * Return 1 if equal. */
			
 
				+unsigned int lpCompare(unsigned char *p, unsigned char *s, uint32_t slen) {
			
 
				+    unsigned char *value;
			
 
				+    int64_t sz;
			
 
				+    if (p[0] == LP_EOF) return 0;
			
 
				+
			
 
				+    value = lpGet(p, &sz, NULL);
			
 
				+    if (value) {
			
 
				+        return (slen == sz) && memcmp(value,s,slen) == 0;
			
 
				+    } else {
			
 
				+        /* We use lpStringToInt64() to get an integer representation of the
			
 
				+         * string 's' and compare it to 'sval', it's much faster than convert
			
 
				+         * integer to string and comparing. */
			
 
				+        int64_t sval;
			
 
				+        if (lpStringToInt64((const char*)s, slen, &sval))
			
 
				+            return sz == sval;
			
 
				+    }
			
 
				+
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* uint compare for qsort */
			
 
				+static int uintCompare(const void *a, const void *b) {
			
 
				+    return (*(unsigned int *) a - *(unsigned int *) b);
			
 
				+}
			
 
				+
			
 
				+/* Helper method to store a string into from val or lval into dest */
			
 
				+static inline void lpSaveValue(unsigned char *val, unsigned int len, int64_t lval, listpackEntry *dest) {
			
 
				+    dest->sval = val;
			
 
				+    dest->slen = len;
			
 
				+    dest->lval = lval;
			
 
				+}
			
 
				+
			
 
				+/* Randomly select a pair of key and value.
			
 
				+ * total_count is a pre-computed length/2 of the listpack (to avoid calls to lpLength)
			
 
				+ * 'key' and 'val' are used to store the result key value pair.
			
 
				+ * 'val' can be NULL if the value is not needed. */
			
 
				+void lpRandomPair(unsigned char *lp, unsigned long total_count, listpackEntry *key, listpackEntry *val) {
			
 
				+    unsigned char *p;
			
 
				+
			
 
				+    /* Avoid div by zero on corrupt listpack */
			
 
				+    assert(total_count);
			
 
				+
			
 
				+    /* Generate even numbers, because listpack saved K-V pair */
			
 
				+    int r = (rand() % total_count) * 2;
			
 
				+    assert((p = lpSeek(lp, r)));
			
 
				+    key->sval = lpGetValue(p, &(key->slen), &(key->lval));
			
 
				+
			
 
				+    if (!val)
			
 
				+        return;
			
 
				+    assert((p = lpNext(lp, p)));
			
 
				+    val->sval = lpGetValue(p, &(val->slen), &(val->lval));
			
 
				+}
			
 
				+
			
 
				+/* Randomly select count of key value pairs and store into 'keys' and
			
 
				+ * 'vals' args. The order of the picked entries is random, and the selections
			
 
				+ * are non-unique (repetitions are possible).
			
 
				+ * The 'vals' arg can be NULL in which case we skip these. */
			
 
				+void lpRandomPairs(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals) {
			
 
				+    unsigned char *p, *key, *value;
			
 
				+    unsigned int klen = 0, vlen = 0;
			
 
				+    long long klval = 0, vlval = 0;
			
 
				+
			
 
				+    /* Notice: the index member must be first due to the use in uintCompare */
			
 
				+    typedef struct {
			
 
				+        unsigned int index;
			
 
				+        unsigned int order;
			
 
				+    } rand_pick;
			
 
				+    rand_pick *picks = zmalloc(sizeof(rand_pick)*count);
			
 
				+    unsigned int total_size = lpLength(lp)/2;
			
 
				+
			
 
				+    /* Avoid div by zero on corrupt listpack */
			
 
				+    assert(total_size);
			
 
				+
			
 
				+    /* create a pool of random indexes (some may be duplicate). */
			
 
				+    for (unsigned int i = 0; i < count; i++) {
			
 
				+        picks[i].index = (rand() % total_size) * 2; /* Generate even indexes */
			
 
				+        /* keep track of the order we picked them */
			
 
				+        picks[i].order = i;
			
 
				+    }
			
 
				+
			
 
				+    /* sort by indexes. */
			
 
				+    qsort(picks, count, sizeof(rand_pick), uintCompare);
			
 
				+
			
 
				+    /* fetch the elements form the listpack into a output array respecting the original order. */
			
 
				+    unsigned int lpindex = picks[0].index, pickindex = 0;
			
 
				+    p = lpSeek(lp, lpindex);
			
 
				+    while (p && pickindex < count) {
			
 
				+        key = lpGetValue(p, &klen, &klval);
			
 
				+        assert((p = lpNext(lp, p)));
			
 
				+        value = lpGetValue(p, &vlen, &vlval);
			
 
				+        while (pickindex < count && lpindex == picks[pickindex].index) {
			
 
				+            int storeorder = picks[pickindex].order;
			
 
				+            lpSaveValue(key, klen, klval, &keys[storeorder]);
			
 
				+            if (vals)
			
 
				+                lpSaveValue(value, vlen, vlval, &vals[storeorder]);
			
 
				+             pickindex++;
			
 
				+        }
			
 
				+        lpindex += 2;
			
 
				+        p = lpNext(lp, p);
			
 
				+    }
			
 
				+
			
 
				+    zfree(picks);
			
 
				+}
			
 
				+
			
 
				+/* Randomly select count of key value pairs and store into 'keys' and
			
 
				+ * 'vals' args. The selections are unique (no repetitions), and the order of
			
 
				+ * the picked entries is NOT-random.
			
 
				+ * The 'vals' arg can be NULL in which case we skip these.
			
 
				+ * The return value is the number of items picked which can be lower than the
			
 
				+ * requested count if the listpack doesn't hold enough pairs. */
			
 
				+unsigned int lpRandomPairsUnique(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals) {
			
 
				+    unsigned char *p, *key;
			
 
				+    unsigned int klen = 0;
			
 
				+    long long klval = 0;
			
 
				+    unsigned int total_size = lpLength(lp)/2;
			
 
				+    unsigned int index = 0;
			
 
				+    if (count > total_size)
			
 
				+        count = total_size;
			
 
				+
			
 
				+    /* To only iterate once, every time we try to pick a member, the probability
			
 
				+     * we pick it is the quotient of the count left we want to pick and the
			
 
				+     * count still we haven't visited in the dict, this way, we could make every
			
 
				+     * member be equally picked.*/
			
 
				+    p = lpFirst(lp);
			
 
				+    unsigned int picked = 0, remaining = count;
			
 
				+    while (picked < count && p) {
			
 
				+        double randomDouble = ((double)rand()) / RAND_MAX;
			
 
				+        double threshold = ((double)remaining) / (total_size - index);
			
 
				+        if (randomDouble <= threshold) {
			
 
				+            key = lpGetValue(p, &klen, &klval);
			
 
				+            lpSaveValue(key, klen, klval, &keys[picked]);
			
 
				+            assert((p = lpNext(lp, p)));
			
 
				+            if (vals) {
			
 
				+                key = lpGetValue(p, &klen, &klval);
			
 
				+                lpSaveValue(key, klen, klval, &vals[picked]);
			
 
				+            }
			
 
				+            remaining--;
			
 
				+            picked++;
			
 
				+        } else {
			
 
				+            assert((p = lpNext(lp, p)));
			
 
				+        }
			
 
				+        p = lpNext(lp, p);
			
 
				+        index++;
			
 
				+    }
			
 
				+    return picked;
			
 
				+}
			
 
				+
			
 
				+/* Print info of listpack which is used in debugCommand */
			
 
				+void lpRepr(unsigned char *lp) {
			
 
				+    unsigned char *p, *vstr;
			
 
				+    int64_t vlen;
			
 
				+    unsigned char intbuf[LP_INTBUF_SIZE];
			
 
				+    int index = 0;
			
 
				+
			
 
				+    printf("{total bytes %zu} {num entries %lu}\n", lpBytes(lp), lpLength(lp));
			
 
				+        
			
 
				+    p = lpFirst(lp);
			
 
				+    while(p) {
			
 
				+        uint32_t encoded_size_bytes = lpCurrentEncodedSizeBytes(p);
			
 
				+        uint32_t encoded_size = lpCurrentEncodedSizeUnsafe(p);
			
 
				+        unsigned long back_len = lpEncodeBacklen(NULL, encoded_size);
			
 
				+        printf(
			
 
				+            "{\n"
			
 
				+                "\taddr: 0x%08lx,\n"
			
 
				+                "\tindex: %2d,\n"
			
 
				+                "\toffset: %1lu,\n"
			
 
				+                "\thdr+entrylen+backlen: %2lu,\n"
			
 
				+                "\thdrlen: %3u,\n"
			
 
				+                "\tbacklen: %2lu,\n"
			
 
				+                "\tpayload: %1u\n",
			
 
				+            (long unsigned)p,
			
 
				+            index,
			
 
				+            (unsigned long) (p-lp),
			
 
				+            encoded_size + back_len,
			
 
				+            encoded_size_bytes,
			
 
				+            back_len,
			
 
				+            encoded_size - encoded_size_bytes);
			
 
				+        printf("\tbytes: ");
			
 
				+        for (unsigned int i = 0; i < (encoded_size + back_len); i++) {
			
 
				+            printf("%02x|",p[i]);
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+
			
 
				+        vstr = lpGet(p, &vlen, intbuf);
			
 
				+        printf("\t[str]");
			
 
				+        if (vlen > 40) {
			
 
				+            if (fwrite(vstr, 40, 1, stdout) == 0) perror("fwrite");
			
 
				+            printf("...");
			
 
				+        } else {
			
 
				+            if (fwrite(vstr, vlen, 1, stdout) == 0) perror("fwrite");
			
 
				+        }
			
 
				+        printf("\n}\n");
			
 
				+        index++;
			
 
				+        p = lpNext(lp, p);
			
 
				+    }
			
 
				+    printf("{end}\n\n");
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+
			
 
				+#include <sys/time.h>
			
 
				+#include "adlist.h"
			
 
				+#include "sds.h"
			
 
				+#include "testhelp.h"
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+#define TEST(name) printf("test — %s\n", name);
			
 
				+
			
 
				+char *mixlist[] = {"hello", "foo", "quux", "1024"};
			
 
				+char *intlist[] = {"4294967296", "-100", "100", "128000", 
			
 
				+                   "non integer", "much much longer non integer"};
			
 
				+
			
 
				+static unsigned char *createList() {
			
 
				+    unsigned char *lp = lpNew(0);
			
 
				+    lp = lpAppend(lp, (unsigned char*)mixlist[1], strlen(mixlist[1]));
			
 
				+    lp = lpAppend(lp, (unsigned char*)mixlist[2], strlen(mixlist[2]));
			
 
				+    lp = lpPrepend(lp, (unsigned char*)mixlist[0], strlen(mixlist[0]));
			
 
				+    lp = lpAppend(lp, (unsigned char*)mixlist[3], strlen(mixlist[3]));
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+static unsigned char *createIntList() {
			
 
				+    unsigned char *lp = lpNew(0);
			
 
				+    lp = lpAppend(lp, (unsigned char*)intlist[2], strlen(intlist[2]));
			
 
				+    lp = lpAppend(lp, (unsigned char*)intlist[3], strlen(intlist[3]));
			
 
				+    lp = lpPrepend(lp, (unsigned char*)intlist[1], strlen(intlist[1]));
			
 
				+    lp = lpPrepend(lp, (unsigned char*)intlist[0], strlen(intlist[0]));
			
 
				+    lp = lpAppend(lp, (unsigned char*)intlist[4], strlen(intlist[4]));
			
 
				+    lp = lpAppend(lp, (unsigned char*)intlist[5], strlen(intlist[5]));
			
 
				+    return lp;
			
 
				+}
			
 
				+
			
 
				+static long long usec(void) {
			
 
				+    struct timeval tv;
			
 
				+    gettimeofday(&tv, NULL);
			
 
				+    return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;
			
 
				+}
			
 
				+
			
 
				+static void stress(int pos, int num, int maxsize, int dnum) {
			
 
				+    int i, j, k;
			
 
				+    unsigned char *lp;
			
 
				+    char posstr[2][5] = { "HEAD", "TAIL" };
			
 
				+    long long start;
			
 
				+    for (i = 0; i < maxsize; i+=dnum) {
			
 
				+        lp = lpNew(0);
			
 
				+        for (j = 0; j < i; j++) {
			
 
				+            lp = lpAppend(lp, (unsigned char*)"quux", 4);
			
 
				+        }
			
 
				+
			
 
				+        /* Do num times a push+pop from pos */
			
 
				+        start = usec();
			
 
				+        for (k = 0; k < num; k++) {
			
 
				+            if (pos == 0) {
			
 
				+                lp = lpPrepend(lp, (unsigned char*)"quux", 4);
			
 
				+            } else {
			
 
				+                lp = lpAppend(lp, (unsigned char*)"quux", 4);
			
 
				+
			
 
				+            }
			
 
				+            lp = lpDelete(lp, lpFirst(lp), NULL);
			
 
				+        }
			
 
				+        printf("List size: %8d, bytes: %8zu, %dx push+pop (%s): %6lld usec\n",
			
 
				+               i, lpBytes(lp), num, posstr[pos], usec()-start);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+static unsigned char *pop(unsigned char *lp, int where) {
			
 
				+    unsigned char *p, *vstr;
			
 
				+    int64_t vlen;
			
 
				+
			
 
				+    p = lpSeek(lp, where == 0 ? 0 : -1);
			
 
				+    vstr = lpGet(p, &vlen, NULL);
			
 
				+    if (where == 0)
			
 
				+        printf("Pop head: ");
			
 
				+    else
			
 
				+        printf("Pop tail: ");
			
 
				+
			
 
				+    if (vstr) {
			
 
				+        if (vlen && fwrite(vstr, vlen, 1, stdout) == 0) perror("fwrite");
			
 
				+    } else {
			
 
				+        printf("%lld", (long long)vlen);
			
 
				+    }
			
 
				+
			
 
				+    printf("\n");
			
 
				+    return lpDelete(lp, p, &p);
			
 
				+}
			
 
				+
			
 
				+static int randstring(char *target, unsigned int min, unsigned int max) {
			
 
				+    int p = 0;
			
 
				+    int len = min+rand()%(max-min+1);
			
 
				+    int minval, maxval;
			
 
				+    switch(rand() % 3) {
			
 
				+    case 0:
			
 
				+        minval = 0;
			
 
				+        maxval = 255;
			
 
				+    break;
			
 
				+    case 1:
			
 
				+        minval = 48;
			
 
				+        maxval = 122;
			
 
				+    break;
			
 
				+    case 2:
			
 
				+        minval = 48;
			
 
				+        maxval = 52;
			
 
				+    break;
			
 
				+    default:
			
 
				+        assert(NULL);
			
 
				+    }
			
 
				+
			
 
				+    while(p < len)
			
 
				+        target[p++] = minval+rand()%(maxval-minval+1);
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+static void verifyEntry(unsigned char *p, unsigned char *s, size_t slen) {
			
 
				+    assert(lpCompare(p, s, slen));
			
 
				+}
			
 
				+
			
 
				+static int lpValidation(unsigned char *p, unsigned int head_count, void *userdata) {
			
 
				+    UNUSED(p);
			
 
				+    UNUSED(head_count);
			
 
				+
			
 
				+    int ret;
			
 
				+    long *count = userdata;
			
 
				+    ret = lpCompare(p, (unsigned char *)mixlist[*count], strlen(mixlist[*count]));
			
 
				+    (*count)++;
			
 
				+    return ret;
			
 
				+}
			
 
				+
			
 
				+int listpackTest(int argc, char *argv[], int flags) {
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+
			
 
				+    int i;
			
 
				+    unsigned char *lp, *p, *vstr;
			
 
				+    int64_t vlen;
			
 
				+    unsigned char intbuf[LP_INTBUF_SIZE];
			
 
				+    int accurate = (flags & REDIS_TEST_ACCURATE);
			
 
				+
			
 
				+    TEST("Create int list") {
			
 
				+        lp = createIntList();
			
 
				+        assert(lpLength(lp) == 6);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Create list") {
			
 
				+        lp = createList();
			
 
				+        assert(lpLength(lp) == 4);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Test lpPrepend") {
			
 
				+        lp = lpNew(0);
			
 
				+        lp = lpPrepend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpPrepend(lp, (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, 0), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, 1), (unsigned char*)"abc", 3);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Test lpPrependInteger") {
			
 
				+        lp = lpNew(0);
			
 
				+        lp = lpPrependInteger(lp, 127);
			
 
				+        lp = lpPrependInteger(lp, 4095);
			
 
				+        lp = lpPrependInteger(lp, 32767);
			
 
				+        lp = lpPrependInteger(lp, 8388607);
			
 
				+        lp = lpPrependInteger(lp, 2147483647);
			
 
				+        lp = lpPrependInteger(lp, 9223372036854775807);
			
 
				+        verifyEntry(lpSeek(lp, 0), (unsigned char*)"9223372036854775807", 19);
			
 
				+        verifyEntry(lpSeek(lp, -1), (unsigned char*)"127", 3);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Get element at index") {
			
 
				+        lp = createList();
			
 
				+        verifyEntry(lpSeek(lp, 0), (unsigned char*)"hello", 5);
			
 
				+        verifyEntry(lpSeek(lp, 3), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, -1), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, -4), (unsigned char*)"hello", 5);
			
 
				+        assert(lpSeek(lp, 4) == NULL);
			
 
				+        assert(lpSeek(lp, -5) == NULL);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Pop list") {
			
 
				+        lp = createList();
			
 
				+        lp = pop(lp, 1);
			
 
				+        lp = pop(lp, 0);
			
 
				+        lp = pop(lp, 1);
			
 
				+        lp = pop(lp, 1);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Get element at index") {
			
 
				+        lp = createList();
			
 
				+        verifyEntry(lpSeek(lp, 0), (unsigned char*)"hello", 5);
			
 
				+        verifyEntry(lpSeek(lp, 3), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, -1), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp, -4), (unsigned char*)"hello", 5);
			
 
				+        assert(lpSeek(lp, 4) == NULL);
			
 
				+        assert(lpSeek(lp, -5) == NULL);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Iterate list from 0 to end") {
			
 
				+        lp = createList();
			
 
				+        p = lpFirst(lp);
			
 
				+        i = 0;
			
 
				+        while (p) {
			
 
				+            verifyEntry(p, (unsigned char*)mixlist[i], strlen(mixlist[i]));
			
 
				+            p = lpNext(lp, p);
			
 
				+            i++;
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Iterate list from 1 to end") {
			
 
				+        lp = createList();
			
 
				+        i = 1;
			
 
				+        p = lpSeek(lp, i);
			
 
				+        while (p) {
			
 
				+            verifyEntry(p, (unsigned char*)mixlist[i], strlen(mixlist[i]));
			
 
				+            p = lpNext(lp, p);
			
 
				+            i++;
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Iterate list from 2 to end") {
			
 
				+        lp = createList();
			
 
				+        i = 2;
			
 
				+        p = lpSeek(lp, i);
			
 
				+        while (p) {
			
 
				+            verifyEntry(p, (unsigned char*)mixlist[i], strlen(mixlist[i]));
			
 
				+            p = lpNext(lp, p);
			
 
				+            i++;
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Iterate from back to front") {
			
 
				+        lp = createList();
			
 
				+        p = lpLast(lp);
			
 
				+        i = 3;
			
 
				+        while (p) {
			
 
				+            verifyEntry(p, (unsigned char*)mixlist[i], strlen(mixlist[i]));
			
 
				+            p = lpPrev(lp, p);
			
 
				+            i--;
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Iterate from back to front, deleting all items") {
			
 
				+        lp = createList();
			
 
				+        p = lpLast(lp);
			
 
				+        i = 3;
			
 
				+        while ((p = lpLast(lp))) {
			
 
				+            verifyEntry(p, (unsigned char*)mixlist[i], strlen(mixlist[i]));
			
 
				+            lp = lpDelete(lp, p, &p);
			
 
				+            assert(p == NULL);
			
 
				+            i--;
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete whole listpack when num == -1");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 0, -1);
			
 
				+        assert(lpLength(lp) == 0);
			
 
				+        assert(lp[LP_HDR_SIZE] == LP_EOF);
			
 
				+        assert(lpBytes(lp) == (LP_HDR_SIZE + 1));
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpFirst(lp);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, -1);
			
 
				+        assert(lpLength(lp) == 0);
			
 
				+        assert(lp[LP_HDR_SIZE] == LP_EOF);
			
 
				+        assert(lpBytes(lp) == (LP_HDR_SIZE + 1));
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete whole listpack with negative index");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, -4, 4);
			
 
				+        assert(lpLength(lp) == 0);
			
 
				+        assert(lp[LP_HDR_SIZE] == LP_EOF);
			
 
				+        assert(lpBytes(lp) == (LP_HDR_SIZE + 1));
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpSeek(lp, -4);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, 4);
			
 
				+        assert(lpLength(lp) == 0);
			
 
				+        assert(lp[LP_HDR_SIZE] == LP_EOF);
			
 
				+        assert(lpBytes(lp) == (LP_HDR_SIZE + 1));
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete inclusive range 0,0");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 0, 1);
			
 
				+        assert(lpLength(lp) == 3);
			
 
				+        assert(lpSkip(lpLast(lp))[0] == LP_EOF); /* check set LP_EOF correctly */
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpFirst(lp);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, 1);
			
 
				+        assert(lpLength(lp) == 3);
			
 
				+        assert(lpSkip(lpLast(lp))[0] == LP_EOF); /* check set LP_EOF correctly */
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete inclusive range 0,1");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 0, 2);
			
 
				+        assert(lpLength(lp) == 2);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[2], strlen(mixlist[2]));
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpFirst(lp);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, 2);
			
 
				+        assert(lpLength(lp) == 2);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[2], strlen(mixlist[2]));
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete inclusive range 1,2");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 1, 2);
			
 
				+        assert(lpLength(lp) == 2);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[0], strlen(mixlist[0]));
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpSeek(lp, 1);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, 2);
			
 
				+        assert(lpLength(lp) == 2);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[0], strlen(mixlist[0]));
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+    
			
 
				+    TEST("Delete with start index out of range");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 5, 1);
			
 
				+        assert(lpLength(lp) == 4);
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete with num overflow");
			
 
				+    {
			
 
				+        lp = createList();
			
 
				+        lp = lpDeleteRange(lp, 1, 5);
			
 
				+        assert(lpLength(lp) == 1);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[0], strlen(mixlist[0]));
			
 
				+        zfree(lp);
			
 
				+
			
 
				+        lp = createList();
			
 
				+        unsigned char *ptr = lpSeek(lp, 1);
			
 
				+        lp = lpDeleteRangeWithEntry(lp, &ptr, 5);
			
 
				+        assert(lpLength(lp) == 1);
			
 
				+        verifyEntry(lpFirst(lp), (unsigned char*)mixlist[0], strlen(mixlist[0]));
			
 
				+        zfree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Delete foo while iterating") {
			
 
				+        lp = createList();
			
 
				+        p = lpFirst(lp);
			
 
				+        while (p) {
			
 
				+            if (lpCompare(p, (unsigned char*)"foo", 3)) {
			
 
				+                lp = lpDelete(lp, p, &p);
			
 
				+            } else {
			
 
				+                p = lpNext(lp, p);
			
 
				+            }
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Replace with same size") {
			
 
				+        lp = createList(); /* "hello", "foo", "quux", "1024" */
			
 
				+        unsigned char *orig_lp = lp;
			
 
				+        p = lpSeek(lp, 0);
			
 
				+        lp = lpReplace(lp, &p, (unsigned char*)"zoink", 5);
			
 
				+        p = lpSeek(lp, 3);
			
 
				+        lp = lpReplace(lp, &p, (unsigned char*)"y", 1);
			
 
				+        p = lpSeek(lp, 1);
			
 
				+        lp = lpReplace(lp, &p, (unsigned char*)"65536", 5);
			
 
				+        p = lpSeek(lp, 0);
			
 
				+        assert(!memcmp((char*)p,
			
 
				+                       "\x85zoink\x06"
			
 
				+                       "\xf2\x00\x00\x01\x04" /* 65536 as int24 */
			
 
				+                       "\x84quux\05" "\x81y\x02" "\xff",
			
 
				+                       22));
			
 
				+        assert(lp == orig_lp); /* no reallocations have happened */
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Replace with different size") {
			
 
				+        lp = createList(); /* "hello", "foo", "quux", "1024" */
			
 
				+        p = lpSeek(lp, 1);
			
 
				+        lp = lpReplace(lp, &p, (unsigned char*)"squirrel", 8);
			
 
				+        p = lpSeek(lp, 0);
			
 
				+        assert(!strncmp((char*)p,
			
 
				+                        "\x85hello\x06" "\x88squirrel\x09" "\x84quux\x05"
			
 
				+                        "\xc4\x00\x02" "\xff",
			
 
				+                        27));
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Regression test for >255 byte strings") {
			
 
				+        char v1[257] = {0}, v2[257] = {0};
			
 
				+        memset(v1,'x',256);
			
 
				+        memset(v2,'y',256);
			
 
				+        lp = lpNew(0);
			
 
				+        lp = lpAppend(lp, (unsigned char*)v1 ,strlen(v1));
			
 
				+        lp = lpAppend(lp, (unsigned char*)v2 ,strlen(v2));
			
 
				+
			
 
				+        /* Pop values again and compare their value. */
			
 
				+        p = lpFirst(lp);
			
 
				+        vstr = lpGet(p, &vlen, NULL);
			
 
				+        assert(strncmp(v1, (char*)vstr, vlen) == 0);
			
 
				+        p = lpSeek(lp, 1);
			
 
				+        vstr = lpGet(p, &vlen, NULL);
			
 
				+        assert(strncmp(v2, (char*)vstr, vlen) == 0);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Create long list and check indices") {
			
 
				+        lp = lpNew(0);
			
 
				+        char buf[32];
			
 
				+        int i,len;
			
 
				+        for (i = 0; i < 1000; i++) {
			
 
				+            len = sprintf(buf, "%d", i);
			
 
				+            lp = lpAppend(lp, (unsigned char*)buf, len);
			
 
				+        }
			
 
				+        for (i = 0; i < 1000; i++) {
			
 
				+            p = lpSeek(lp, i);
			
 
				+            vstr = lpGet(p, &vlen, NULL);
			
 
				+            assert(i == vlen);
			
 
				+
			
 
				+            p = lpSeek(lp, -i-1);
			
 
				+            vstr = lpGet(p, &vlen, NULL);
			
 
				+            assert(999-i == vlen);
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Compare strings with listpack entries") {
			
 
				+        lp = createList();
			
 
				+        p = lpSeek(lp,0);
			
 
				+        assert(lpCompare(p,(unsigned char*)"hello",5));
			
 
				+        assert(!lpCompare(p,(unsigned char*)"hella",5));
			
 
				+
			
 
				+        p = lpSeek(lp,3);
			
 
				+        assert(lpCompare(p,(unsigned char*)"1024",4));
			
 
				+        assert(!lpCompare(p,(unsigned char*)"1025",4));
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("lpMerge two empty listpacks") {
			
 
				+        unsigned char *lp1 = lpNew(0);
			
 
				+        unsigned char *lp2 = lpNew(0);
			
 
				+
			
 
				+        /* Merge two empty listpacks, get empty result back. */
			
 
				+        lp1 = lpMerge(&lp1, &lp2);
			
 
				+        assert(lpLength(lp1) == 0);
			
 
				+        zfree(lp1);
			
 
				+    }
			
 
				+
			
 
				+    TEST("lpMerge two listpacks - first larger than second") {
			
 
				+        unsigned char *lp1 = createIntList();
			
 
				+        unsigned char *lp2 = createList();
			
 
				+
			
 
				+        size_t lp1_bytes = lpBytes(lp1);
			
 
				+        size_t lp2_bytes = lpBytes(lp2);
			
 
				+        unsigned long lp1_len = lpLength(lp1);
			
 
				+        unsigned long lp2_len = lpLength(lp2);
			
 
				+
			
 
				+        unsigned char *lp3 = lpMerge(&lp1, &lp2);
			
 
				+        assert(lp3 == lp1);
			
 
				+        assert(lp2 == NULL);
			
 
				+        assert(lpLength(lp3) == (lp1_len + lp2_len));
			
 
				+        assert(lpBytes(lp3) == (lp1_bytes + lp2_bytes - LP_HDR_SIZE - 1));
			
 
				+        verifyEntry(lpSeek(lp3, 0), (unsigned char*)"4294967296", 10);
			
 
				+        verifyEntry(lpSeek(lp3, 5), (unsigned char*)"much much longer non integer", 28);
			
 
				+        verifyEntry(lpSeek(lp3, 6), (unsigned char*)"hello", 5);
			
 
				+        verifyEntry(lpSeek(lp3, -1), (unsigned char*)"1024", 4);
			
 
				+        zfree(lp3);
			
 
				+    }
			
 
				+
			
 
				+    TEST("lpMerge two listpacks - second larger than first") {
			
 
				+        unsigned char *lp1 = createList();
			
 
				+        unsigned char *lp2 = createIntList();
			
 
				+
			
 
				+        size_t lp1_bytes = lpBytes(lp1);
			
 
				+        size_t lp2_bytes = lpBytes(lp2);
			
 
				+        unsigned long lp1_len = lpLength(lp1);
			
 
				+        unsigned long lp2_len = lpLength(lp2);
			
 
				+
			
 
				+        unsigned char *lp3 = lpMerge(&lp1, &lp2);
			
 
				+        assert(lp3 == lp2);
			
 
				+        assert(lp1 == NULL);
			
 
				+        assert(lpLength(lp3) == (lp1_len + lp2_len));
			
 
				+        assert(lpBytes(lp3) == (lp1_bytes + lp2_bytes - LP_HDR_SIZE - 1));
			
 
				+        verifyEntry(lpSeek(lp3, 0), (unsigned char*)"hello", 5);
			
 
				+        verifyEntry(lpSeek(lp3, 3), (unsigned char*)"1024", 4);
			
 
				+        verifyEntry(lpSeek(lp3, 4), (unsigned char*)"4294967296", 10);
			
 
				+        verifyEntry(lpSeek(lp3, -1), (unsigned char*)"much much longer non integer", 28);
			
 
				+        zfree(lp3);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pair with one element") {
			
 
				+        listpackEntry key, val;
			
 
				+        unsigned char *lp = lpNew(0);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        lpRandomPair(lp, 1, &key, &val);
			
 
				+        assert(memcmp(key.sval, "abc", key.slen) == 0);
			
 
				+        assert(val.lval == 123);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pair with many elements") {
			
 
				+        listpackEntry key, val;
			
 
				+        unsigned char *lp = lpNew(0);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"456", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"def", 3);
			
 
				+        lpRandomPair(lp, 2, &key, &val);
			
 
				+        if (key.sval) {
			
 
				+            assert(!memcmp(key.sval, "abc", key.slen));
			
 
				+            assert(key.slen == 3);
			
 
				+            assert(val.lval == 123);
			
 
				+        }
			
 
				+        if (!key.sval) {
			
 
				+            assert(key.lval == 456);
			
 
				+            assert(!memcmp(val.sval, "def", val.slen));
			
 
				+        }
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pairs with one element") {
			
 
				+        int count = 5;
			
 
				+        unsigned char *lp = lpNew(0);
			
 
				+        listpackEntry *keys = zmalloc(sizeof(listpackEntry) * count);
			
 
				+        listpackEntry *vals = zmalloc(sizeof(listpackEntry) * count);
			
 
				+
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        lpRandomPairs(lp, count, keys, vals);
			
 
				+        assert(memcmp(keys[4].sval, "abc", keys[4].slen) == 0);
			
 
				+        assert(vals[4].lval == 123);
			
 
				+        zfree(keys);
			
 
				+        zfree(vals);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pairs with many elements") {
			
 
				+        int count = 5;
			
 
				+        lp = lpNew(0);
			
 
				+        listpackEntry *keys = zmalloc(sizeof(listpackEntry) * count);
			
 
				+        listpackEntry *vals = zmalloc(sizeof(listpackEntry) * count);
			
 
				+
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"456", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"def", 3);
			
 
				+        lpRandomPairs(lp, count, keys, vals);
			
 
				+        for (int i = 0; i < count; i++) {
			
 
				+            if (keys[i].sval) {
			
 
				+                assert(!memcmp(keys[i].sval, "abc", keys[i].slen));
			
 
				+                assert(keys[i].slen == 3);
			
 
				+                assert(vals[i].lval == 123);
			
 
				+            }
			
 
				+            if (!keys[i].sval) {
			
 
				+                assert(keys[i].lval == 456);
			
 
				+                assert(!memcmp(vals[i].sval, "def", vals[i].slen));
			
 
				+            }
			
 
				+        }
			
 
				+        zfree(keys);
			
 
				+        zfree(vals);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pairs unique with one element") {
			
 
				+        unsigned picked;
			
 
				+        int count = 5;
			
 
				+        lp = lpNew(0);
			
 
				+        listpackEntry *keys = zmalloc(sizeof(listpackEntry) * count);
			
 
				+        listpackEntry *vals = zmalloc(sizeof(listpackEntry) * count);
			
 
				+
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        picked = lpRandomPairsUnique(lp, count, keys, vals);
			
 
				+        assert(picked == 1);
			
 
				+        assert(memcmp(keys[0].sval, "abc", keys[0].slen) == 0);
			
 
				+        assert(vals[0].lval == 123);
			
 
				+        zfree(keys);
			
 
				+        zfree(vals);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Random pairs unique with many elements") {
			
 
				+        unsigned picked;
			
 
				+        int count = 5;
			
 
				+        lp = lpNew(0);
			
 
				+        listpackEntry *keys = zmalloc(sizeof(listpackEntry) * count);
			
 
				+        listpackEntry *vals = zmalloc(sizeof(listpackEntry) * count);
			
 
				+
			
 
				+        lp = lpAppend(lp, (unsigned char*)"abc", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"123", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"456", 3);
			
 
				+        lp = lpAppend(lp, (unsigned char*)"def", 3);
			
 
				+        picked = lpRandomPairsUnique(lp, count, keys, vals);
			
 
				+        assert(picked == 2);
			
 
				+        for (int i = 0; i < 2; i++) {
			
 
				+            if (keys[i].sval) {
			
 
				+                assert(!memcmp(keys[i].sval, "abc", keys[i].slen));
			
 
				+                assert(keys[i].slen == 3);
			
 
				+                assert(vals[i].lval == 123);
			
 
				+            }
			
 
				+            if (!keys[i].sval) {
			
 
				+                assert(keys[i].lval == 456);
			
 
				+                assert(!memcmp(vals[i].sval, "def", vals[i].slen));
			
 
				+            }
			
 
				+        }
			
 
				+        zfree(keys);
			
 
				+        zfree(vals);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("push various encodings") {
			
 
				+        lp = lpNew(0);
			
 
				+
			
 
				+        /* Push integer encode element using lpAppend */
			
 
				+        lp = lpAppend(lp, (unsigned char*)"127", 3);
			
 
				+        assert(LP_ENCODING_IS_7BIT_UINT(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)"4095", 4);
			
 
				+        assert(LP_ENCODING_IS_13BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)"32767", 5);
			
 
				+        assert(LP_ENCODING_IS_16BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)"8388607", 7);
			
 
				+        assert(LP_ENCODING_IS_24BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)"2147483647", 10);
			
 
				+        assert(LP_ENCODING_IS_32BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)"9223372036854775807", 19);
			
 
				+        assert(LP_ENCODING_IS_64BIT_INT(lpLast(lp)[0]));
			
 
				+
			
 
				+        /* Push integer encode element using lpAppendInteger */
			
 
				+        lp = lpAppendInteger(lp, 127);
			
 
				+        assert(LP_ENCODING_IS_7BIT_UINT(lpLast(lp)[0]));
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"127", 3);
			
 
				+        lp = lpAppendInteger(lp, 4095);
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"4095", 4);
			
 
				+        assert(LP_ENCODING_IS_13BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppendInteger(lp, 32767);
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"32767", 5);
			
 
				+        assert(LP_ENCODING_IS_16BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppendInteger(lp, 8388607);
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"8388607", 7);
			
 
				+        assert(LP_ENCODING_IS_24BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppendInteger(lp, 2147483647);
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"2147483647", 10);
			
 
				+        assert(LP_ENCODING_IS_32BIT_INT(lpLast(lp)[0]));
			
 
				+        lp = lpAppendInteger(lp, 9223372036854775807);
			
 
				+        verifyEntry(lpLast(lp), (unsigned char*)"9223372036854775807", 19);
			
 
				+        assert(LP_ENCODING_IS_64BIT_INT(lpLast(lp)[0]));
			
 
				+
			
 
				+        /* string encode */
			
 
				+        unsigned char *str = zmalloc(65535);
			
 
				+        memset(str, 0, 65535);
			
 
				+        lp = lpAppend(lp, (unsigned char*)str, 63);
			
 
				+        assert(LP_ENCODING_IS_6BIT_STR(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)str, 4095);
			
 
				+        assert(LP_ENCODING_IS_12BIT_STR(lpLast(lp)[0]));
			
 
				+        lp = lpAppend(lp, (unsigned char*)str, 65535);
			
 
				+        assert(LP_ENCODING_IS_32BIT_STR(lpLast(lp)[0]));
			
 
				+        zfree(str);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Test lpFind") {
			
 
				+        lp = createList();
			
 
				+        assert(lpFind(lp, lpFirst(lp), (unsigned char*)"abc", 3, 0) == NULL);
			
 
				+        verifyEntry(lpFind(lp, lpFirst(lp), (unsigned char*)"hello", 5, 0), (unsigned char*)"hello", 5);
			
 
				+        verifyEntry(lpFind(lp, lpFirst(lp), (unsigned char*)"1024", 4, 0), (unsigned char*)"1024", 4);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Test lpValidateIntegrity") {
			
 
				+        lp = createList();
			
 
				+        long count = 0;
			
 
				+        assert(lpValidateIntegrity(lp, lpBytes(lp), 1, lpValidation, &count) == 1);
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Test number of elements exceeds LP_HDR_NUMELE_UNKNOWN") {
			
 
				+        lp = lpNew(0);
			
 
				+        for (int i = 0; i < LP_HDR_NUMELE_UNKNOWN + 1; i++)
			
 
				+            lp = lpAppend(lp, (unsigned char*)"1", 1);
			
 
				+
			
 
				+        assert(lpGetNumElements(lp) == LP_HDR_NUMELE_UNKNOWN);
			
 
				+        assert(lpLength(lp) == LP_HDR_NUMELE_UNKNOWN+1);
			
 
				+
			
 
				+        lp = lpDeleteRange(lp, -2, 2);
			
 
				+        assert(lpGetNumElements(lp) == LP_HDR_NUMELE_UNKNOWN);
			
 
				+        assert(lpLength(lp) == LP_HDR_NUMELE_UNKNOWN-1);
			
 
				+        assert(lpGetNumElements(lp) == LP_HDR_NUMELE_UNKNOWN-1); /* update length after lpLength */
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Stress with random payloads of different encoding") {
			
 
				+        unsigned long long start = usec();
			
 
				+        int i,j,len,where;
			
 
				+        unsigned char *p;
			
 
				+        char buf[1024];
			
 
				+        int buflen;
			
 
				+        list *ref;
			
 
				+        listNode *refnode;
			
 
				+
			
 
				+        int iteration = accurate ? 20000 : 20;
			
 
				+        for (i = 0; i < iteration; i++) {
			
 
				+            lp = lpNew(0);
			
 
				+            ref = listCreate();
			
 
				+            listSetFreeMethod(ref,(void (*)(void*))sdsfree);
			
 
				+            len = rand() % 256;
			
 
				+
			
 
				+            /* Create lists */
			
 
				+            for (j = 0; j < len; j++) {
			
 
				+                where = (rand() & 1) ? 0 : 1;
			
 
				+                if (rand() % 2) {
			
 
				+                    buflen = randstring(buf,1,sizeof(buf)-1);
			
 
				+                } else {
			
 
				+                    switch(rand() % 3) {
			
 
				+                    case 0:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()) >> 20);
			
 
				+                        break;
			
 
				+                    case 1:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()));
			
 
				+                        break;
			
 
				+                    case 2:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()) << 20);
			
 
				+                        break;
			
 
				+                    default:
			
 
				+                        assert(NULL);
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                /* Add to listpack */
			
 
				+                if (where == 0) {
			
 
				+                    lp = lpPrepend(lp, (unsigned char*)buf, buflen);
			
 
				+                } else {
			
 
				+                    lp = lpAppend(lp, (unsigned char*)buf, buflen);
			
 
				+                }
			
 
				+
			
 
				+                /* Add to reference list */
			
 
				+                if (where == 0) {
			
 
				+                    listAddNodeHead(ref,sdsnewlen(buf, buflen));
			
 
				+                } else if (where == 1) {
			
 
				+                    listAddNodeTail(ref,sdsnewlen(buf, buflen));
			
 
				+                } else {
			
 
				+                    assert(NULL);
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            assert(listLength(ref) == lpLength(lp));
			
 
				+            for (j = 0; j < len; j++) {
			
 
				+                /* Naive way to get elements, but similar to the stresser
			
 
				+                 * executed from the Tcl test suite. */
			
 
				+                p = lpSeek(lp,j);
			
 
				+                refnode = listIndex(ref,j);
			
 
				+
			
 
				+                vstr = lpGet(p, &vlen, intbuf);
			
 
				+                assert(memcmp(vstr,listNodeValue(refnode),vlen) == 0);
			
 
				+            }
			
 
				+            lpFree(lp);
			
 
				+            listRelease(ref);
			
 
				+        }
			
 
				+        printf("Done. usec=%lld\n\n", usec()-start);
			
 
				+    }
			
 
				+
			
 
				+    TEST("Stress with variable listpack size") {
			
 
				+        unsigned long long start = usec();
			
 
				+        int maxsize = accurate ? 16384 : 16;
			
 
				+        stress(0,100000,maxsize,256);
			
 
				+        stress(1,100000,maxsize,256);
			
 
				+        printf("Done. usec=%lld\n\n", usec()-start);
			
 
				+    }
			
 
				+
			
 
				+    /* Benchmarks */
			
 
				+    {
			
 
				+        int iteration = accurate ? 100000 : 100;
			
 
				+        lp = lpNew(0);
			
 
				+        TEST("Benchmark lpAppend") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i=0; i<iteration; i++) {
			
 
				+                char buf[4096] = "asdf";
			
 
				+                lp = lpAppend(lp, (unsigned char*)buf, 4);
			
 
				+                lp = lpAppend(lp, (unsigned char*)buf, 40);
			
 
				+                lp = lpAppend(lp, (unsigned char*)buf, 400);
			
 
				+                lp = lpAppend(lp, (unsigned char*)buf, 4000);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"1", 1);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"10", 2);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"100", 3);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"1000", 4);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"10000", 5);
			
 
				+                lp = lpAppend(lp, (unsigned char*)"100000", 6);
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpFind string") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *fptr = lpFirst(lp);
			
 
				+                fptr = lpFind(lp, fptr, (unsigned char*)"nothing", 7, 1);
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpFind number") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *fptr = lpFirst(lp);
			
 
				+                fptr = lpFind(lp, fptr, (unsigned char*)"99999", 5, 1);
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpSeek") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                lpSeek(lp, 99999);
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpValidateIntegrity") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                lpValidateIntegrity(lp, lpBytes(lp), 1, NULL, NULL);
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpCompare with string") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *eptr = lpSeek(lp,0);
			
 
				+                while (eptr != NULL) {
			
 
				+                    lpCompare(eptr,(unsigned char*)"nothing",7);
			
 
				+                    eptr = lpNext(lp,eptr);
			
 
				+                }
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Benchmark lpCompare with number") {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *eptr = lpSeek(lp,0);
			
 
				+                while (eptr != NULL) {
			
 
				+                    lpCompare(lp, (unsigned char*)"99999", 5);
			
 
				+                    eptr = lpNext(lp,eptr);
			
 
				+                }
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        lpFree(lp);
			
 
				+    }
			
 
				+
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+#endif
			
--- a/src/listpack.h
+++ b/src/listpack.h
@@ -0,0 +1,98 @@
 
				+/* Listpack -- A lists of strings serialization format
			
 
				+ *
			
 
				+ * This file implements the specification you can find at:
			
 
				+ *
			
 
				+ *  https://github.com/antirez/listpack
			
 
				+ *
			
 
				+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __LISTPACK_H
			
 
				+#define __LISTPACK_H
			
 
				+
			
 
				+#include <stdlib.h>
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+#define LP_INTBUF_SIZE 21 /* 20 digits of -2^63 + 1 null term = 21. */
			
 
				+
			
 
				+/* lpInsert() where argument possible values: */
			
 
				+#define LP_BEFORE 0
			
 
				+#define LP_AFTER 1
			
 
				+#define LP_REPLACE 2
			
 
				+
			
 
				+/* Each entry in the listpack is either a string or an integer. */
			
 
				+typedef struct {
			
 
				+    /* When string is used, it is provided with the length (slen). */
			
 
				+    unsigned char *sval;
			
 
				+    uint32_t slen;
			
 
				+    /* When integer is used, 'sval' is NULL, and lval holds the value. */
			
 
				+    long long lval;
			
 
				+} listpackEntry;
			
 
				+
			
 
				+unsigned char *lpNew(size_t capacity);
			
 
				+void lpFree(unsigned char *lp);
			
 
				+unsigned char* lpShrinkToFit(unsigned char *lp);
			
 
				+unsigned char *lpInsertString(unsigned char *lp, unsigned char *s, uint32_t slen,
			
 
				+                              unsigned char *p, int where, unsigned char **newp);
			
 
				+unsigned char *lpPrepend(unsigned char *lp, unsigned char *s, uint32_t slen);
			
 
				+unsigned char *lpPrependInteger(unsigned char *lp, long long lval);
			
 
				+unsigned char *lpAppend(unsigned char *lp, unsigned char *s, uint32_t slen);
			
 
				+unsigned char *lpAppendInteger(unsigned char *lp, long long lval);
			
 
				+unsigned char *lpReplace(unsigned char *lp, unsigned char **p, unsigned char *s, uint32_t slen);
			
 
				+unsigned char *lpReplaceInteger(unsigned char *lp, unsigned char **p, long long lval);
			
 
				+unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp);
			
 
				+unsigned char *lpDeleteRangeWithEntry(unsigned char *lp, unsigned char **p, unsigned long num);
			
 
				+unsigned char *lpDeleteRange(unsigned char *lp, long index, unsigned long num);
			
 
				+unsigned char *lpMerge(unsigned char **first, unsigned char **second);
			
 
				+unsigned long lpLength(unsigned char *lp);
			
 
				+unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf);
			
 
				+unsigned char *lpGetValue(unsigned char *p, unsigned int *slen, long long *lval);
			
 
				+unsigned char *lpFind(unsigned char *lp, unsigned char *p, unsigned char *s, uint32_t slen, unsigned int skip);
			
 
				+unsigned char *lpFirst(unsigned char *lp);
			
 
				+unsigned char *lpLast(unsigned char *lp);
			
 
				+unsigned char *lpNext(unsigned char *lp, unsigned char *p);
			
 
				+unsigned char *lpPrev(unsigned char *lp, unsigned char *p);
			
 
				+size_t lpBytes(unsigned char *lp);
			
 
				+unsigned char *lpSeek(unsigned char *lp, long index);
			
 
				+typedef int (*listpackValidateEntryCB)(unsigned char *p, unsigned int head_count, void *userdata);
			
 
				+int lpValidateIntegrity(unsigned char *lp, size_t size, int deep,
			
 
				+                        listpackValidateEntryCB entry_cb, void *cb_userdata);
			
 
				+unsigned char *lpValidateFirst(unsigned char *lp);
			
 
				+int lpValidateNext(unsigned char *lp, unsigned char **pp, size_t lpbytes);
			
 
				+unsigned int lpCompare(unsigned char *p, unsigned char *s, uint32_t slen);
			
 
				+void lpRandomPair(unsigned char *lp, unsigned long total_count, listpackEntry *key, listpackEntry *val);
			
 
				+void lpRandomPairs(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals);
			
 
				+unsigned int lpRandomPairsUnique(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals);
			
 
				+int lpSafeToAdd(unsigned char* lp, size_t add);
			
 
				+void lpRepr(unsigned char *lp);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int listpackTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/listpack_malloc.h
+++ b/src/listpack_malloc.h
@@ -0,0 +1,46 @@
 
				+/* Listpack -- A lists of strings serialization format
			
 
				+ * https://github.com/antirez/listpack
			
 
				+ *
			
 
				+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+/* Allocator selection.
			
 
				+ *
			
 
				+ * This file is used in order to change the Rax allocator at compile time.
			
 
				+ * Just define the following defines to what you want to use. Also add
			
 
				+ * the include of your alternate allocator if needed (not needed in order
			
 
				+ * to use the default libc allocator). */
			
 
				+
			
 
				+#ifndef LISTPACK_ALLOC_H
			
 
				+#define LISTPACK_ALLOC_H
			
 
				+#include "zmalloc.h"
			
 
				+#define lp_malloc zmalloc
			
 
				+#define lp_realloc zrealloc
			
 
				+#define lp_free zfree
			
 
				+#define lp_malloc_size zmalloc_usable_size
			
 
				+#endif
			
--- a/src/logger.c
+++ b/src/logger.c
@@ -0,0 +1,25 @@
 
				+#include "logger.h"
			
 
				+
			
 
				+#include <stdarg.h>
			
 
				+
			
 
				+logger_t* g_logger = NULL;
			
 
				+
			
 
				+void set_default_logger(logger_t* logger)
			
 
				+{
			
 
				+    g_logger = logger;
			
 
				+}
			
 
				+
			
 
				+logger_t* get_logger()
			
 
				+{
			
 
				+    return g_logger;
			
 
				+}
			
 
				+
			
 
				+int logg(e_log_level_t level, const char* fmt, ...)
			
 
				+{
			
 
				+    va_list ap;
			
 
				+
			
 
				+    va_start(ap, fmt);
			
 
				+    int r = vfprintf(stdout, fmt, ap);
			
 
				+    va_end(ap);
			
 
				+    return r;
			
 
				+}
			
--- a/src/logger.h
+++ b/src/logger.h
@@ -0,0 +1,28 @@
 
				+#ifndef LOGGER_H
			
 
				+#define LOGGER_H
			
 
				+
			
 
				+#include <uv.h>
			
 
				+
			
 
				+typedef enum _e_log_level {
			
 
				+    LVL_TRACE,
			
 
				+    LVL_DEBUG,
			
 
				+    LVL_INFO,
			
 
				+    LVL_WARN,
			
 
				+    LVL_ERROR,
			
 
				+    LVL_FATAL,
			
 
				+}e_log_level_t;
			
 
				+
			
 
				+typedef struct _logger {
			
 
				+    e_log_level_t level;
			
 
				+    char* file;
			
 
				+    uv_loop_t* loop;
			
 
				+}logger_t;
			
 
				+
			
 
				+void set_default_logger(logger_t* logger);
			
 
				+logger_t* get_logger();
			
 
				+
			
 
				+int logg(e_log_level_t level, const char* fmt, ...);
			
 
				+
			
 
				+#define info(fmt, ...) logg(LVL_INFO, fmt, ##__VA_ARGS__)
			
 
				+
			
 
				+#endif
			
--- a/src/lzf.h
+++ b/src/lzf.h
@@ -0,0 +1,100 @@
 
				+/*
			
 
				+ * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp@schmorp.de>
			
 
				+ *
			
 
				+ * Redistribution and use in source and binary forms, with or without modifica-
			
 
				+ * tion, are permitted provided that the following conditions are met:
			
 
				+ *
			
 
				+ *   1.  Redistributions of source code must retain the above copyright notice,
			
 
				+ *       this list of conditions and the following disclaimer.
			
 
				+ *
			
 
				+ *   2.  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.
			
 
				+ *
			
 
				+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
			
 
				+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
			
 
				+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
			
 
				+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
			
 
				+ * CIAL, 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 OTH-
			
 
				+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
			
 
				+ * OF THE POSSIBILITY OF SUCH DAMAGE.
			
 
				+ *
			
 
				+ * Alternatively, the contents of this file may be used under the terms of
			
 
				+ * the GNU General Public License ("GPL") version 2 or any later version,
			
 
				+ * in which case the provisions of the GPL are applicable instead of
			
 
				+ * the above. If you wish to allow the use of your version of this file
			
 
				+ * only under the terms of the GPL and not to allow others to use your
			
 
				+ * version of this file under the BSD license, indicate your decision
			
 
				+ * by deleting the provisions above and replace them with the notice
			
 
				+ * and other provisions required by the GPL. If you do not delete the
			
 
				+ * provisions above, a recipient may use your version of this file under
			
 
				+ * either the BSD or the GPL.
			
 
				+ */
			
 
				+
			
 
				+#ifndef LZF_H
			
 
				+#define LZF_H
			
 
				+
			
 
				+/***********************************************************************
			
 
				+**
			
 
				+**	lzf -- an extremely fast/free compression/decompression-method
			
 
				+**	http://liblzf.plan9.de/
			
 
				+**
			
 
				+**	This algorithm is believed to be patent-free.
			
 
				+**
			
 
				+***********************************************************************/
			
 
				+
			
 
				+#define LZF_VERSION 0x0105 /* 1.5, API version */
			
 
				+
			
 
				+/*
			
 
				+ * Compress in_len bytes stored at the memory block starting at
			
 
				+ * in_data and write the result to out_data, up to a maximum length
			
 
				+ * of out_len bytes.
			
 
				+ *
			
 
				+ * If the output buffer is not large enough or any error occurs return 0,
			
 
				+ * otherwise return the number of bytes used, which might be considerably
			
 
				+ * more than in_len (but less than 104% of the original size), so it
			
 
				+ * makes sense to always use out_len == in_len - 1), to ensure _some_
			
 
				+ * compression, and store the data uncompressed otherwise (with a flag, of
			
 
				+ * course.
			
 
				+ *
			
 
				+ * lzf_compress might use different algorithms on different systems and
			
 
				+ * even different runs, thus might result in different compressed strings
			
 
				+ * depending on the phase of the moon or similar factors. However, all
			
 
				+ * these strings are architecture-independent and will result in the
			
 
				+ * original data when decompressed using lzf_decompress.
			
 
				+ *
			
 
				+ * The buffers must not be overlapping.
			
 
				+ *
			
 
				+ * If the option LZF_STATE_ARG is enabled, an extra argument must be
			
 
				+ * supplied which is not reflected in this header file. Refer to lzfP.h
			
 
				+ * and lzf_c.c.
			
 
				+ *
			
 
				+ */
			
 
				+size_t
			
 
				+lzf_compress (const void *const in_data,  size_t in_len,
			
 
				+              void             *out_data, size_t out_len);
			
 
				+
			
 
				+/*
			
 
				+ * Decompress data compressed with some version of the lzf_compress
			
 
				+ * function and stored at location in_data and length in_len. The result
			
 
				+ * will be stored at out_data up to a maximum of out_len characters.
			
 
				+ *
			
 
				+ * If the output buffer is not large enough to hold the decompressed
			
 
				+ * data, a 0 is returned and errno is set to E2BIG. Otherwise the number
			
 
				+ * of decompressed bytes (i.e. the original length of the data) is
			
 
				+ * returned.
			
 
				+ *
			
 
				+ * If an error in the compressed data is detected, a zero is returned and
			
 
				+ * errno is set to EINVAL.
			
 
				+ *
			
 
				+ * This function is very fast, about as fast as a copying loop.
			
 
				+ */
			
 
				+size_t
			
 
				+lzf_decompress (const void *const in_data,  size_t in_len,
			
 
				+                void             *out_data, size_t out_len);
			
 
				+
			
 
				+#endif
			
 
				+
			
--- a/src/lzfP.h
+++ b/src/lzfP.h
@@ -0,0 +1,190 @@
 
				+/*
			
 
				+ * Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
			
 
				+ *
			
 
				+ * Redistribution and use in source and binary forms, with or without modifica-
			
 
				+ * tion, are permitted provided that the following conditions are met:
			
 
				+ *
			
 
				+ *   1.  Redistributions of source code must retain the above copyright notice,
			
 
				+ *       this list of conditions and the following disclaimer.
			
 
				+ *
			
 
				+ *   2.  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.
			
 
				+ *
			
 
				+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
			
 
				+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
			
 
				+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
			
 
				+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
			
 
				+ * CIAL, 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 OTH-
			
 
				+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
			
 
				+ * OF THE POSSIBILITY OF SUCH DAMAGE.
			
 
				+ *
			
 
				+ * Alternatively, the contents of this file may be used under the terms of
			
 
				+ * the GNU General Public License ("GPL") version 2 or any later version,
			
 
				+ * in which case the provisions of the GPL are applicable instead of
			
 
				+ * the above. If you wish to allow the use of your version of this file
			
 
				+ * only under the terms of the GPL and not to allow others to use your
			
 
				+ * version of this file under the BSD license, indicate your decision
			
 
				+ * by deleting the provisions above and replace them with the notice
			
 
				+ * and other provisions required by the GPL. If you do not delete the
			
 
				+ * provisions above, a recipient may use your version of this file under
			
 
				+ * either the BSD or the GPL.
			
 
				+ */
			
 
				+
			
 
				+#ifndef LZFP_h
			
 
				+#define LZFP_h
			
 
				+
			
 
				+#define STANDALONE 1 /* at the moment, this is ok. */
			
 
				+
			
 
				+#ifndef STANDALONE
			
 
				+# include "lzf.h"
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Size of hashtable is (1 << HLOG) * sizeof (char *)
			
 
				+ * decompression is independent of the hash table size
			
 
				+ * the difference between 15 and 14 is very small
			
 
				+ * for small blocks (and 14 is usually a bit faster).
			
 
				+ * For a low-memory/faster configuration, use HLOG == 13;
			
 
				+ * For best compression, use 15 or 16 (or more, up to 22).
			
 
				+ */
			
 
				+#ifndef HLOG
			
 
				+# define HLOG 16
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Sacrifice very little compression quality in favour of compression speed.
			
 
				+ * This gives almost the same compression as the default code, and is
			
 
				+ * (very roughly) 15% faster. This is the preferred mode of operation.
			
 
				+ */
			
 
				+#ifndef VERY_FAST
			
 
				+# define VERY_FAST 1
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Sacrifice some more compression quality in favour of compression speed.
			
 
				+ * (roughly 1-2% worse compression for large blocks and
			
 
				+ * 9-10% for small, redundant, blocks and >>20% better speed in both cases)
			
 
				+ * In short: when in need for speed, enable this for binary data,
			
 
				+ * possibly disable this for text data.
			
 
				+ */
			
 
				+#ifndef ULTRA_FAST
			
 
				+# define ULTRA_FAST 0
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Unconditionally aligning does not cost very much, so do it if unsure
			
 
				+ */
			
 
				+#ifndef STRICT_ALIGN
			
 
				+# if !(defined(__i386) || defined (__amd64))
			
 
				+#  define STRICT_ALIGN 1
			
 
				+# else
			
 
				+#  define STRICT_ALIGN 0
			
 
				+# endif
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * You may choose to pre-set the hash table (might be faster on some
			
 
				+ * modern cpus and large (>>64k) blocks, and also makes compression
			
 
				+ * deterministic/repeatable when the configuration otherwise is the same).
			
 
				+ */
			
 
				+#ifndef INIT_HTAB
			
 
				+# define INIT_HTAB 0
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Avoid assigning values to errno variable? for some embedding purposes
			
 
				+ * (linux kernel for example), this is necessary. NOTE: this breaks
			
 
				+ * the documentation in lzf.h. Avoiding errno has no speed impact.
			
 
				+ */
			
 
				+#ifndef AVOID_ERRNO
			
 
				+# define AVOID_ERRNO 0
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Whether to pass the LZF_STATE variable as argument, or allocate it
			
 
				+ * on the stack. For small-stack environments, define this to 1.
			
 
				+ * NOTE: this breaks the prototype in lzf.h.
			
 
				+ */
			
 
				+#ifndef LZF_STATE_ARG
			
 
				+# define LZF_STATE_ARG 0
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Whether to add extra checks for input validity in lzf_decompress
			
 
				+ * and return EINVAL if the input stream has been corrupted. This
			
 
				+ * only shields against overflowing the input buffer and will not
			
 
				+ * detect most corrupted streams.
			
 
				+ * This check is not normally noticeable on modern hardware
			
 
				+ * (<1% slowdown), but might slow down older cpus considerably.
			
 
				+ */
			
 
				+#ifndef CHECK_INPUT
			
 
				+# define CHECK_INPUT 1
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * Whether to store pointers or offsets inside the hash table. On
			
 
				+ * 64 bit architectures, pointers take up twice as much space,
			
 
				+ * and might also be slower. Default is to autodetect.
			
 
				+ * Notice: Don't set this value to 1, it will result in 'LZF_HSLOT'
			
 
				+ * not being able to store offset above UINT32_MAX in 64bit. */
			
 
				+#define LZF_USE_OFFSETS 0
			
 
				+
			
 
				+/*****************************************************************************/
			
 
				+/* nothing should be changed below */
			
 
				+
			
 
				+#ifdef __cplusplus
			
 
				+# include <cstring>
			
 
				+# include <climits>
			
 
				+using namespace std;
			
 
				+#else
			
 
				+# include <string.h>
			
 
				+# include <limits.h>
			
 
				+#endif
			
 
				+
			
 
				+#ifndef LZF_USE_OFFSETS
			
 
				+# if defined (WIN32)
			
 
				+#  define LZF_USE_OFFSETS defined(_M_X64)
			
 
				+# else
			
 
				+#  if __cplusplus > 199711L
			
 
				+#   include <cstdint>
			
 
				+#  else
			
 
				+#   include <stdint.h>
			
 
				+#  endif
			
 
				+#  define LZF_USE_OFFSETS (UINTPTR_MAX > 0xffffffffU)
			
 
				+# endif
			
 
				+#endif
			
 
				+
			
 
				+typedef unsigned char u8;
			
 
				+
			
 
				+#if LZF_USE_OFFSETS
			
 
				+# define LZF_HSLOT_BIAS ((const u8 *)in_data)
			
 
				+  typedef unsigned int LZF_HSLOT;
			
 
				+#else
			
 
				+# define LZF_HSLOT_BIAS 0
			
 
				+  typedef const u8 *LZF_HSLOT;
			
 
				+#endif
			
 
				+
			
 
				+typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
			
 
				+
			
 
				+#if !STRICT_ALIGN
			
 
				+/* for unaligned accesses we need a 16 bit datatype. */
			
 
				+# if USHRT_MAX == 65535
			
 
				+    typedef unsigned short u16;
			
 
				+# elif UINT_MAX == 65535
			
 
				+    typedef unsigned int u16;
			
 
				+# else
			
 
				+#  undef STRICT_ALIGN
			
 
				+#  define STRICT_ALIGN 1
			
 
				+# endif
			
 
				+#endif
			
 
				+
			
 
				+#if ULTRA_FAST
			
 
				+# undef VERY_FAST
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
 
				+
			
--- a/src/lzf_c.c
+++ b/src/lzf_c.c
@@ -0,0 +1,302 @@
 
				+/*
			
 
				+ * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
			
 
				+ *
			
 
				+ * Redistribution and use in source and binary forms, with or without modifica-
			
 
				+ * tion, are permitted provided that the following conditions are met:
			
 
				+ *
			
 
				+ *   1.  Redistributions of source code must retain the above copyright notice,
			
 
				+ *       this list of conditions and the following disclaimer.
			
 
				+ *
			
 
				+ *   2.  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.
			
 
				+ *
			
 
				+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
			
 
				+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
			
 
				+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
			
 
				+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
			
 
				+ * CIAL, 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 OTH-
			
 
				+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
			
 
				+ * OF THE POSSIBILITY OF SUCH DAMAGE.
			
 
				+ *
			
 
				+ * Alternatively, the contents of this file may be used under the terms of
			
 
				+ * the GNU General Public License ("GPL") version 2 or any later version,
			
 
				+ * in which case the provisions of the GPL are applicable instead of
			
 
				+ * the above. If you wish to allow the use of your version of this file
			
 
				+ * only under the terms of the GPL and not to allow others to use your
			
 
				+ * version of this file under the BSD license, indicate your decision
			
 
				+ * by deleting the provisions above and replace them with the notice
			
 
				+ * and other provisions required by the GPL. If you do not delete the
			
 
				+ * provisions above, a recipient may use your version of this file under
			
 
				+ * either the BSD or the GPL.
			
 
				+ */
			
 
				+
			
 
				+#include "lzfP.h"
			
 
				+
			
 
				+#define HSIZE (1 << (HLOG))
			
 
				+
			
 
				+/*
			
 
				+ * don't play with this unless you benchmark!
			
 
				+ * the data format is not dependent on the hash function.
			
 
				+ * the hash function might seem strange, just believe me,
			
 
				+ * it works ;)
			
 
				+ */
			
 
				+#ifndef FRST
			
 
				+# define FRST(p) (((p[0]) << 8) | p[1])
			
 
				+# define NEXT(v,p) (((v) << 8) | p[2])
			
 
				+# if ULTRA_FAST
			
 
				+#  define IDX(h) ((( h             >> (3*8 - HLOG)) - h  ) & (HSIZE - 1))
			
 
				+# elif VERY_FAST
			
 
				+#  define IDX(h) ((( h             >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
			
 
				+# else
			
 
				+#  define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
			
 
				+# endif
			
 
				+#endif
			
 
				+/*
			
 
				+ * IDX works because it is very similar to a multiplicative hash, e.g.
			
 
				+ * ((h * 57321 >> (3*8 - HLOG)) & (HSIZE - 1))
			
 
				+ * the latter is also quite fast on newer CPUs, and compresses similarly.
			
 
				+ *
			
 
				+ * the next one is also quite good, albeit slow ;)
			
 
				+ * (int)(cos(h & 0xffffff) * 1e6)
			
 
				+ */
			
 
				+
			
 
				+#if 0
			
 
				+/* original lzv-like hash function, much worse and thus slower */
			
 
				+# define FRST(p) (p[0] << 5) ^ p[1]
			
 
				+# define NEXT(v,p) ((v) << 5) ^ p[2]
			
 
				+# define IDX(h) ((h) & (HSIZE - 1))
			
 
				+#endif
			
 
				+
			
 
				+#define        MAX_LIT        (1 <<  5)
			
 
				+#define        MAX_OFF        (1 << 13)
			
 
				+#define        MAX_REF        ((1 << 8) + (1 << 3))
			
 
				+
			
 
				+#if __GNUC__ >= 3
			
 
				+# define expect(expr,value)         __builtin_expect ((expr),(value))
			
 
				+# define inline                     inline
			
 
				+#else
			
 
				+# define expect(expr,value)         (expr)
			
 
				+# define inline                     static
			
 
				+#endif
			
 
				+
			
 
				+#define expect_false(expr) expect ((expr) != 0, 0)
			
 
				+#define expect_true(expr)  expect ((expr) != 0, 1)
			
 
				+
			
 
				+#if defined(__has_attribute)
			
 
				+# if __has_attribute(no_sanitize)
			
 
				+#  define NO_SANITIZE(sanitizer) __attribute__((no_sanitize(sanitizer)))
			
 
				+# endif
			
 
				+#endif
			
 
				+
			
 
				+#if !defined(NO_SANITIZE)
			
 
				+# define NO_SANITIZE(sanitizer)
			
 
				+#endif
			
 
				+
			
 
				+/*
			
 
				+ * compressed format
			
 
				+ *
			
 
				+ * 000LLLLL <L+1>    ; literal, L+1=1..33 octets
			
 
				+ * LLLooooo oooooooo ; backref L+1=1..7 octets, o+1=1..4096 offset
			
 
				+ * 111ooooo LLLLLLLL oooooooo ; backref L+8 octets, o+1=1..4096 offset
			
 
				+ *
			
 
				+ */
			
 
				+NO_SANITIZE("alignment")
			
 
				+size_t
			
 
				+lzf_compress (const void *const in_data, size_t in_len,
			
 
				+	      void *out_data, size_t out_len
			
 
				+#if LZF_STATE_ARG
			
 
				+              , LZF_STATE htab
			
 
				+#endif
			
 
				+              )
			
 
				+{
			
 
				+#if !LZF_STATE_ARG
			
 
				+  LZF_STATE htab;
			
 
				+#endif
			
 
				+  const u8 *ip = (const u8 *)in_data;
			
 
				+        u8 *op = (u8 *)out_data;
			
 
				+  const u8 *in_end  = ip + in_len;
			
 
				+        u8 *out_end = op + out_len;
			
 
				+  const u8 *ref;
			
 
				+
			
 
				+  /* off requires a type wide enough to hold a general pointer difference.
			
 
				+   * ISO C doesn't have that (size_t might not be enough and ptrdiff_t only
			
 
				+   * works for differences within a single object). We also assume that no
			
 
				+   * no bit pattern traps. Since the only platform that is both non-POSIX
			
 
				+   * and fails to support both assumptions is windows 64 bit, we make a
			
 
				+   * special workaround for it.
			
 
				+   */
			
 
				+#if defined (WIN32) && defined (_M_X64)
			
 
				+  unsigned _int64 off; /* workaround for missing POSIX compliance */
			
 
				+#else
			
 
				+  size_t off;
			
 
				+#endif
			
 
				+  unsigned int hval;
			
 
				+  int lit;
			
 
				+
			
 
				+  if (!in_len || !out_len)
			
 
				+    return 0;
			
 
				+
			
 
				+#if INIT_HTAB
			
 
				+  memset (htab, 0, sizeof (htab));
			
 
				+#endif
			
 
				+
			
 
				+  lit = 0; op++; /* start run */
			
 
				+
			
 
				+  hval = FRST (ip);
			
 
				+  while (ip < in_end - 2)
			
 
				+    {
			
 
				+      LZF_HSLOT *hslot;
			
 
				+
			
 
				+      hval = NEXT (hval, ip);
			
 
				+      hslot = htab + IDX (hval);
			
 
				+      ref = *hslot ? (*hslot + LZF_HSLOT_BIAS) : NULL; /* avoid applying zero offset to null pointer */
			
 
				+      *hslot = ip - LZF_HSLOT_BIAS;
			
 
				+
			
 
				+      if (1
			
 
				+#if INIT_HTAB
			
 
				+          && ref < ip /* the next test will actually take care of this, but this is faster */
			
 
				+#endif
			
 
				+          && (off = ip - ref - 1) < MAX_OFF
			
 
				+          && ref > (u8 *)in_data
			
 
				+          && ref[2] == ip[2]
			
 
				+#if STRICT_ALIGN
			
 
				+          && ((ref[1] << 8) | ref[0]) == ((ip[1] << 8) | ip[0])
			
 
				+#else
			
 
				+          && *(u16 *)ref == *(u16 *)ip
			
 
				+#endif
			
 
				+        )
			
 
				+        {
			
 
				+          /* match found at *ref++ */
			
 
				+          unsigned int len = 2;
			
 
				+          size_t maxlen = in_end - ip - len;
			
 
				+          maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
			
 
				+
			
 
				+          if (expect_false (op + 3 + 1 >= out_end)) /* first a faster conservative test */
			
 
				+            if (op - !lit + 3 + 1 >= out_end) /* second the exact but rare test */
			
 
				+              return 0;
			
 
				+
			
 
				+          op [- lit - 1] = lit - 1; /* stop run */
			
 
				+          op -= !lit; /* undo run if length is zero */
			
 
				+
			
 
				+          for (;;)
			
 
				+            {
			
 
				+              if (expect_true (maxlen > 16))
			
 
				+                {
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                  len++; if (ref [len] != ip [len]) break;
			
 
				+                }
			
 
				+
			
 
				+              do
			
 
				+                len++;
			
 
				+              while (len < maxlen && ref[len] == ip[len]);
			
 
				+
			
 
				+              break;
			
 
				+            }
			
 
				+
			
 
				+          len -= 2; /* len is now #octets - 1 */
			
 
				+          ip++;
			
 
				+
			
 
				+          if (len < 7)
			
 
				+            {
			
 
				+              *op++ = (off >> 8) + (len << 5);
			
 
				+            }
			
 
				+          else
			
 
				+            {
			
 
				+              *op++ = (off >> 8) + (  7 << 5);
			
 
				+              *op++ = len - 7;
			
 
				+            }
			
 
				+
			
 
				+          *op++ = off;
			
 
				+
			
 
				+          lit = 0; op++; /* start run */
			
 
				+
			
 
				+          ip += len + 1;
			
 
				+
			
 
				+          if (expect_false (ip >= in_end - 2))
			
 
				+            break;
			
 
				+
			
 
				+#if ULTRA_FAST || VERY_FAST
			
 
				+          --ip;
			
 
				+# if VERY_FAST && !ULTRA_FAST
			
 
				+          --ip;
			
 
				+# endif
			
 
				+          hval = FRST (ip);
			
 
				+
			
 
				+          hval = NEXT (hval, ip);
			
 
				+          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
			
 
				+          ip++;
			
 
				+
			
 
				+# if VERY_FAST && !ULTRA_FAST
			
 
				+          hval = NEXT (hval, ip);
			
 
				+          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
			
 
				+          ip++;
			
 
				+# endif
			
 
				+#else
			
 
				+          ip -= len + 1;
			
 
				+
			
 
				+          do
			
 
				+            {
			
 
				+              hval = NEXT (hval, ip);
			
 
				+              htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
			
 
				+              ip++;
			
 
				+            }
			
 
				+          while (len--);
			
 
				+#endif
			
 
				+        }
			
 
				+      else
			
 
				+        {
			
 
				+          /* one more literal byte we must copy */
			
 
				+          if (expect_false (op >= out_end))
			
 
				+            return 0;
			
 
				+
			
 
				+          lit++; *op++ = *ip++;
			
 
				+
			
 
				+          if (expect_false (lit == MAX_LIT))
			
 
				+            {
			
 
				+              op [- lit - 1] = lit - 1; /* stop run */
			
 
				+              lit = 0; op++; /* start run */
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+  if (op + 3 > out_end) /* at most 3 bytes can be missing here */
			
 
				+    return 0;
			
 
				+
			
 
				+  while (ip < in_end)
			
 
				+    {
			
 
				+      lit++; *op++ = *ip++;
			
 
				+
			
 
				+      if (expect_false (lit == MAX_LIT))
			
 
				+        {
			
 
				+          op [- lit - 1] = lit - 1; /* stop run */
			
 
				+          lit = 0; op++; /* start run */
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+  op [- lit - 1] = lit - 1; /* end run */
			
 
				+  op -= !lit; /* undo run if length is zero */
			
 
				+
			
 
				+  return op - (u8 *)out_data;
			
 
				+}
			
 
				+
			
--- a/src/lzf_d.c
+++ b/src/lzf_d.c
@@ -0,0 +1,191 @@
 
				+/*
			
 
				+ * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
			
 
				+ *
			
 
				+ * Redistribution and use in source and binary forms, with or without modifica-
			
 
				+ * tion, are permitted provided that the following conditions are met:
			
 
				+ *
			
 
				+ *   1.  Redistributions of source code must retain the above copyright notice,
			
 
				+ *       this list of conditions and the following disclaimer.
			
 
				+ *
			
 
				+ *   2.  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.
			
 
				+ *
			
 
				+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
			
 
				+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
			
 
				+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
			
 
				+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
			
 
				+ * CIAL, 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 OTH-
			
 
				+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
			
 
				+ * OF THE POSSIBILITY OF SUCH DAMAGE.
			
 
				+ *
			
 
				+ * Alternatively, the contents of this file may be used under the terms of
			
 
				+ * the GNU General Public License ("GPL") version 2 or any later version,
			
 
				+ * in which case the provisions of the GPL are applicable instead of
			
 
				+ * the above. If you wish to allow the use of your version of this file
			
 
				+ * only under the terms of the GPL and not to allow others to use your
			
 
				+ * version of this file under the BSD license, indicate your decision
			
 
				+ * by deleting the provisions above and replace them with the notice
			
 
				+ * and other provisions required by the GPL. If you do not delete the
			
 
				+ * provisions above, a recipient may use your version of this file under
			
 
				+ * either the BSD or the GPL.
			
 
				+ */
			
 
				+
			
 
				+#include "lzfP.h"
			
 
				+
			
 
				+#if AVOID_ERRNO
			
 
				+# define SET_ERRNO(n)
			
 
				+#else
			
 
				+# include <errno.h>
			
 
				+# define SET_ERRNO(n) errno = (n)
			
 
				+#endif
			
 
				+
			
 
				+#if USE_REP_MOVSB /* small win on amd, big loss on intel */
			
 
				+#if (__i386 || __amd64) && __GNUC__ >= 3
			
 
				+# define lzf_movsb(dst, src, len)                \
			
 
				+   asm ("rep movsb"                              \
			
 
				+        : "=D" (dst), "=S" (src), "=c" (len)     \
			
 
				+        :  "0" (dst),  "1" (src),  "2" (len));
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+#if defined(__GNUC__) && __GNUC__ >= 7
			
 
				+#pragma GCC diagnostic push
			
 
				+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
			
 
				+#endif
			
 
				+size_t
			
 
				+lzf_decompress (const void *const in_data,  size_t in_len,
			
 
				+                void             *out_data, size_t out_len)
			
 
				+{
			
 
				+  u8 const *ip = (const u8 *)in_data;
			
 
				+  u8       *op = (u8 *)out_data;
			
 
				+  u8 const *const in_end  = ip + in_len;
			
 
				+  u8       *const out_end = op + out_len;
			
 
				+
			
 
				+  while (ip < in_end)
			
 
				+    {
			
 
				+      unsigned int ctrl;
			
 
				+      ctrl = *ip++;
			
 
				+
			
 
				+      if (ctrl < (1 << 5)) /* literal run */
			
 
				+        {
			
 
				+          ctrl++;
			
 
				+
			
 
				+          if (op + ctrl > out_end)
			
 
				+            {
			
 
				+              SET_ERRNO (E2BIG);
			
 
				+              return 0;
			
 
				+            }
			
 
				+
			
 
				+#if CHECK_INPUT
			
 
				+          if (ip + ctrl > in_end)
			
 
				+            {
			
 
				+              SET_ERRNO (EINVAL);
			
 
				+              return 0;
			
 
				+            }
			
 
				+#endif
			
 
				+
			
 
				+#ifdef lzf_movsb
			
 
				+          lzf_movsb (op, ip, ctrl);
			
 
				+#else
			
 
				+          switch (ctrl)
			
 
				+            {
			
 
				+              case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++; case 29: *op++ = *ip++;
			
 
				+              case 28: *op++ = *ip++; case 27: *op++ = *ip++; case 26: *op++ = *ip++; case 25: *op++ = *ip++;
			
 
				+              case 24: *op++ = *ip++; case 23: *op++ = *ip++; case 22: *op++ = *ip++; case 21: *op++ = *ip++;
			
 
				+              case 20: *op++ = *ip++; case 19: *op++ = *ip++; case 18: *op++ = *ip++; case 17: *op++ = *ip++;
			
 
				+              case 16: *op++ = *ip++; case 15: *op++ = *ip++; case 14: *op++ = *ip++; case 13: *op++ = *ip++;
			
 
				+              case 12: *op++ = *ip++; case 11: *op++ = *ip++; case 10: *op++ = *ip++; case  9: *op++ = *ip++;
			
 
				+              case  8: *op++ = *ip++; case  7: *op++ = *ip++; case  6: *op++ = *ip++; case  5: *op++ = *ip++;
			
 
				+              case  4: *op++ = *ip++; case  3: *op++ = *ip++; case  2: *op++ = *ip++; case  1: *op++ = *ip++;
			
 
				+            }
			
 
				+#endif
			
 
				+        }
			
 
				+      else /* back reference */
			
 
				+        {
			
 
				+          unsigned int len = ctrl >> 5;
			
 
				+
			
 
				+          u8 *ref = op - ((ctrl & 0x1f) << 8) - 1;
			
 
				+
			
 
				+#if CHECK_INPUT
			
 
				+          if (ip >= in_end)
			
 
				+            {
			
 
				+              SET_ERRNO (EINVAL);
			
 
				+              return 0;
			
 
				+            }
			
 
				+#endif
			
 
				+          if (len == 7)
			
 
				+            {
			
 
				+              len += *ip++;
			
 
				+#if CHECK_INPUT
			
 
				+              if (ip >= in_end)
			
 
				+                {
			
 
				+                  SET_ERRNO (EINVAL);
			
 
				+                  return 0;
			
 
				+                }
			
 
				+#endif
			
 
				+            }
			
 
				+
			
 
				+          ref -= *ip++;
			
 
				+
			
 
				+          if (op + len + 2 > out_end)
			
 
				+            {
			
 
				+              SET_ERRNO (E2BIG);
			
 
				+              return 0;
			
 
				+            }
			
 
				+
			
 
				+          if (ref < (u8 *)out_data)
			
 
				+            {
			
 
				+              SET_ERRNO (EINVAL);
			
 
				+              return 0;
			
 
				+            }
			
 
				+
			
 
				+#ifdef lzf_movsb
			
 
				+          len += 2;
			
 
				+          lzf_movsb (op, ref, len);
			
 
				+#else
			
 
				+          switch (len)
			
 
				+            {
			
 
				+              default:
			
 
				+                len += 2;
			
 
				+
			
 
				+                if (op >= ref + len)
			
 
				+                  {
			
 
				+                    /* disjunct areas */
			
 
				+                    memcpy (op, ref, len);
			
 
				+                    op += len;
			
 
				+                  }
			
 
				+                else
			
 
				+                  {
			
 
				+                    /* overlapping, use octte by octte copying */
			
 
				+                    do
			
 
				+                      *op++ = *ref++;
			
 
				+                    while (--len);
			
 
				+                  }
			
 
				+
			
 
				+                break;
			
 
				+
			
 
				+              case 9: *op++ = *ref++; /* fall-thru */
			
 
				+              case 8: *op++ = *ref++; /* fall-thru */
			
 
				+              case 7: *op++ = *ref++; /* fall-thru */
			
 
				+              case 6: *op++ = *ref++; /* fall-thru */
			
 
				+              case 5: *op++ = *ref++; /* fall-thru */
			
 
				+              case 4: *op++ = *ref++; /* fall-thru */
			
 
				+              case 3: *op++ = *ref++; /* fall-thru */
			
 
				+              case 2: *op++ = *ref++; /* fall-thru */
			
 
				+              case 1: *op++ = *ref++; /* fall-thru */
			
 
				+              case 0: *op++ = *ref++; /* two octets more */
			
 
				+                      *op++ = *ref++; /* fall-thru */
			
 
				+            }
			
 
				+#endif
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+  return op - (u8 *)out_data;
			
 
				+}
			
 
				+#if defined(__GNUC__) && __GNUC__ >= 5
			
 
				+#pragma GCC diagnostic pop
			
 
				+#endif
			
--- a/src/main.c
+++ b/src/main.c
@@ -0,0 +1,206 @@
 
				+#include <uv.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <llhttp.h>
			
 
				+#include "logger.h"
			
 
				+#include "dict.h"
			
 
				+#include <string.h>
			
 
				+
			
 
				+void on_alloc_buff(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
			
 
				+{
			
 
				+    if (suggested_size <= 0)
			
 
				+    {
			
 
				+        return;
			
 
				+    }
			
 
				+    info("suggested_size=%d\n", suggested_size);
			
 
				+    char* buffer = (char*)malloc(suggested_size);
			
 
				+    *buf = uv_buf_init(buffer, suggested_size);
			
 
				+}
			
 
				+
			
 
				+int on_status(llhttp_t* h, const char *at, size_t length)
			
 
				+{
			
 
				+    char buf[8] ={0};
			
 
				+    strncpy(buf, at, length);
			
 
				+    info("status=%s\n", buf);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_body(llhttp_t* h, const char *at, size_t length)
			
 
				+{
			
 
				+    char buf[256] ={0};
			
 
				+    strncpy(buf, at, length);
			
 
				+    info("body: %s\n", buf);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_url(llhttp_t* h, const char *at, size_t length)
			
 
				+{
			
 
				+    char buf[256] ={0};
			
 
				+    strncpy(buf, at, length);
			
 
				+    info("url:%s\n", buf);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_header_field(llhttp_t* h, const char *at, size_t length)
			
 
				+{
			
 
				+    char buf[256] ={0};
			
 
				+    strncpy(buf, at, length);
			
 
				+    info("field:%s\n", buf);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_header_value(llhttp_t* h, const char *at, size_t length)
			
 
				+{
			
 
				+    char buf[256] ={0};
			
 
				+    strncpy(buf, at, length);
			
 
				+    info("value:%s\n", buf);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_headers_completed(llhttp_t* h)
			
 
				+{
			
 
				+    // info("on_headers_completed:HTTP %d/%d METHOD:%d STATUS CODE:%d, CONTENT-LENGTH, data:%s\n", 
			
 
				+    //     h->http_major, h->http_minor, h->method, h->status_code, h->content_length, h->header_state,
			
 
				+    //     (char*)h->data);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+int on_message_completed(llhttp_t* h)
			
 
				+{
			
 
				+    info("HTTP %d/%d METHOD:%d STATUS CODE:%d, CONTENT-LENGTH, data:%s\n", 
			
 
				+        h->http_major, h->http_minor, h->method, h->status_code, h->content_length, h->header_state,
			
 
				+        (char*)h->data);
			
 
				+    return HPE_OK;
			
 
				+}
			
 
				+
			
 
				+void on_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
			
 
				+{
			
 
				+    if (nread <= 0)
			
 
				+    {
			
 
				+        if (nread == UV_EOF) {
			
 
				+            fprintf(stdout, "read to the end \n");
			
 
				+        }
			
 
				+        fprintf(stdout, "remote closed the connection \n");
			
 
				+        uv_close((uv_handle_t*)stream, NULL);
			
 
				+        free((uv_tcp_t*)stream);
			
 
				+    }
			
 
				+    else
			
 
				+    {
			
 
				+        llhttp_t parser;
			
 
				+        llhttp_settings_t settings;
			
 
				+        llhttp_settings_init(&settings);
			
 
				+        settings.on_headers_complete = on_headers_completed;
			
 
				+        settings.on_body = on_body;
			
 
				+        settings.on_url = on_url;
			
 
				+        settings.on_header_field = on_header_field;
			
 
				+        settings.on_header_value = on_header_value;
			
 
				+        // settings.on_status = on_status;
			
 
				+        settings.on_message_complete = on_message_completed;
			
 
				+        llhttp_init(&parser, HTTP_BOTH, &settings);
			
 
				+
			
 
				+        // info("parsing[%d]: %s\n", nread, buf->base);
			
 
				+        enum llhttp_errno err = llhttp_execute(&parser, buf->base, nread);
			
 
				+        if (err != HPE_OK) {
			
 
				+            info("parse error:%s\n", llhttp_errno_name(err));
			
 
				+        } else {
			
 
				+            info("parse ok.\n");
			
 
				+        }
			
 
				+
			
 
				+        // fprintf(stdout, "received: %ld content: %s\n", nread, buf->base);
			
 
				+    }
			
 
				+    if (buf->base) {
			
 
				+        free(buf->base);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+void on_new_connection(uv_stream_t *server, int status)
			
 
				+{
			
 
				+    if (status < 0)
			
 
				+    {
			
 
				+        fprintf(stderr, "new connection error: %s\n", uv_strerror(status));
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    fprintf(stdout, "new connection\n");
			
 
				+    uv_tcp_t *client = (uv_tcp_t *)malloc(sizeof(uv_tcp_t));
			
 
				+    uv_tcp_init(uv_default_loop(), client);
			
 
				+    int r = uv_accept(server, (uv_stream_t *)client);
			
 
				+    if (r)
			
 
				+    {
			
 
				+        fprintf(stderr, "accept error: %s\n", uv_strerror(r));
			
 
				+        free(client);
			
 
				+        return;
			
 
				+    }
			
 
				+    uv_read_start((uv_stream_t *)client, on_alloc_buff, on_read);
			
 
				+}
			
 
				+
			
 
				+
			
 
				+void test_llhttp();
			
 
				+
			
 
				+void test_dict() {
			
 
				+    dict* d = dictCreate(NULL);
			
 
				+    if (!d) {
			
 
				+        info('great!\n');
			
 
				+        return;
			
 
				+    }
			
 
				+    int ec = dictAdd(d, (void*)"good", (void*)"gg");
			
 
				+    if (ec) {
			
 
				+        info("ec:%d\n", ec);
			
 
				+        goto err;
			
 
				+    }
			
 
				+
			
 
				+    // ec = dictAdd(d, (void*)"great", (void*)"hhh");
			
 
				+    // dictEntry* v = dictFind(d, (const void*)"good");
			
 
				+    // if (v != NULL) {
			
 
				+    //     info("%s\n", (char*)v->v.val);
			
 
				+    // }
			
 
				+err:
			
 
				+    dictRelease(d);
			
 
				+}
			
 
				+
			
 
				+int main()
			
 
				+{
			
 
				+    test_dict();
			
 
				+    return 0;
			
 
				+    uv_loop_t *loop = uv_default_loop();
			
 
				+
			
 
				+    uv_tcp_t tcp;
			
 
				+
			
 
				+    uv_tcp_init(loop, &tcp);
			
 
				+
			
 
				+    struct sockaddr_in addr;
			
 
				+    uv_ip4_addr("0.0.0.0", 8000, &addr);
			
 
				+
			
 
				+    uv_tcp_bind(&tcp, (const struct sockaddr *)&addr, 0);
			
 
				+
			
 
				+    int r = uv_listen((uv_stream_t *)&tcp, 512, on_new_connection);
			
 
				+    if (r)
			
 
				+    {
			
 
				+        fprintf(stderr, "listen error: %s\n", uv_strerror(r));
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    uv_run(loop, UV_RUN_DEFAULT);
			
 
				+    uv_loop_close(loop);
			
 
				+
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+void test_llhttp() {
			
 
				+    const char* req = "GET /products?g=d HTTP/1.1\r\n \
			
 
				+Host: localhost:8000\r\n \
			
 
				+User-Agent: curl/7.79.1\r\n \
			
 
				+Accept: */*\r\n";
			
 
				+    llhttp_t parser;
			
 
				+    llhttp_settings_t settings;
			
 
				+    llhttp_settings_init(&settings);
			
 
				+    settings.on_headers_complete = on_message_completed;
			
 
				+    llhttp_init(&parser, HTTP_BOTH, &settings);
			
 
				+
			
 
				+    info("req: %s\n", req);
			
 
				+    enum llhttp_errno err = llhttp_execute(&parser, req, strlen(req));
			
 
				+    if (err != HPE_OK) {
			
 
				+        info("parse error:%s\n", llhttp_errno_name(err));
			
 
				+    } else {
			
 
				+        info("parse ok.\n");
			
 
				+    }
			
 
				+}
			
--- a/src/monotonic.c
+++ b/src/monotonic.c
@@ -0,0 +1,170 @@
 
				+#include "monotonic.h"
			
 
				+#include <stddef.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <stdio.h>
			
 
				+#include <time.h>
			
 
				+
			
 
				+#undef NDEBUG
			
 
				+#include <assert.h>
			
 
				+
			
 
				+
			
 
				+/* The function pointer for clock retrieval.  */
			
 
				+monotime (*getMonotonicUs)(void) = NULL;
			
 
				+
			
 
				+static char monotonic_info_string[32];
			
 
				+
			
 
				+
			
 
				+/* Using the processor clock (aka TSC on x86) can provide improved performance
			
 
				+ * throughout Redis wherever the monotonic clock is used.  The processor clock
			
 
				+ * is significantly faster than calling 'clock_getting' (POSIX).  While this is
			
 
				+ * generally safe on modern systems, this link provides additional information
			
 
				+ * about use of the x86 TSC: http://oliveryang.net/2015/09/pitfalls-of-TSC-usage
			
 
				+ *
			
 
				+ * To use the processor clock, either uncomment this line, or build with
			
 
				+ *   CFLAGS="-DUSE_PROCESSOR_CLOCK"
			
 
				+#define USE_PROCESSOR_CLOCK
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+#if defined(USE_PROCESSOR_CLOCK) && defined(__x86_64__) && defined(__linux__)
			
 
				+#include <regex.h>
			
 
				+#include <x86intrin.h>
			
 
				+
			
 
				+static long mono_ticksPerMicrosecond = 0;
			
 
				+
			
 
				+static monotime getMonotonicUs_x86() {
			
 
				+    return __rdtsc() / mono_ticksPerMicrosecond;
			
 
				+}
			
 
				+
			
 
				+static void monotonicInit_x86linux() {
			
 
				+    const int bufflen = 256;
			
 
				+    char buf[bufflen];
			
 
				+    regex_t cpuGhzRegex, constTscRegex;
			
 
				+    const size_t nmatch = 2;
			
 
				+    regmatch_t pmatch[nmatch];
			
 
				+    int constantTsc = 0;
			
 
				+    int rc;
			
 
				+
			
 
				+    /* Determine the number of TSC ticks in a micro-second.  This is
			
 
				+     * a constant value matching the standard speed of the processor.
			
 
				+     * On modern processors, this speed remains constant even though
			
 
				+     * the actual clock speed varies dynamically for each core.  */
			
 
				+    rc = regcomp(&cpuGhzRegex, "^model name\\s+:.*@ ([0-9.]+)GHz", REG_EXTENDED);
			
 
				+    assert(rc == 0);
			
 
				+
			
 
				+    /* Also check that the constant_tsc flag is present.  (It should be
			
 
				+     * unless this is a really old CPU.  */
			
 
				+    rc = regcomp(&constTscRegex, "^flags\\s+:.* constant_tsc", REG_EXTENDED);
			
 
				+    assert(rc == 0);
			
 
				+
			
 
				+    FILE *cpuinfo = fopen("/proc/cpuinfo", "r");
			
 
				+    if (cpuinfo != NULL) {
			
 
				+        while (fgets(buf, bufflen, cpuinfo) != NULL) {
			
 
				+            if (regexec(&cpuGhzRegex, buf, nmatch, pmatch, 0) == 0) {
			
 
				+                buf[pmatch[1].rm_eo] = '\0';
			
 
				+                double ghz = atof(&buf[pmatch[1].rm_so]);
			
 
				+                mono_ticksPerMicrosecond = (long)(ghz * 1000);
			
 
				+                break;
			
 
				+            }
			
 
				+        }
			
 
				+        while (fgets(buf, bufflen, cpuinfo) != NULL) {
			
 
				+            if (regexec(&constTscRegex, buf, nmatch, pmatch, 0) == 0) {
			
 
				+                constantTsc = 1;
			
 
				+                break;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        fclose(cpuinfo);
			
 
				+    }
			
 
				+    regfree(&cpuGhzRegex);
			
 
				+    regfree(&constTscRegex);
			
 
				+
			
 
				+    if (mono_ticksPerMicrosecond == 0) {
			
 
				+        fprintf(stderr, "monotonic: x86 linux, unable to determine clock rate");
			
 
				+        return;
			
 
				+    }
			
 
				+    if (!constantTsc) {
			
 
				+        fprintf(stderr, "monotonic: x86 linux, 'constant_tsc' flag not present");
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    snprintf(monotonic_info_string, sizeof(monotonic_info_string),
			
 
				+            "X86 TSC @ %ld ticks/us", mono_ticksPerMicrosecond);
			
 
				+    getMonotonicUs = getMonotonicUs_x86;
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+
			
 
				+#if defined(USE_PROCESSOR_CLOCK) && defined(__aarch64__)
			
 
				+static long mono_ticksPerMicrosecond = 0;
			
 
				+
			
 
				+/* Read the clock value.  */
			
 
				+static inline uint64_t __cntvct() {
			
 
				+    uint64_t virtual_timer_value;
			
 
				+    __asm__ volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
			
 
				+    return virtual_timer_value;
			
 
				+}
			
 
				+
			
 
				+/* Read the Count-timer Frequency.  */
			
 
				+static inline uint32_t cntfrq_hz() {
			
 
				+    uint64_t virtual_freq_value;
			
 
				+    __asm__ volatile("mrs %0, cntfrq_el0" : "=r"(virtual_freq_value));
			
 
				+    return (uint32_t)virtual_freq_value;    /* top 32 bits are reserved */
			
 
				+}
			
 
				+
			
 
				+static monotime getMonotonicUs_aarch64() {
			
 
				+    return __cntvct() / mono_ticksPerMicrosecond;
			
 
				+}
			
 
				+
			
 
				+static void monotonicInit_aarch64() {
			
 
				+    mono_ticksPerMicrosecond = (long)cntfrq_hz() / 1000L / 1000L;
			
 
				+    if (mono_ticksPerMicrosecond == 0) {
			
 
				+        fprintf(stderr, "monotonic: aarch64, unable to determine clock rate");
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    snprintf(monotonic_info_string, sizeof(monotonic_info_string),
			
 
				+            "ARM CNTVCT @ %ld ticks/us", mono_ticksPerMicrosecond);
			
 
				+    getMonotonicUs = getMonotonicUs_aarch64;
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+
			
 
				+static monotime getMonotonicUs_posix() {
			
 
				+    /* clock_gettime() is specified in POSIX.1b (1993).  Even so, some systems
			
 
				+     * did not support this until much later.  CLOCK_MONOTONIC is technically
			
 
				+     * optional and may not be supported - but it appears to be universal.
			
 
				+     * If this is not supported, provide a system-specific alternate version.  */
			
 
				+    struct timespec ts;
			
 
				+    clock_gettime(CLOCK_MONOTONIC, &ts);
			
 
				+    return ((uint64_t)ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
			
 
				+}
			
 
				+
			
 
				+static void monotonicInit_posix() {
			
 
				+    /* Ensure that CLOCK_MONOTONIC is supported.  This should be supported
			
 
				+     * on any reasonably current OS.  If the assertion below fails, provide
			
 
				+     * an appropriate alternate implementation.  */
			
 
				+    struct timespec ts;
			
 
				+    int rc = clock_gettime(CLOCK_MONOTONIC, &ts);
			
 
				+    assert(rc == 0);
			
 
				+
			
 
				+    snprintf(monotonic_info_string, sizeof(monotonic_info_string),
			
 
				+            "POSIX clock_gettime");
			
 
				+    getMonotonicUs = getMonotonicUs_posix;
			
 
				+}
			
 
				+
			
 
				+
			
 
				+
			
 
				+const char * monotonicInit() {
			
 
				+    #if defined(USE_PROCESSOR_CLOCK) && defined(__x86_64__) && defined(__linux__)
			
 
				+    if (getMonotonicUs == NULL) monotonicInit_x86linux();
			
 
				+    #endif
			
 
				+
			
 
				+    #if defined(USE_PROCESSOR_CLOCK) && defined(__aarch64__)
			
 
				+    if (getMonotonicUs == NULL) monotonicInit_aarch64();
			
 
				+    #endif
			
 
				+
			
 
				+    if (getMonotonicUs == NULL) monotonicInit_posix();
			
 
				+
			
 
				+    return monotonic_info_string;
			
 
				+}
			
--- a/src/monotonic.h
+++ b/src/monotonic.h
@@ -0,0 +1,52 @@
 
				+#ifndef __MONOTONIC_H
			
 
				+#define __MONOTONIC_H
			
 
				+/* The monotonic clock is an always increasing clock source.  It is unrelated to
			
 
				+ * the actual time of day and should only be used for relative timings.  The
			
 
				+ * monotonic clock is also not guaranteed to be chronologically precise; there
			
 
				+ * may be slight skew/shift from a precise clock.
			
 
				+ *
			
 
				+ * Depending on system architecture, the monotonic time may be able to be
			
 
				+ * retrieved much faster than a normal clock source by using an instruction
			
 
				+ * counter on the CPU.  On x86 architectures (for example), the RDTSC
			
 
				+ * instruction is a very fast clock source for this purpose.
			
 
				+ */
			
 
				+
			
 
				+#include "fmacros.h"
			
 
				+#include <stdint.h>
			
 
				+#include <unistd.h>
			
 
				+
			
 
				+/* A counter in micro-seconds.  The 'monotime' type is provided for variables
			
 
				+ * holding a monotonic time.  This will help distinguish & document that the
			
 
				+ * variable is associated with the monotonic clock and should not be confused
			
 
				+ * with other types of time.*/
			
 
				+typedef uint64_t monotime;
			
 
				+
			
 
				+/* Retrieve counter of micro-seconds relative to an arbitrary point in time.  */
			
 
				+extern monotime (*getMonotonicUs)(void);
			
 
				+
			
 
				+
			
 
				+/* Call once at startup to initialize the monotonic clock.  Though this only
			
 
				+ * needs to be called once, it may be called additional times without impact.
			
 
				+ * Returns a printable string indicating the type of clock initialized.
			
 
				+ * (The returned string is static and doesn't need to be freed.)  */
			
 
				+const char * monotonicInit();
			
 
				+
			
 
				+
			
 
				+/* Functions to measure elapsed time.  Example:
			
 
				+ *     monotime myTimer;
			
 
				+ *     elapsedStart(&myTimer);
			
 
				+ *     while (elapsedMs(myTimer) < 10) {} // loops for 10ms
			
 
				+ */
			
 
				+static inline void elapsedStart(monotime *start_time) {
			
 
				+    *start_time = getMonotonicUs();
			
 
				+}
			
 
				+
			
 
				+static inline uint64_t elapsedUs(monotime start_time) {
			
 
				+    return getMonotonicUs() - start_time;
			
 
				+}
			
 
				+
			
 
				+static inline uint64_t elapsedMs(monotime start_time) {
			
 
				+    return elapsedUs(start_time) / 1000;
			
 
				+}
			
 
				+
			
 
				+#endif
			
--- a/src/mt19937-64.c
+++ b/src/mt19937-64.c
@@ -0,0 +1,187 @@
 
				+/*
			
 
				+   A C-program for MT19937-64 (2004/9/29 version).
			
 
				+   Coded by Takuji Nishimura and Makoto Matsumoto.
			
 
				+
			
 
				+   This is a 64-bit version of Mersenne Twister pseudorandom number
			
 
				+   generator.
			
 
				+
			
 
				+   Before using, initialize the state by using init_genrand64(seed)
			
 
				+   or init_by_array64(init_key, key_length).
			
 
				+
			
 
				+   Copyright (C) 2004, Makoto Matsumoto and Takuji Nishimura,
			
 
				+   All rights reserved.
			
 
				+
			
 
				+   Redistribution and use in source and binary forms, with or without
			
 
				+   modification, are permitted provided that the following conditions
			
 
				+   are met:
			
 
				+
			
 
				+     1. Redistributions of source code must retain the above copyright
			
 
				+        notice, this list of conditions and the following disclaimer.
			
 
				+
			
 
				+     2. 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.
			
 
				+
			
 
				+     3. The names of its contributors may not 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.
			
 
				+
			
 
				+   References:
			
 
				+   T. Nishimura, ``Tables of 64-bit Mersenne Twisters''
			
 
				+     ACM Transactions on Modeling and
			
 
				+     Computer Simulation 10. (2000) 348--357.
			
 
				+   M. Matsumoto and T. Nishimura,
			
 
				+     ``Mersenne Twister: a 623-dimensionally equidistributed
			
 
				+       uniform pseudorandom number generator''
			
 
				+     ACM Transactions on Modeling and
			
 
				+     Computer Simulation 8. (Jan. 1998) 3--30.
			
 
				+
			
 
				+   Any feedback is very welcome.
			
 
				+   http://www.math.hiroshima-u.ac.jp/~m-mat/MT/emt.html
			
 
				+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove spaces)
			
 
				+*/
			
 
				+
			
 
				+
			
 
				+#include "mt19937-64.h"
			
 
				+#include <stdio.h>
			
 
				+
			
 
				+#define NN 312
			
 
				+#define MM 156
			
 
				+#define MATRIX_A 0xB5026F5AA96619E9ULL
			
 
				+#define UM 0xFFFFFFFF80000000ULL /* Most significant 33 bits */
			
 
				+#define LM 0x7FFFFFFFULL /* Least significant 31 bits */
			
 
				+
			
 
				+
			
 
				+/* The array for the state vector */
			
 
				+static unsigned long long mt[NN];
			
 
				+/* mti==NN+1 means mt[NN] is not initialized */
			
 
				+static int mti=NN+1;
			
 
				+
			
 
				+/* initializes mt[NN] with a seed */
			
 
				+void init_genrand64(unsigned long long seed)
			
 
				+{
			
 
				+    mt[0] = seed;
			
 
				+    for (mti=1; mti<NN; mti++)
			
 
				+        mt[mti] =  (6364136223846793005ULL * (mt[mti-1] ^ (mt[mti-1] >> 62)) + mti);
			
 
				+}
			
 
				+
			
 
				+/* initialize by an array with array-length */
			
 
				+/* init_key is the array for initializing keys */
			
 
				+/* key_length is its length */
			
 
				+void init_by_array64(unsigned long long init_key[],
			
 
				+                     unsigned long long key_length)
			
 
				+{
			
 
				+    unsigned long long i, j, k;
			
 
				+    init_genrand64(19650218ULL);
			
 
				+    i=1; j=0;
			
 
				+    k = (NN>key_length ? NN : key_length);
			
 
				+    for (; k; k--) {
			
 
				+        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 62)) * 3935559000370003845ULL))
			
 
				+          + init_key[j] + j; /* non linear */
			
 
				+        i++; j++;
			
 
				+        if (i>=NN) { mt[0] = mt[NN-1]; i=1; }
			
 
				+        if (j>=key_length) j=0;
			
 
				+    }
			
 
				+    for (k=NN-1; k; k--) {
			
 
				+        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 62)) * 2862933555777941757ULL))
			
 
				+          - i; /* non linear */
			
 
				+        i++;
			
 
				+        if (i>=NN) { mt[0] = mt[NN-1]; i=1; }
			
 
				+    }
			
 
				+
			
 
				+    mt[0] = 1ULL << 63; /* MSB is 1; assuring non-zero initial array */
			
 
				+}
			
 
				+
			
 
				+/* generates a random number on [0, 2^64-1]-interval */
			
 
				+unsigned long long genrand64_int64(void)
			
 
				+{
			
 
				+    int i;
			
 
				+    unsigned long long x;
			
 
				+    static unsigned long long mag01[2]={0ULL, MATRIX_A};
			
 
				+
			
 
				+    if (mti >= NN) { /* generate NN words at one time */
			
 
				+
			
 
				+        /* if init_genrand64() has not been called, */
			
 
				+        /* a default initial seed is used     */
			
 
				+        if (mti == NN+1)
			
 
				+            init_genrand64(5489ULL);
			
 
				+
			
 
				+        for (i=0;i<NN-MM;i++) {
			
 
				+            x = (mt[i]&UM)|(mt[i+1]&LM);
			
 
				+            mt[i] = mt[i+MM] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
			
 
				+        }
			
 
				+        for (;i<NN-1;i++) {
			
 
				+            x = (mt[i]&UM)|(mt[i+1]&LM);
			
 
				+            mt[i] = mt[i+(MM-NN)] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
			
 
				+        }
			
 
				+        x = (mt[NN-1]&UM)|(mt[0]&LM);
			
 
				+        mt[NN-1] = mt[MM-1] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
			
 
				+
			
 
				+        mti = 0;
			
 
				+    }
			
 
				+
			
 
				+    x = mt[mti++];
			
 
				+
			
 
				+    x ^= (x >> 29) & 0x5555555555555555ULL;
			
 
				+    x ^= (x << 17) & 0x71D67FFFEDA60000ULL;
			
 
				+    x ^= (x << 37) & 0xFFF7EEE000000000ULL;
			
 
				+    x ^= (x >> 43);
			
 
				+
			
 
				+    return x;
			
 
				+}
			
 
				+
			
 
				+/* generates a random number on [0, 2^63-1]-interval */
			
 
				+long long genrand64_int63(void)
			
 
				+{
			
 
				+    return (long long)(genrand64_int64() >> 1);
			
 
				+}
			
 
				+
			
 
				+/* generates a random number on [0,1]-real-interval */
			
 
				+double genrand64_real1(void)
			
 
				+{
			
 
				+    return (genrand64_int64() >> 11) * (1.0/9007199254740991.0);
			
 
				+}
			
 
				+
			
 
				+/* generates a random number on [0,1)-real-interval */
			
 
				+double genrand64_real2(void)
			
 
				+{
			
 
				+    return (genrand64_int64() >> 11) * (1.0/9007199254740992.0);
			
 
				+}
			
 
				+
			
 
				+/* generates a random number on (0,1)-real-interval */
			
 
				+double genrand64_real3(void)
			
 
				+{
			
 
				+    return ((genrand64_int64() >> 12) + 0.5) * (1.0/4503599627370496.0);
			
 
				+}
			
 
				+
			
 
				+#ifdef MT19937_64_MAIN
			
 
				+int main(void)
			
 
				+{
			
 
				+    int i;
			
 
				+    unsigned long long init[4]={0x12345ULL, 0x23456ULL, 0x34567ULL, 0x45678ULL}, length=4;
			
 
				+    init_by_array64(init, length);
			
 
				+    printf("1000 outputs of genrand64_int64()\n");
			
 
				+    for (i=0; i<1000; i++) {
			
 
				+      printf("%20llu ", genrand64_int64());
			
 
				+      if (i%5==4) printf("\n");
			
 
				+    }
			
 
				+    printf("\n1000 outputs of genrand64_real2()\n");
			
 
				+    for (i=0; i<1000; i++) {
			
 
				+      printf("%10.8f ", genrand64_real2());
			
 
				+      if (i%5==4) printf("\n");
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/mt19937-64.h
+++ b/src/mt19937-64.h
@@ -0,0 +1,87 @@
 
				+/*
			
 
				+   A C-program for MT19937-64 (2004/9/29 version).
			
 
				+   Coded by Takuji Nishimura and Makoto Matsumoto.
			
 
				+
			
 
				+   This is a 64-bit version of Mersenne Twister pseudorandom number
			
 
				+   generator.
			
 
				+
			
 
				+   Before using, initialize the state by using init_genrand64(seed)
			
 
				+   or init_by_array64(init_key, key_length).
			
 
				+
			
 
				+   Copyright (C) 2004, Makoto Matsumoto and Takuji Nishimura,
			
 
				+   All rights reserved.
			
 
				+
			
 
				+   Redistribution and use in source and binary forms, with or without
			
 
				+   modification, are permitted provided that the following conditions
			
 
				+   are met:
			
 
				+
			
 
				+     1. Redistributions of source code must retain the above copyright
			
 
				+        notice, this list of conditions and the following disclaimer.
			
 
				+
			
 
				+     2. 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.
			
 
				+
			
 
				+     3. The names of its contributors may not 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.
			
 
				+
			
 
				+   References:
			
 
				+   T. Nishimura, ``Tables of 64-bit Mersenne Twisters''
			
 
				+     ACM Transactions on Modeling and
			
 
				+     Computer Simulation 10. (2000) 348--357.
			
 
				+   M. Matsumoto and T. Nishimura,
			
 
				+     ``Mersenne Twister: a 623-dimensionally equidistributed
			
 
				+       uniform pseudorandom number generator''
			
 
				+     ACM Transactions on Modeling and
			
 
				+     Computer Simulation 8. (Jan. 1998) 3--30.
			
 
				+
			
 
				+   Any feedback is very welcome.
			
 
				+   http://www.math.hiroshima-u.ac.jp/~m-mat/MT/emt.html
			
 
				+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove spaces)
			
 
				+*/
			
 
				+
			
 
				+#ifndef __MT19937_64_H
			
 
				+#define __MT19937_64_H
			
 
				+
			
 
				+/* initializes mt[NN] with a seed */
			
 
				+void init_genrand64(unsigned long long seed);
			
 
				+
			
 
				+/* initialize by an array with array-length */
			
 
				+/* init_key is the array for initializing keys */
			
 
				+/* key_length is its length */
			
 
				+void init_by_array64(unsigned long long init_key[],
			
 
				+                     unsigned long long key_length);
			
 
				+
			
 
				+/* generates a random number on [0, 2^64-1]-interval */
			
 
				+unsigned long long genrand64_int64(void);
			
 
				+
			
 
				+
			
 
				+/* generates a random number on [0, 2^63-1]-interval */
			
 
				+long long genrand64_int63(void);
			
 
				+
			
 
				+/* generates a random number on [0,1]-real-interval */
			
 
				+double genrand64_real1(void);
			
 
				+
			
 
				+/* generates a random number on [0,1)-real-interval */
			
 
				+double genrand64_real2(void);
			
 
				+
			
 
				+/* generates a random number on (0,1)-real-interval */
			
 
				+double genrand64_real3(void);
			
 
				+
			
 
				+/* generates a random number on (0,1]-real-interval */
			
 
				+double genrand64_real4(void);
			
 
				+
			
 
				+#endif
			
--- a/src/pqsort.c
+++ b/src/pqsort.c
@@ -0,0 +1,185 @@
 
				+/* The following is the NetBSD libc qsort implementation modified in order to
			
 
				+ * support partial sorting of ranges for Redis.
			
 
				+ *
			
 
				+ * Copyright(C) 2009-2012 Salvatore Sanfilippo. All rights reserved.
			
 
				+ *
			
 
				+ * The original copyright notice follows. */
			
 
				+
			
 
				+
			
 
				+/*	$NetBSD: qsort.c,v 1.19 2009/01/30 23:38:44 lukem Exp $	*/
			
 
				+
			
 
				+/*-
			
 
				+ * Copyright (c) 1992, 1993
			
 
				+ *	The Regents of the University of California.  All rights reserved.
			
 
				+ *
			
 
				+ * Redistribution and use in source and binary forms, with or without
			
 
				+ * modification, are permitted provided that the following conditions
			
 
				+ * are met:
			
 
				+ * 1. Redistributions of source code must retain the above copyright
			
 
				+ *    notice, this list of conditions and the following disclaimer.
			
 
				+ * 2. 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.
			
 
				+ * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
			
 
				+ */
			
 
				+
			
 
				+#include <sys/types.h>
			
 
				+
			
 
				+#include <errno.h>
			
 
				+#include <stdlib.h>
			
 
				+
			
 
				+static inline char	*med3 (char *, char *, char *,
			
 
				+    int (*)(const void *, const void *));
			
 
				+static inline void	 swapfunc (char *, char *, size_t, int);
			
 
				+
			
 
				+#define min(a, b)	(a) < (b) ? a : b
			
 
				+
			
 
				+/*
			
 
				+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
			
 
				+ */
			
 
				+#define swapcode(TYPE, parmi, parmj, n) { 		\
			
 
				+	size_t i = (n) / sizeof (TYPE); 		\
			
 
				+	TYPE *pi = (TYPE *)(void *)(parmi); 		\
			
 
				+	TYPE *pj = (TYPE *)(void *)(parmj); 		\
			
 
				+	do { 						\
			
 
				+		TYPE	t = *pi;			\
			
 
				+		*pi++ = *pj;				\
			
 
				+		*pj++ = t;				\
			
 
				+        } while (--i > 0);				\
			
 
				+}
			
 
				+
			
 
				+#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
			
 
				+	es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
			
 
				+
			
 
				+static inline void
			
 
				+swapfunc(char *a, char *b, size_t n, int swaptype)
			
 
				+{
			
 
				+
			
 
				+	if (swaptype <= 1)
			
 
				+		swapcode(long, a, b, n)
			
 
				+	else
			
 
				+		swapcode(char, a, b, n)
			
 
				+}
			
 
				+
			
 
				+#define swap(a, b)						\
			
 
				+	if (swaptype == 0) {					\
			
 
				+		long t = *(long *)(void *)(a);			\
			
 
				+		*(long *)(void *)(a) = *(long *)(void *)(b);	\
			
 
				+		*(long *)(void *)(b) = t;			\
			
 
				+	} else							\
			
 
				+		swapfunc(a, b, es, swaptype)
			
 
				+
			
 
				+#define vecswap(a, b, n) if ((n) > 0) swapfunc((a), (b), (size_t)(n), swaptype)
			
 
				+
			
 
				+static inline char *
			
 
				+med3(char *a, char *b, char *c,
			
 
				+    int (*cmp) (const void *, const void *))
			
 
				+{
			
 
				+
			
 
				+	return cmp(a, b) < 0 ?
			
 
				+	       (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
			
 
				+              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
			
 
				+}
			
 
				+
			
 
				+static void
			
 
				+_pqsort(void *a, size_t n, size_t es,
			
 
				+    int (*cmp) (const void *, const void *), void *lrange, void *rrange)
			
 
				+{
			
 
				+	char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
			
 
				+	size_t d, r;
			
 
				+	int swaptype, cmp_result;
			
 
				+
			
 
				+loop:	SWAPINIT(a, es);
			
 
				+	if (n < 7) {
			
 
				+		for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
			
 
				+			for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
			
 
				+			     pl -= es)
			
 
				+				swap(pl, pl - es);
			
 
				+		return;
			
 
				+	}
			
 
				+	pm = (char *) a + (n / 2) * es;
			
 
				+	if (n > 7) {
			
 
				+		pl = (char *) a;
			
 
				+		pn = (char *) a + (n - 1) * es;
			
 
				+		if (n > 40) {
			
 
				+			d = (n / 8) * es;
			
 
				+			pl = med3(pl, pl + d, pl + 2 * d, cmp);
			
 
				+			pm = med3(pm - d, pm, pm + d, cmp);
			
 
				+			pn = med3(pn - 2 * d, pn - d, pn, cmp);
			
 
				+		}
			
 
				+		pm = med3(pl, pm, pn, cmp);
			
 
				+	}
			
 
				+	swap(a, pm);
			
 
				+	pa = pb = (char *) a + es;
			
 
				+
			
 
				+	pc = pd = (char *) a + (n - 1) * es;
			
 
				+	for (;;) {
			
 
				+		while (pb <= pc && (cmp_result = cmp(pb, a)) <= 0) {
			
 
				+			if (cmp_result == 0) {
			
 
				+				swap(pa, pb);
			
 
				+				pa += es;
			
 
				+			}
			
 
				+			pb += es;
			
 
				+		}
			
 
				+		while (pb <= pc && (cmp_result = cmp(pc, a)) >= 0) {
			
 
				+			if (cmp_result == 0) {
			
 
				+				swap(pc, pd);
			
 
				+				pd -= es;
			
 
				+			}
			
 
				+			pc -= es;
			
 
				+		}
			
 
				+		if (pb > pc)
			
 
				+			break;
			
 
				+		swap(pb, pc);
			
 
				+		pb += es;
			
 
				+		pc -= es;
			
 
				+	}
			
 
				+
			
 
				+	pn = (char *) a + n * es;
			
 
				+	r = min(pa - (char *) a, pb - pa);
			
 
				+	vecswap(a, pb - r, r);
			
 
				+	r = min((size_t)(pd - pc), pn - pd - es);
			
 
				+	vecswap(pb, pn - r, r);
			
 
				+	if ((r = pb - pa) > es) {
			
 
				+                void *_l = a, *_r = ((unsigned char*)a)+r-1;
			
 
				+                if (!((lrange < _l && rrange < _l) ||
			
 
				+                    (lrange > _r && rrange > _r)))
			
 
				+		    _pqsort(a, r / es, es, cmp, lrange, rrange);
			
 
				+        }
			
 
				+	if ((r = pd - pc) > es) {
			
 
				+                void *_l, *_r;
			
 
				+
			
 
				+		/* Iterate rather than recurse to save stack space */
			
 
				+		a = pn - r;
			
 
				+		n = r / es;
			
 
				+
			
 
				+                _l = a;
			
 
				+                _r = ((unsigned char*)a)+r-1;
			
 
				+                if (!((lrange < _l && rrange < _l) ||
			
 
				+                    (lrange > _r && rrange > _r)))
			
 
				+		    goto loop;
			
 
				+	}
			
 
				+/*		qsort(pn - r, r / es, es, cmp);*/
			
 
				+}
			
 
				+
			
 
				+void
			
 
				+pqsort(void *a, size_t n, size_t es,
			
 
				+    int (*cmp) (const void *, const void *), size_t lrange, size_t rrange)
			
 
				+{
			
 
				+    _pqsort(a,n,es,cmp,((unsigned char*)a)+(lrange*es),
			
 
				+                       ((unsigned char*)a)+((rrange+1)*es)-1);
			
 
				+}
			
--- a/src/pqsort.h
+++ b/src/pqsort.h
@@ -0,0 +1,40 @@
 
				+/* The following is the NetBSD libc qsort implementation modified in order to
			
 
				+ * support partial sorting of ranges for Redis.
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ *
			
 
				+ * See the pqsort.c file for the original copyright notice. */
			
 
				+
			
 
				+#ifndef __PQSORT_H
			
 
				+#define __PQSORT_H
			
 
				+
			
 
				+void
			
 
				+pqsort(void *a, size_t n, size_t es,
			
 
				+    int (*cmp) (const void *, const void *), size_t lrange, size_t rrange);
			
 
				+
			
 
				+#endif
			
--- a/src/quicklist.c
+++ b/src/quicklist.c
@@ -0,0 +1,3223 @@
 
				+/* quicklist.c - A doubly linked list of listpacks
			
 
				+ *
			
 
				+ * Copyright (c) 2014, Matt Stancliff <matt@genges.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 start the above copyright notice,
			
 
				+ *     this quicklist of conditions and the following disclaimer.
			
 
				+ *   * Redistributions in binary form must reproduce the above copyright
			
 
				+ *     notice, this quicklist 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <string.h> /* for memcpy */
			
 
				+#include "quicklist.h"
			
 
				+#include "zmalloc.h"
			
 
				+#include "config.h"
			
 
				+#include "listpack.h"
			
 
				+#include "util.h" /* for ll2string */
			
 
				+#include "lzf.h"
			
 
				+#include "redisassert.h"
			
 
				+
			
 
				+#ifndef REDIS_STATIC
			
 
				+#define REDIS_STATIC static
			
 
				+#endif
			
 
				+
			
 
				+/* Optimization levels for size-based filling.
			
 
				+ * Note that the largest possible limit is 16k, so even if each record takes
			
 
				+ * just one byte, it still won't overflow the 16 bit count field. */
			
 
				+static const size_t optimization_level[] = {4096, 8192, 16384, 32768, 65536};
			
 
				+
			
 
				+/* packed_threshold is initialized to 1gb*/
			
 
				+static size_t packed_threshold = (1 << 30);
			
 
				+
			
 
				+/* set threshold for PLAIN nodes, the real limit is 4gb */
			
 
				+#define isLargeElement(size) ((size) >= packed_threshold)
			
 
				+
			
 
				+int quicklistisSetPackedThreshold(size_t sz) {
			
 
				+    /* Don't allow threshold to be set above or even slightly below 4GB */
			
 
				+    if (sz > (1ull<<32) - (1<<20)) {
			
 
				+        return 0;
			
 
				+    }
			
 
				+    packed_threshold = sz;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Maximum size in bytes of any multi-element listpack.
			
 
				+ * Larger values will live in their own isolated listpacks.
			
 
				+ * This is used only if we're limited by record count. when we're limited by
			
 
				+ * size, the maximum limit is bigger, but still safe.
			
 
				+ * 8k is a recommended / default size limit */
			
 
				+#define SIZE_SAFETY_LIMIT 8192
			
 
				+
			
 
				+/* Maximum estimate of the listpack entry overhead.
			
 
				+ * Although in the worst case(sz < 64), we will waste 6 bytes in one
			
 
				+ * quicklistNode, but can avoid memory waste due to internal fragmentation
			
 
				+ * when the listpack exceeds the size limit by a few bytes (e.g. being 16388). */
			
 
				+#define SIZE_ESTIMATE_OVERHEAD 8
			
 
				+
			
 
				+/* Minimum listpack size in bytes for attempting compression. */
			
 
				+#define MIN_COMPRESS_BYTES 48
			
 
				+
			
 
				+/* Minimum size reduction in bytes to store compressed quicklistNode data.
			
 
				+ * This also prevents us from storing compression if the compression
			
 
				+ * resulted in a larger size than the original data. */
			
 
				+#define MIN_COMPRESS_IMPROVE 8
			
 
				+
			
 
				+/* If not verbose testing, remove all debug printing. */
			
 
				+#ifndef REDIS_TEST_VERBOSE
			
 
				+#define D(...)
			
 
				+#else
			
 
				+#define D(...)                                                                 \
			
 
				+    do {                                                                       \
			
 
				+        printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__);                   \
			
 
				+        printf(__VA_ARGS__);                                                   \
			
 
				+        printf("\n");                                                          \
			
 
				+    } while (0)
			
 
				+#endif
			
 
				+
			
 
				+/* Bookmarks forward declarations */
			
 
				+#define QL_MAX_BM ((1 << QL_BM_BITS)-1)
			
 
				+quicklistBookmark *_quicklistBookmarkFindByName(quicklist *ql, const char *name);
			
 
				+quicklistBookmark *_quicklistBookmarkFindByNode(quicklist *ql, quicklistNode *node);
			
 
				+void _quicklistBookmarkDelete(quicklist *ql, quicklistBookmark *bm);
			
 
				+
			
 
				+/* Simple way to give quicklistEntry structs default values with one call. */
			
 
				+#define initEntry(e)                                                           \
			
 
				+    do {                                                                       \
			
 
				+        (e)->zi = (e)->value = NULL;                                           \
			
 
				+        (e)->longval = -123456789;                                             \
			
 
				+        (e)->quicklist = NULL;                                                 \
			
 
				+        (e)->node = NULL;                                                      \
			
 
				+        (e)->offset = 123456789;                                               \
			
 
				+        (e)->sz = 0;                                                           \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Reset the quicklistIter to prevent it from being used again after
			
 
				+ * insert, replace, or other against quicklist operation. */
			
 
				+#define resetIterator(iter)                                                    \
			
 
				+    do {                                                                       \
			
 
				+        (iter)->current = NULL;                                                \
			
 
				+        (iter)->zi = NULL;                                                     \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Create a new quicklist.
			
 
				+ * Free with quicklistRelease(). */
			
 
				+quicklist *quicklistCreate(void) {
			
 
				+    struct quicklist *quicklist;
			
 
				+
			
 
				+    quicklist = zmalloc(sizeof(*quicklist));
			
 
				+    quicklist->head = quicklist->tail = NULL;
			
 
				+    quicklist->len = 0;
			
 
				+    quicklist->count = 0;
			
 
				+    quicklist->compress = 0;
			
 
				+    quicklist->fill = -2;
			
 
				+    quicklist->bookmark_count = 0;
			
 
				+    return quicklist;
			
 
				+}
			
 
				+
			
 
				+#define COMPRESS_MAX ((1 << QL_COMP_BITS)-1)
			
 
				+void quicklistSetCompressDepth(quicklist *quicklist, int compress) {
			
 
				+    if (compress > COMPRESS_MAX) {
			
 
				+        compress = COMPRESS_MAX;
			
 
				+    } else if (compress < 0) {
			
 
				+        compress = 0;
			
 
				+    }
			
 
				+    quicklist->compress = compress;
			
 
				+}
			
 
				+
			
 
				+#define FILL_MAX ((1 << (QL_FILL_BITS-1))-1)
			
 
				+void quicklistSetFill(quicklist *quicklist, int fill) {
			
 
				+    if (fill > FILL_MAX) {
			
 
				+        fill = FILL_MAX;
			
 
				+    } else if (fill < -5) {
			
 
				+        fill = -5;
			
 
				+    }
			
 
				+    quicklist->fill = fill;
			
 
				+}
			
 
				+
			
 
				+void quicklistSetOptions(quicklist *quicklist, int fill, int depth) {
			
 
				+    quicklistSetFill(quicklist, fill);
			
 
				+    quicklistSetCompressDepth(quicklist, depth);
			
 
				+}
			
 
				+
			
 
				+/* Create a new quicklist with some default parameters. */
			
 
				+quicklist *quicklistNew(int fill, int compress) {
			
 
				+    quicklist *quicklist = quicklistCreate();
			
 
				+    quicklistSetOptions(quicklist, fill, compress);
			
 
				+    return quicklist;
			
 
				+}
			
 
				+
			
 
				+REDIS_STATIC quicklistNode *quicklistCreateNode(void) {
			
 
				+    quicklistNode *node;
			
 
				+    node = zmalloc(sizeof(*node));
			
 
				+    node->entry = NULL;
			
 
				+    node->count = 0;
			
 
				+    node->sz = 0;
			
 
				+    node->next = node->prev = NULL;
			
 
				+    node->encoding = QUICKLIST_NODE_ENCODING_RAW;
			
 
				+    node->container = QUICKLIST_NODE_CONTAINER_PACKED;
			
 
				+    node->recompress = 0;
			
 
				+    return node;
			
 
				+}
			
 
				+
			
 
				+/* Return cached quicklist count */
			
 
				+unsigned long quicklistCount(const quicklist *ql) { return ql->count; }
			
 
				+
			
 
				+/* Free entire quicklist. */
			
 
				+void quicklistRelease(quicklist *quicklist) {
			
 
				+    unsigned long len;
			
 
				+    quicklistNode *current, *next;
			
 
				+
			
 
				+    current = quicklist->head;
			
 
				+    len = quicklist->len;
			
 
				+    while (len--) {
			
 
				+        next = current->next;
			
 
				+
			
 
				+        zfree(current->entry);
			
 
				+        quicklist->count -= current->count;
			
 
				+
			
 
				+        zfree(current);
			
 
				+
			
 
				+        quicklist->len--;
			
 
				+        current = next;
			
 
				+    }
			
 
				+    quicklistBookmarksClear(quicklist);
			
 
				+    zfree(quicklist);
			
 
				+}
			
 
				+
			
 
				+/* Compress the listpack in 'node' and update encoding details.
			
 
				+ * Returns 1 if listpack compressed successfully.
			
 
				+ * Returns 0 if compression failed or if listpack too small to compress. */
			
 
				+REDIS_STATIC int __quicklistCompressNode(quicklistNode *node) {
			
 
				+#ifdef REDIS_TEST
			
 
				+    node->attempted_compress = 1;
			
 
				+#endif
			
 
				+
			
 
				+    /* validate that the node is neither
			
 
				+     * tail nor head (it has prev and next)*/
			
 
				+    assert(node->prev && node->next);
			
 
				+
			
 
				+    node->recompress = 0;
			
 
				+    /* Don't bother compressing small values */
			
 
				+    if (node->sz < MIN_COMPRESS_BYTES)
			
 
				+        return 0;
			
 
				+
			
 
				+    quicklistLZF *lzf = zmalloc(sizeof(*lzf) + node->sz);
			
 
				+
			
 
				+    /* Cancel if compression fails or doesn't compress small enough */
			
 
				+    if (((lzf->sz = lzf_compress(node->entry, node->sz, lzf->compressed,
			
 
				+                                 node->sz)) == 0) ||
			
 
				+        lzf->sz + MIN_COMPRESS_IMPROVE >= node->sz) {
			
 
				+        /* lzf_compress aborts/rejects compression if value not compressible. */
			
 
				+        zfree(lzf);
			
 
				+        return 0;
			
 
				+    }
			
 
				+    lzf = zrealloc(lzf, sizeof(*lzf) + lzf->sz);
			
 
				+    zfree(node->entry);
			
 
				+    node->entry = (unsigned char *)lzf;
			
 
				+    node->encoding = QUICKLIST_NODE_ENCODING_LZF;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Compress only uncompressed nodes. */
			
 
				+#define quicklistCompressNode(_node)                                           \
			
 
				+    do {                                                                       \
			
 
				+        if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_RAW) {     \
			
 
				+            __quicklistCompressNode((_node));                                  \
			
 
				+        }                                                                      \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Uncompress the listpack in 'node' and update encoding details.
			
 
				+ * Returns 1 on successful decode, 0 on failure to decode. */
			
 
				+REDIS_STATIC int __quicklistDecompressNode(quicklistNode *node) {
			
 
				+#ifdef REDIS_TEST
			
 
				+    node->attempted_compress = 0;
			
 
				+#endif
			
 
				+    node->recompress = 0;
			
 
				+
			
 
				+    void *decompressed = zmalloc(node->sz);
			
 
				+    quicklistLZF *lzf = (quicklistLZF *)node->entry;
			
 
				+    if (lzf_decompress(lzf->compressed, lzf->sz, decompressed, node->sz) == 0) {
			
 
				+        /* Someone requested decompress, but we can't decompress.  Not good. */
			
 
				+        zfree(decompressed);
			
 
				+        return 0;
			
 
				+    }
			
 
				+    zfree(lzf);
			
 
				+    node->entry = decompressed;
			
 
				+    node->encoding = QUICKLIST_NODE_ENCODING_RAW;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Decompress only compressed nodes. */
			
 
				+#define quicklistDecompressNode(_node)                                         \
			
 
				+    do {                                                                       \
			
 
				+        if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) {     \
			
 
				+            __quicklistDecompressNode((_node));                                \
			
 
				+        }                                                                      \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Force node to not be immediately re-compressible */
			
 
				+#define quicklistDecompressNodeForUse(_node)                                   \
			
 
				+    do {                                                                       \
			
 
				+        if ((_node) && (_node)->encoding == QUICKLIST_NODE_ENCODING_LZF) {     \
			
 
				+            __quicklistDecompressNode((_node));                                \
			
 
				+            (_node)->recompress = 1;                                           \
			
 
				+        }                                                                      \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Extract the raw LZF data from this quicklistNode.
			
 
				+ * Pointer to LZF data is assigned to '*data'.
			
 
				+ * Return value is the length of compressed LZF data. */
			
 
				+size_t quicklistGetLzf(const quicklistNode *node, void **data) {
			
 
				+    quicklistLZF *lzf = (quicklistLZF *)node->entry;
			
 
				+    *data = lzf->compressed;
			
 
				+    return lzf->sz;
			
 
				+}
			
 
				+
			
 
				+#define quicklistAllowsCompression(_ql) ((_ql)->compress != 0)
			
 
				+
			
 
				+/* Force 'quicklist' to meet compression guidelines set by compress depth.
			
 
				+ * The only way to guarantee interior nodes get compressed is to iterate
			
 
				+ * to our "interior" compress depth then compress the next node we find.
			
 
				+ * If compress depth is larger than the entire list, we return immediately. */
			
 
				+REDIS_STATIC void __quicklistCompress(const quicklist *quicklist,
			
 
				+                                      quicklistNode *node) {
			
 
				+    if (quicklist->len == 0) return;
			
 
				+
			
 
				+    /* The head and tail should never be compressed (we should not attempt to recompress them) */
			
 
				+    assert(quicklist->head->recompress == 0 && quicklist->tail->recompress == 0);
			
 
				+
			
 
				+    /* If length is less than our compress depth (from both sides),
			
 
				+     * we can't compress anything. */
			
 
				+    if (!quicklistAllowsCompression(quicklist) ||
			
 
				+        quicklist->len < (unsigned int)(quicklist->compress * 2))
			
 
				+        return;
			
 
				+
			
 
				+#if 0
			
 
				+    /* Optimized cases for small depth counts */
			
 
				+    if (quicklist->compress == 1) {
			
 
				+        quicklistNode *h = quicklist->head, *t = quicklist->tail;
			
 
				+        quicklistDecompressNode(h);
			
 
				+        quicklistDecompressNode(t);
			
 
				+        if (h != node && t != node)
			
 
				+            quicklistCompressNode(node);
			
 
				+        return;
			
 
				+    } else if (quicklist->compress == 2) {
			
 
				+        quicklistNode *h = quicklist->head, *hn = h->next, *hnn = hn->next;
			
 
				+        quicklistNode *t = quicklist->tail, *tp = t->prev, *tpp = tp->prev;
			
 
				+        quicklistDecompressNode(h);
			
 
				+        quicklistDecompressNode(hn);
			
 
				+        quicklistDecompressNode(t);
			
 
				+        quicklistDecompressNode(tp);
			
 
				+        if (h != node && hn != node && t != node && tp != node) {
			
 
				+            quicklistCompressNode(node);
			
 
				+        }
			
 
				+        if (hnn != t) {
			
 
				+            quicklistCompressNode(hnn);
			
 
				+        }
			
 
				+        if (tpp != h) {
			
 
				+            quicklistCompressNode(tpp);
			
 
				+        }
			
 
				+        return;
			
 
				+    }
			
 
				+#endif
			
 
				+
			
 
				+    /* Iterate until we reach compress depth for both sides of the list.a
			
 
				+     * Note: because we do length checks at the *top* of this function,
			
 
				+     *       we can skip explicit null checks below. Everything exists. */
			
 
				+    quicklistNode *forward = quicklist->head;
			
 
				+    quicklistNode *reverse = quicklist->tail;
			
 
				+    int depth = 0;
			
 
				+    int in_depth = 0;
			
 
				+    while (depth++ < quicklist->compress) {
			
 
				+        quicklistDecompressNode(forward);
			
 
				+        quicklistDecompressNode(reverse);
			
 
				+
			
 
				+        if (forward == node || reverse == node)
			
 
				+            in_depth = 1;
			
 
				+
			
 
				+        /* We passed into compress depth of opposite side of the quicklist
			
 
				+         * so there's no need to compress anything and we can exit. */
			
 
				+        if (forward == reverse || forward->next == reverse)
			
 
				+            return;
			
 
				+
			
 
				+        forward = forward->next;
			
 
				+        reverse = reverse->prev;
			
 
				+    }
			
 
				+
			
 
				+    if (!in_depth)
			
 
				+        quicklistCompressNode(node);
			
 
				+
			
 
				+    /* At this point, forward and reverse are one node beyond depth */
			
 
				+    quicklistCompressNode(forward);
			
 
				+    quicklistCompressNode(reverse);
			
 
				+}
			
 
				+
			
 
				+#define quicklistCompress(_ql, _node)                                          \
			
 
				+    do {                                                                       \
			
 
				+        if ((_node)->recompress)                                               \
			
 
				+            quicklistCompressNode((_node));                                    \
			
 
				+        else                                                                   \
			
 
				+            __quicklistCompress((_ql), (_node));                               \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* If we previously used quicklistDecompressNodeForUse(), just recompress. */
			
 
				+#define quicklistRecompressOnly(_node)                                         \
			
 
				+    do {                                                                       \
			
 
				+        if ((_node)->recompress)                                               \
			
 
				+            quicklistCompressNode((_node));                                    \
			
 
				+    } while (0)
			
 
				+
			
 
				+/* Insert 'new_node' after 'old_node' if 'after' is 1.
			
 
				+ * Insert 'new_node' before 'old_node' if 'after' is 0.
			
 
				+ * Note: 'new_node' is *always* uncompressed, so if we assign it to
			
 
				+ *       head or tail, we do not need to uncompress it. */
			
 
				+REDIS_STATIC void __quicklistInsertNode(quicklist *quicklist,
			
 
				+                                        quicklistNode *old_node,
			
 
				+                                        quicklistNode *new_node, int after) {
			
 
				+    if (after) {
			
 
				+        new_node->prev = old_node;
			
 
				+        if (old_node) {
			
 
				+            new_node->next = old_node->next;
			
 
				+            if (old_node->next)
			
 
				+                old_node->next->prev = new_node;
			
 
				+            old_node->next = new_node;
			
 
				+        }
			
 
				+        if (quicklist->tail == old_node)
			
 
				+            quicklist->tail = new_node;
			
 
				+    } else {
			
 
				+        new_node->next = old_node;
			
 
				+        if (old_node) {
			
 
				+            new_node->prev = old_node->prev;
			
 
				+            if (old_node->prev)
			
 
				+                old_node->prev->next = new_node;
			
 
				+            old_node->prev = new_node;
			
 
				+        }
			
 
				+        if (quicklist->head == old_node)
			
 
				+            quicklist->head = new_node;
			
 
				+    }
			
 
				+    /* If this insert creates the only element so far, initialize head/tail. */
			
 
				+    if (quicklist->len == 0) {
			
 
				+        quicklist->head = quicklist->tail = new_node;
			
 
				+    }
			
 
				+
			
 
				+    /* Update len first, so in __quicklistCompress we know exactly len */
			
 
				+    quicklist->len++;
			
 
				+
			
 
				+    if (old_node)
			
 
				+        quicklistCompress(quicklist, old_node);
			
 
				+
			
 
				+    quicklistCompress(quicklist, new_node);
			
 
				+}
			
 
				+
			
 
				+/* Wrappers for node inserting around existing node. */
			
 
				+REDIS_STATIC void _quicklistInsertNodeBefore(quicklist *quicklist,
			
 
				+                                             quicklistNode *old_node,
			
 
				+                                             quicklistNode *new_node) {
			
 
				+    __quicklistInsertNode(quicklist, old_node, new_node, 0);
			
 
				+}
			
 
				+
			
 
				+REDIS_STATIC void _quicklistInsertNodeAfter(quicklist *quicklist,
			
 
				+                                            quicklistNode *old_node,
			
 
				+                                            quicklistNode *new_node) {
			
 
				+    __quicklistInsertNode(quicklist, old_node, new_node, 1);
			
 
				+}
			
 
				+
			
 
				+REDIS_STATIC int
			
 
				+_quicklistNodeSizeMeetsOptimizationRequirement(const size_t sz,
			
 
				+                                               const int fill) {
			
 
				+    if (fill >= 0)
			
 
				+        return 0;
			
 
				+
			
 
				+    size_t offset = (-fill) - 1;
			
 
				+    if (offset < (sizeof(optimization_level) / sizeof(*optimization_level))) {
			
 
				+        if (sz <= optimization_level[offset]) {
			
 
				+            return 1;
			
 
				+        } else {
			
 
				+            return 0;
			
 
				+        }
			
 
				+    } else {
			
 
				+        return 0;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+#define sizeMeetsSafetyLimit(sz) ((sz) <= SIZE_SAFETY_LIMIT)
			
 
				+
			
 
				+REDIS_STATIC int _quicklistNodeAllowInsert(const quicklistNode *node,
			
 
				+                                           const int fill, const size_t sz) {
			
 
				+    if (unlikely(!node))
			
 
				+        return 0;
			
 
				+
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(node) || isLargeElement(sz)))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Estimate how many bytes will be added to the listpack by this one entry.
			
 
				+     * We prefer an overestimation, which would at worse lead to a few bytes
			
 
				+     * below the lowest limit of 4k (see optimization_level).
			
 
				+     * Note: No need to check for overflow below since both `node->sz` and
			
 
				+     * `sz` are to be less than 1GB after the plain/large element check above. */
			
 
				+    size_t new_sz = node->sz + sz + SIZE_ESTIMATE_OVERHEAD;
			
 
				+    if (likely(_quicklistNodeSizeMeetsOptimizationRequirement(new_sz, fill)))
			
 
				+        return 1;
			
 
				+    /* when we return 1 above we know that the limit is a size limit (which is
			
 
				+     * safe, see comments next to optimization_level and SIZE_SAFETY_LIMIT) */
			
 
				+    else if (!sizeMeetsSafetyLimit(new_sz))
			
 
				+        return 0;
			
 
				+    else if ((int)node->count < fill)
			
 
				+        return 1;
			
 
				+    else
			
 
				+        return 0;
			
 
				+}
			
 
				+
			
 
				+REDIS_STATIC int _quicklistNodeAllowMerge(const quicklistNode *a,
			
 
				+                                          const quicklistNode *b,
			
 
				+                                          const int fill) {
			
 
				+    if (!a || !b)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(a) || QL_NODE_IS_PLAIN(b)))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* approximate merged listpack size (- 11 to remove one listpack
			
 
				+     * header/trailer) */
			
 
				+    unsigned int merge_sz = a->sz + b->sz - 11;
			
 
				+    if (likely(_quicklistNodeSizeMeetsOptimizationRequirement(merge_sz, fill)))
			
 
				+        return 1;
			
 
				+    /* when we return 1 above we know that the limit is a size limit (which is
			
 
				+     * safe, see comments next to optimization_level and SIZE_SAFETY_LIMIT) */
			
 
				+    else if (!sizeMeetsSafetyLimit(merge_sz))
			
 
				+        return 0;
			
 
				+    else if ((int)(a->count + b->count) <= fill)
			
 
				+        return 1;
			
 
				+    else
			
 
				+        return 0;
			
 
				+}
			
 
				+
			
 
				+#define quicklistNodeUpdateSz(node)                                            \
			
 
				+    do {                                                                       \
			
 
				+        (node)->sz = lpBytes((node)->entry);                                   \
			
 
				+    } while (0)
			
 
				+
			
 
				+static quicklistNode* __quicklistCreatePlainNode(void *value, size_t sz) {
			
 
				+    quicklistNode *new_node = quicklistCreateNode();
			
 
				+    new_node->entry = zmalloc(sz);
			
 
				+    new_node->container = QUICKLIST_NODE_CONTAINER_PLAIN;
			
 
				+    memcpy(new_node->entry, value, sz);
			
 
				+    new_node->sz = sz;
			
 
				+    new_node->count++;
			
 
				+    return new_node;
			
 
				+}
			
 
				+
			
 
				+static void __quicklistInsertPlainNode(quicklist *quicklist, quicklistNode *old_node,
			
 
				+                                       void *value, size_t sz, int after) {
			
 
				+    __quicklistInsertNode(quicklist, old_node, __quicklistCreatePlainNode(value, sz), after);
			
 
				+    quicklist->count++;
			
 
				+}
			
 
				+
			
 
				+/* Add new entry to head node of quicklist.
			
 
				+ *
			
 
				+ * Returns 0 if used existing head.
			
 
				+ * Returns 1 if new head created. */
			
 
				+int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {
			
 
				+    quicklistNode *orig_head = quicklist->head;
			
 
				+
			
 
				+    if (unlikely(isLargeElement(sz))) {
			
 
				+        __quicklistInsertPlainNode(quicklist, quicklist->head, value, sz, 0);
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    if (likely(
			
 
				+            _quicklistNodeAllowInsert(quicklist->head, quicklist->fill, sz))) {
			
 
				+        quicklist->head->entry = lpPrepend(quicklist->head->entry, value, sz);
			
 
				+        quicklistNodeUpdateSz(quicklist->head);
			
 
				+    } else {
			
 
				+        quicklistNode *node = quicklistCreateNode();
			
 
				+        node->entry = lpPrepend(lpNew(0), value, sz);
			
 
				+
			
 
				+        quicklistNodeUpdateSz(node);
			
 
				+        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);
			
 
				+    }
			
 
				+    quicklist->count++;
			
 
				+    quicklist->head->count++;
			
 
				+    return (orig_head != quicklist->head);
			
 
				+}
			
 
				+
			
 
				+/* Add new entry to tail node of quicklist.
			
 
				+ *
			
 
				+ * Returns 0 if used existing tail.
			
 
				+ * Returns 1 if new tail created. */
			
 
				+int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {
			
 
				+    quicklistNode *orig_tail = quicklist->tail;
			
 
				+    if (unlikely(isLargeElement(sz))) {
			
 
				+        __quicklistInsertPlainNode(quicklist, quicklist->tail, value, sz, 1);
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    if (likely(
			
 
				+            _quicklistNodeAllowInsert(quicklist->tail, quicklist->fill, sz))) {
			
 
				+        quicklist->tail->entry = lpAppend(quicklist->tail->entry, value, sz);
			
 
				+        quicklistNodeUpdateSz(quicklist->tail);
			
 
				+    } else {
			
 
				+        quicklistNode *node = quicklistCreateNode();
			
 
				+        node->entry = lpAppend(lpNew(0), value, sz);
			
 
				+
			
 
				+        quicklistNodeUpdateSz(node);
			
 
				+        _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
			
 
				+    }
			
 
				+    quicklist->count++;
			
 
				+    quicklist->tail->count++;
			
 
				+    return (orig_tail != quicklist->tail);
			
 
				+}
			
 
				+
			
 
				+/* Create new node consisting of a pre-formed listpack.
			
 
				+ * Used for loading RDBs where entire listpacks have been stored
			
 
				+ * to be retrieved later. */
			
 
				+void quicklistAppendListpack(quicklist *quicklist, unsigned char *zl) {
			
 
				+    quicklistNode *node = quicklistCreateNode();
			
 
				+
			
 
				+    node->entry = zl;
			
 
				+    node->count = lpLength(node->entry);
			
 
				+    node->sz = lpBytes(zl);
			
 
				+
			
 
				+    _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
			
 
				+    quicklist->count += node->count;
			
 
				+}
			
 
				+
			
 
				+/* Create new node consisting of a pre-formed plain node.
			
 
				+ * Used for loading RDBs where entire plain node has been stored
			
 
				+ * to be retrieved later.
			
 
				+ * data - the data to add (pointer becomes the responsibility of quicklist) */
			
 
				+void quicklistAppendPlainNode(quicklist *quicklist, unsigned char *data, size_t sz) {
			
 
				+    quicklistNode *node = quicklistCreateNode();
			
 
				+
			
 
				+    node->entry = data;
			
 
				+    node->count = 1;
			
 
				+    node->sz = sz;
			
 
				+    node->container = QUICKLIST_NODE_CONTAINER_PLAIN;
			
 
				+
			
 
				+    _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
			
 
				+    quicklist->count += node->count;
			
 
				+}
			
 
				+
			
 
				+#define quicklistDeleteIfEmpty(ql, n)                                          \
			
 
				+    do {                                                                       \
			
 
				+        if ((n)->count == 0) {                                                 \
			
 
				+            __quicklistDelNode((ql), (n));                                     \
			
 
				+            (n) = NULL;                                                        \
			
 
				+        }                                                                      \
			
 
				+    } while (0)
			
 
				+
			
 
				+REDIS_STATIC void __quicklistDelNode(quicklist *quicklist,
			
 
				+                                     quicklistNode *node) {
			
 
				+    /* Update the bookmark if any */
			
 
				+    quicklistBookmark *bm = _quicklistBookmarkFindByNode(quicklist, node);
			
 
				+    if (bm) {
			
 
				+        bm->node = node->next;
			
 
				+        /* if the bookmark was to the last node, delete it. */
			
 
				+        if (!bm->node)
			
 
				+            _quicklistBookmarkDelete(quicklist, bm);
			
 
				+    }
			
 
				+
			
 
				+    if (node->next)
			
 
				+        node->next->prev = node->prev;
			
 
				+    if (node->prev)
			
 
				+        node->prev->next = node->next;
			
 
				+
			
 
				+    if (node == quicklist->tail) {
			
 
				+        quicklist->tail = node->prev;
			
 
				+    }
			
 
				+
			
 
				+    if (node == quicklist->head) {
			
 
				+        quicklist->head = node->next;
			
 
				+    }
			
 
				+
			
 
				+    /* Update len first, so in __quicklistCompress we know exactly len */
			
 
				+    quicklist->len--;
			
 
				+    quicklist->count -= node->count;
			
 
				+
			
 
				+    /* If we deleted a node within our compress depth, we
			
 
				+     * now have compressed nodes needing to be decompressed. */
			
 
				+    __quicklistCompress(quicklist, NULL);
			
 
				+
			
 
				+    zfree(node->entry);
			
 
				+    zfree(node);
			
 
				+}
			
 
				+
			
 
				+/* Delete one entry from list given the node for the entry and a pointer
			
 
				+ * to the entry in the node.
			
 
				+ *
			
 
				+ * Note: quicklistDelIndex() *requires* uncompressed nodes because you
			
 
				+ *       already had to get *p from an uncompressed node somewhere.
			
 
				+ *
			
 
				+ * Returns 1 if the entire node was deleted, 0 if node still exists.
			
 
				+ * Also updates in/out param 'p' with the next offset in the listpack. */
			
 
				+REDIS_STATIC int quicklistDelIndex(quicklist *quicklist, quicklistNode *node,
			
 
				+                                   unsigned char **p) {
			
 
				+    int gone = 0;
			
 
				+
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(node))) {
			
 
				+        __quicklistDelNode(quicklist, node);
			
 
				+        return 1;
			
 
				+    }
			
 
				+    node->entry = lpDelete(node->entry, *p, p);
			
 
				+    node->count--;
			
 
				+    if (node->count == 0) {
			
 
				+        gone = 1;
			
 
				+        __quicklistDelNode(quicklist, node);
			
 
				+    } else {
			
 
				+        quicklistNodeUpdateSz(node);
			
 
				+    }
			
 
				+    quicklist->count--;
			
 
				+    /* If we deleted the node, the original node is no longer valid */
			
 
				+    return gone ? 1 : 0;
			
 
				+}
			
 
				+
			
 
				+/* Delete one element represented by 'entry'
			
 
				+ *
			
 
				+ * 'entry' stores enough metadata to delete the proper position in
			
 
				+ * the correct listpack in the correct quicklist node. */
			
 
				+void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry) {
			
 
				+    quicklistNode *prev = entry->node->prev;
			
 
				+    quicklistNode *next = entry->node->next;
			
 
				+    int deleted_node = quicklistDelIndex((quicklist *)entry->quicklist,
			
 
				+                                         entry->node, &entry->zi);
			
 
				+
			
 
				+    /* after delete, the zi is now invalid for any future usage. */
			
 
				+    iter->zi = NULL;
			
 
				+
			
 
				+    /* If current node is deleted, we must update iterator node and offset. */
			
 
				+    if (deleted_node) {
			
 
				+        if (iter->direction == AL_START_HEAD) {
			
 
				+            iter->current = next;
			
 
				+            iter->offset = 0;
			
 
				+        } else if (iter->direction == AL_START_TAIL) {
			
 
				+            iter->current = prev;
			
 
				+            iter->offset = -1;
			
 
				+        }
			
 
				+    }
			
 
				+    /* else if (!deleted_node), no changes needed.
			
 
				+     * we already reset iter->zi above, and the existing iter->offset
			
 
				+     * doesn't move again because:
			
 
				+     *   - [1, 2, 3] => delete offset 1 => [1, 3]: next element still offset 1
			
 
				+     *   - [1, 2, 3] => delete offset 0 => [2, 3]: next element still offset 0
			
 
				+     *  if we deleted the last element at offset N and now
			
 
				+     *  length of this listpack is N-1, the next call into
			
 
				+     *  quicklistNext() will jump to the next node. */
			
 
				+}
			
 
				+
			
 
				+/* Replace quicklist entry by 'data' with length 'sz'. */
			
 
				+void quicklistReplaceEntry(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                           void *data, size_t sz)
			
 
				+{
			
 
				+    quicklist* quicklist = iter->quicklist;
			
 
				+
			
 
				+    if (likely(!QL_NODE_IS_PLAIN(entry->node) && !isLargeElement(sz))) {
			
 
				+        entry->node->entry = lpReplace(entry->node->entry, &entry->zi, data, sz);
			
 
				+        quicklistNodeUpdateSz(entry->node);
			
 
				+        /* quicklistNext() and quicklistGetIteratorEntryAtIdx() provide an uncompressed node */
			
 
				+        quicklistCompress(quicklist, entry->node);
			
 
				+    } else if (QL_NODE_IS_PLAIN(entry->node)) {
			
 
				+        if (isLargeElement(sz)) {
			
 
				+            zfree(entry->node->entry);
			
 
				+            entry->node->entry = zmalloc(sz);
			
 
				+            entry->node->sz = sz;
			
 
				+            memcpy(entry->node->entry, data, sz);
			
 
				+            quicklistCompress(quicklist, entry->node);
			
 
				+        } else {
			
 
				+            quicklistInsertAfter(iter, entry, data, sz);
			
 
				+            __quicklistDelNode(quicklist, entry->node);
			
 
				+        }
			
 
				+    } else {
			
 
				+        quicklistInsertAfter(iter, entry, data, sz);
			
 
				+        if (entry->node->count == 1) {
			
 
				+            __quicklistDelNode(quicklist, entry->node);
			
 
				+        } else {
			
 
				+            unsigned char *p = lpSeek(entry->node->entry, -1);
			
 
				+            quicklistDelIndex(quicklist, entry->node, &p);
			
 
				+            quicklistCompress(quicklist, entry->node->next);
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    /* In any case, we reset iterator to forbid use of iterator after insert.
			
 
				+     * Notice: iter->current has been compressed above. */
			
 
				+    resetIterator(iter);
			
 
				+}
			
 
				+
			
 
				+/* Replace quicklist entry at offset 'index' by 'data' with length 'sz'.
			
 
				+ *
			
 
				+ * Returns 1 if replace happened.
			
 
				+ * Returns 0 if replace failed and no changes happened. */
			
 
				+int quicklistReplaceAtIndex(quicklist *quicklist, long index, void *data,
			
 
				+                            size_t sz) {
			
 
				+    quicklistEntry entry;
			
 
				+    quicklistIter *iter = quicklistGetIteratorEntryAtIdx(quicklist, index, &entry);
			
 
				+    if (likely(iter)) {
			
 
				+        quicklistReplaceEntry(iter, &entry, data, sz);
			
 
				+        quicklistReleaseIterator(iter);
			
 
				+        return 1;
			
 
				+    } else {
			
 
				+        return 0;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Given two nodes, try to merge their listpacks.
			
 
				+ *
			
 
				+ * This helps us not have a quicklist with 3 element listpacks if
			
 
				+ * our fill factor can handle much higher levels.
			
 
				+ *
			
 
				+ * Note: 'a' must be to the LEFT of 'b'.
			
 
				+ *
			
 
				+ * After calling this function, both 'a' and 'b' should be considered
			
 
				+ * unusable.  The return value from this function must be used
			
 
				+ * instead of re-using any of the quicklistNode input arguments.
			
 
				+ *
			
 
				+ * Returns the input node picked to merge against or NULL if
			
 
				+ * merging was not possible. */
			
 
				+REDIS_STATIC quicklistNode *_quicklistListpackMerge(quicklist *quicklist,
			
 
				+                                                    quicklistNode *a,
			
 
				+                                                    quicklistNode *b) {
			
 
				+    D("Requested merge (a,b) (%u, %u)", a->count, b->count);
			
 
				+
			
 
				+    quicklistDecompressNode(a);
			
 
				+    quicklistDecompressNode(b);
			
 
				+    if ((lpMerge(&a->entry, &b->entry))) {
			
 
				+        /* We merged listpacks! Now remove the unused quicklistNode. */
			
 
				+        quicklistNode *keep = NULL, *nokeep = NULL;
			
 
				+        if (!a->entry) {
			
 
				+            nokeep = a;
			
 
				+            keep = b;
			
 
				+        } else if (!b->entry) {
			
 
				+            nokeep = b;
			
 
				+            keep = a;
			
 
				+        }
			
 
				+        keep->count = lpLength(keep->entry);
			
 
				+        quicklistNodeUpdateSz(keep);
			
 
				+
			
 
				+        nokeep->count = 0;
			
 
				+        __quicklistDelNode(quicklist, nokeep);
			
 
				+        quicklistCompress(quicklist, keep);
			
 
				+        return keep;
			
 
				+    } else {
			
 
				+        /* else, the merge returned NULL and nothing changed. */
			
 
				+        return NULL;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Attempt to merge listpacks within two nodes on either side of 'center'.
			
 
				+ *
			
 
				+ * We attempt to merge:
			
 
				+ *   - (center->prev->prev, center->prev)
			
 
				+ *   - (center->next, center->next->next)
			
 
				+ *   - (center->prev, center)
			
 
				+ *   - (center, center->next)
			
 
				+ */
			
 
				+REDIS_STATIC void _quicklistMergeNodes(quicklist *quicklist,
			
 
				+                                       quicklistNode *center) {
			
 
				+    int fill = quicklist->fill;
			
 
				+    quicklistNode *prev, *prev_prev, *next, *next_next, *target;
			
 
				+    prev = prev_prev = next = next_next = target = NULL;
			
 
				+
			
 
				+    if (center->prev) {
			
 
				+        prev = center->prev;
			
 
				+        if (center->prev->prev)
			
 
				+            prev_prev = center->prev->prev;
			
 
				+    }
			
 
				+
			
 
				+    if (center->next) {
			
 
				+        next = center->next;
			
 
				+        if (center->next->next)
			
 
				+            next_next = center->next->next;
			
 
				+    }
			
 
				+
			
 
				+    /* Try to merge prev_prev and prev */
			
 
				+    if (_quicklistNodeAllowMerge(prev, prev_prev, fill)) {
			
 
				+        _quicklistListpackMerge(quicklist, prev_prev, prev);
			
 
				+        prev_prev = prev = NULL; /* they could have moved, invalidate them. */
			
 
				+    }
			
 
				+
			
 
				+    /* Try to merge next and next_next */
			
 
				+    if (_quicklistNodeAllowMerge(next, next_next, fill)) {
			
 
				+        _quicklistListpackMerge(quicklist, next, next_next);
			
 
				+        next = next_next = NULL; /* they could have moved, invalidate them. */
			
 
				+    }
			
 
				+
			
 
				+    /* Try to merge center node and previous node */
			
 
				+    if (_quicklistNodeAllowMerge(center, center->prev, fill)) {
			
 
				+        target = _quicklistListpackMerge(quicklist, center->prev, center);
			
 
				+        center = NULL; /* center could have been deleted, invalidate it. */
			
 
				+    } else {
			
 
				+        /* else, we didn't merge here, but target needs to be valid below. */
			
 
				+        target = center;
			
 
				+    }
			
 
				+
			
 
				+    /* Use result of center merge (or original) to merge with next node. */
			
 
				+    if (_quicklistNodeAllowMerge(target, target->next, fill)) {
			
 
				+        _quicklistListpackMerge(quicklist, target, target->next);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Split 'node' into two parts, parameterized by 'offset' and 'after'.
			
 
				+ *
			
 
				+ * The 'after' argument controls which quicklistNode gets returned.
			
 
				+ * If 'after'==1, returned node has elements after 'offset'.
			
 
				+ *                input node keeps elements up to 'offset', including 'offset'.
			
 
				+ * If 'after'==0, returned node has elements up to 'offset'.
			
 
				+ *                input node keeps elements after 'offset', including 'offset'.
			
 
				+ *
			
 
				+ * Or in other words:
			
 
				+ * If 'after'==1, returned node will have elements after 'offset'.
			
 
				+ *                The returned node will have elements [OFFSET+1, END].
			
 
				+ *                The input node keeps elements [0, OFFSET].
			
 
				+ * If 'after'==0, returned node will keep elements up to but not including 'offset'.
			
 
				+ *                The returned node will have elements [0, OFFSET-1].
			
 
				+ *                The input node keeps elements [OFFSET, END].
			
 
				+ *
			
 
				+ * The input node keeps all elements not taken by the returned node.
			
 
				+ *
			
 
				+ * Returns newly created node or NULL if split not possible. */
			
 
				+REDIS_STATIC quicklistNode *_quicklistSplitNode(quicklistNode *node, int offset,
			
 
				+                                                int after) {
			
 
				+    size_t zl_sz = node->sz;
			
 
				+
			
 
				+    quicklistNode *new_node = quicklistCreateNode();
			
 
				+    new_node->entry = zmalloc(zl_sz);
			
 
				+
			
 
				+    /* Copy original listpack so we can split it */
			
 
				+    memcpy(new_node->entry, node->entry, zl_sz);
			
 
				+
			
 
				+    /* Ranges to be trimmed: -1 here means "continue deleting until the list ends" */
			
 
				+    int orig_start = after ? offset + 1 : 0;
			
 
				+    int orig_extent = after ? -1 : offset;
			
 
				+    int new_start = after ? 0 : offset;
			
 
				+    int new_extent = after ? offset + 1 : -1;
			
 
				+
			
 
				+    D("After %d (%d); ranges: [%d, %d], [%d, %d]", after, offset, orig_start,
			
 
				+      orig_extent, new_start, new_extent);
			
 
				+
			
 
				+    node->entry = lpDeleteRange(node->entry, orig_start, orig_extent);
			
 
				+    node->count = lpLength(node->entry);
			
 
				+    quicklistNodeUpdateSz(node);
			
 
				+
			
 
				+    new_node->entry = lpDeleteRange(new_node->entry, new_start, new_extent);
			
 
				+    new_node->count = lpLength(new_node->entry);
			
 
				+    quicklistNodeUpdateSz(new_node);
			
 
				+
			
 
				+    D("After split lengths: orig (%d), new (%d)", node->count, new_node->count);
			
 
				+    return new_node;
			
 
				+}
			
 
				+
			
 
				+/* Insert a new entry before or after existing entry 'entry'.
			
 
				+ *
			
 
				+ * If after==1, the new value is inserted after 'entry', otherwise
			
 
				+ * the new value is inserted before 'entry'. */
			
 
				+REDIS_STATIC void _quicklistInsert(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                                   void *value, const size_t sz, int after)
			
 
				+{
			
 
				+    quicklist *quicklist = iter->quicklist;
			
 
				+    int full = 0, at_tail = 0, at_head = 0, avail_next = 0, avail_prev = 0;
			
 
				+    int fill = quicklist->fill;
			
 
				+    quicklistNode *node = entry->node;
			
 
				+    quicklistNode *new_node = NULL;
			
 
				+
			
 
				+    if (!node) {
			
 
				+        /* we have no reference node, so let's create only node in the list */
			
 
				+        D("No node given!");
			
 
				+        if (unlikely(isLargeElement(sz))) {
			
 
				+            __quicklistInsertPlainNode(quicklist, quicklist->tail, value, sz, after);
			
 
				+            return;
			
 
				+        }
			
 
				+        new_node = quicklistCreateNode();
			
 
				+        new_node->entry = lpPrepend(lpNew(0), value, sz);
			
 
				+        __quicklistInsertNode(quicklist, NULL, new_node, after);
			
 
				+        new_node->count++;
			
 
				+        quicklist->count++;
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    /* Populate accounting flags for easier boolean checks later */
			
 
				+    if (!_quicklistNodeAllowInsert(node, fill, sz)) {
			
 
				+        D("Current node is full with count %d with requested fill %d",
			
 
				+          node->count, fill);
			
 
				+        full = 1;
			
 
				+    }
			
 
				+
			
 
				+    if (after && (entry->offset == node->count - 1 || entry->offset == -1)) {
			
 
				+        D("At Tail of current listpack");
			
 
				+        at_tail = 1;
			
 
				+        if (_quicklistNodeAllowInsert(node->next, fill, sz)) {
			
 
				+            D("Next node is available.");
			
 
				+            avail_next = 1;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    if (!after && (entry->offset == 0 || entry->offset == -(node->count))) {
			
 
				+        D("At Head");
			
 
				+        at_head = 1;
			
 
				+        if (_quicklistNodeAllowInsert(node->prev, fill, sz)) {
			
 
				+            D("Prev node is available.");
			
 
				+            avail_prev = 1;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    if (unlikely(isLargeElement(sz))) {
			
 
				+        if (QL_NODE_IS_PLAIN(node) || (at_tail && after) || (at_head && !after)) {
			
 
				+            __quicklistInsertPlainNode(quicklist, node, value, sz, after);
			
 
				+        } else {
			
 
				+            quicklistDecompressNodeForUse(node);
			
 
				+            new_node = _quicklistSplitNode(node, entry->offset, after);
			
 
				+            quicklistNode *entry_node = __quicklistCreatePlainNode(value, sz);
			
 
				+            __quicklistInsertNode(quicklist, node, entry_node, after);
			
 
				+            __quicklistInsertNode(quicklist, entry_node, new_node, after);
			
 
				+            quicklist->count++;
			
 
				+        }
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    /* Now determine where and how to insert the new element */
			
 
				+    if (!full && after) {
			
 
				+        D("Not full, inserting after current position.");
			
 
				+        quicklistDecompressNodeForUse(node);
			
 
				+        node->entry = lpInsertString(node->entry, value, sz, entry->zi, LP_AFTER, NULL);
			
 
				+        node->count++;
			
 
				+        quicklistNodeUpdateSz(node);
			
 
				+        quicklistRecompressOnly(node);
			
 
				+    } else if (!full && !after) {
			
 
				+        D("Not full, inserting before current position.");
			
 
				+        quicklistDecompressNodeForUse(node);
			
 
				+        node->entry = lpInsertString(node->entry, value, sz, entry->zi, LP_BEFORE, NULL);
			
 
				+        node->count++;
			
 
				+        quicklistNodeUpdateSz(node);
			
 
				+        quicklistRecompressOnly(node);
			
 
				+    } else if (full && at_tail && avail_next && after) {
			
 
				+        /* If we are: at tail, next has free space, and inserting after:
			
 
				+         *   - insert entry at head of next node. */
			
 
				+        D("Full and tail, but next isn't full; inserting next node head");
			
 
				+        new_node = node->next;
			
 
				+        quicklistDecompressNodeForUse(new_node);
			
 
				+        new_node->entry = lpPrepend(new_node->entry, value, sz);
			
 
				+        new_node->count++;
			
 
				+        quicklistNodeUpdateSz(new_node);
			
 
				+        quicklistRecompressOnly(new_node);
			
 
				+    } else if (full && at_head && avail_prev && !after) {
			
 
				+        /* If we are: at head, previous has free space, and inserting before:
			
 
				+         *   - insert entry at tail of previous node. */
			
 
				+        D("Full and head, but prev isn't full, inserting prev node tail");
			
 
				+        new_node = node->prev;
			
 
				+        quicklistDecompressNodeForUse(new_node);
			
 
				+        new_node->entry = lpAppend(new_node->entry, value, sz);
			
 
				+        new_node->count++;
			
 
				+        quicklistNodeUpdateSz(new_node);
			
 
				+        quicklistRecompressOnly(new_node);
			
 
				+    } else if (full && ((at_tail && !avail_next && after) ||
			
 
				+                        (at_head && !avail_prev && !after))) {
			
 
				+        /* If we are: full, and our prev/next has no available space, then:
			
 
				+         *   - create new node and attach to quicklist */
			
 
				+        D("\tprovisioning new node...");
			
 
				+        new_node = quicklistCreateNode();
			
 
				+        new_node->entry = lpPrepend(lpNew(0), value, sz);
			
 
				+        new_node->count++;
			
 
				+        quicklistNodeUpdateSz(new_node);
			
 
				+        __quicklistInsertNode(quicklist, node, new_node, after);
			
 
				+    } else if (full) {
			
 
				+        /* else, node is full we need to split it. */
			
 
				+        /* covers both after and !after cases */
			
 
				+        D("\tsplitting node...");
			
 
				+        quicklistDecompressNodeForUse(node);
			
 
				+        new_node = _quicklistSplitNode(node, entry->offset, after);
			
 
				+        if (after)
			
 
				+            new_node->entry = lpPrepend(new_node->entry, value, sz);
			
 
				+        else
			
 
				+            new_node->entry = lpAppend(new_node->entry, value, sz);
			
 
				+        new_node->count++;
			
 
				+        quicklistNodeUpdateSz(new_node);
			
 
				+        __quicklistInsertNode(quicklist, node, new_node, after);
			
 
				+        _quicklistMergeNodes(quicklist, node);
			
 
				+    }
			
 
				+
			
 
				+    quicklist->count++;
			
 
				+
			
 
				+    /* In any case, we reset iterator to forbid use of iterator after insert.
			
 
				+     * Notice: iter->current has been compressed in _quicklistInsert(). */
			
 
				+    resetIterator(iter); 
			
 
				+}
			
 
				+
			
 
				+void quicklistInsertBefore(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                           void *value, const size_t sz)
			
 
				+{
			
 
				+    _quicklistInsert(iter, entry, value, sz, 0);
			
 
				+}
			
 
				+
			
 
				+void quicklistInsertAfter(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                          void *value, const size_t sz)
			
 
				+{
			
 
				+    _quicklistInsert(iter, entry, value, sz, 1);
			
 
				+}
			
 
				+
			
 
				+/* Delete a range of elements from the quicklist.
			
 
				+ *
			
 
				+ * elements may span across multiple quicklistNodes, so we
			
 
				+ * have to be careful about tracking where we start and end.
			
 
				+ *
			
 
				+ * Returns 1 if entries were deleted, 0 if nothing was deleted. */
			
 
				+int quicklistDelRange(quicklist *quicklist, const long start,
			
 
				+                      const long count) {
			
 
				+    if (count <= 0)
			
 
				+        return 0;
			
 
				+
			
 
				+    unsigned long extent = count; /* range is inclusive of start position */
			
 
				+
			
 
				+    if (start >= 0 && extent > (quicklist->count - start)) {
			
 
				+        /* if requesting delete more elements than exist, limit to list size. */
			
 
				+        extent = quicklist->count - start;
			
 
				+    } else if (start < 0 && extent > (unsigned long)(-start)) {
			
 
				+        /* else, if at negative offset, limit max size to rest of list. */
			
 
				+        extent = -start; /* c.f. LREM -29 29; just delete until end. */
			
 
				+    }
			
 
				+
			
 
				+    quicklistIter *iter = quicklistGetIteratorAtIdx(quicklist, AL_START_TAIL, start);
			
 
				+    if (!iter)
			
 
				+        return 0;
			
 
				+
			
 
				+    D("Quicklist delete request for start %ld, count %ld, extent: %ld", start,
			
 
				+      count, extent);
			
 
				+    quicklistNode *node = iter->current;
			
 
				+    long offset = iter->offset;
			
 
				+    quicklistReleaseIterator(iter);
			
 
				+
			
 
				+    /* iterate over next nodes until everything is deleted. */
			
 
				+    while (extent) {
			
 
				+        quicklistNode *next = node->next;
			
 
				+
			
 
				+        unsigned long del;
			
 
				+        int delete_entire_node = 0;
			
 
				+        if (offset == 0 && extent >= node->count) {
			
 
				+            /* If we are deleting more than the count of this node, we
			
 
				+             * can just delete the entire node without listpack math. */
			
 
				+            delete_entire_node = 1;
			
 
				+            del = node->count;
			
 
				+        } else if (offset >= 0 && extent + offset >= node->count) {
			
 
				+            /* If deleting more nodes after this one, calculate delete based
			
 
				+             * on size of current node. */
			
 
				+            del = node->count - offset;
			
 
				+        } else if (offset < 0) {
			
 
				+            /* If offset is negative, we are in the first run of this loop
			
 
				+             * and we are deleting the entire range
			
 
				+             * from this start offset to end of list.  Since the Negative
			
 
				+             * offset is the number of elements until the tail of the list,
			
 
				+             * just use it directly as the deletion count. */
			
 
				+            del = -offset;
			
 
				+
			
 
				+            /* If the positive offset is greater than the remaining extent,
			
 
				+             * we only delete the remaining extent, not the entire offset.
			
 
				+             */
			
 
				+            if (del > extent)
			
 
				+                del = extent;
			
 
				+        } else {
			
 
				+            /* else, we are deleting less than the extent of this node, so
			
 
				+             * use extent directly. */
			
 
				+            del = extent;
			
 
				+        }
			
 
				+
			
 
				+        D("[%ld]: asking to del: %ld because offset: %d; (ENTIRE NODE: %d), "
			
 
				+          "node count: %u",
			
 
				+          extent, del, offset, delete_entire_node, node->count);
			
 
				+
			
 
				+        if (delete_entire_node || QL_NODE_IS_PLAIN(node)) {
			
 
				+            __quicklistDelNode(quicklist, node);
			
 
				+        } else {
			
 
				+            quicklistDecompressNodeForUse(node);
			
 
				+            node->entry = lpDeleteRange(node->entry, offset, del);
			
 
				+            quicklistNodeUpdateSz(node);
			
 
				+            node->count -= del;
			
 
				+            quicklist->count -= del;
			
 
				+            quicklistDeleteIfEmpty(quicklist, node);
			
 
				+            if (node)
			
 
				+                quicklistRecompressOnly(node);
			
 
				+        }
			
 
				+
			
 
				+        extent -= del;
			
 
				+
			
 
				+        node = next;
			
 
				+
			
 
				+        offset = 0;
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* compare between a two entries */
			
 
				+int quicklistCompare(quicklistEntry* entry, unsigned char *p2, const size_t p2_len) {
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(entry->node))) {
			
 
				+        return ((entry->sz == p2_len) && (memcmp(entry->value, p2, p2_len) == 0));
			
 
				+    }
			
 
				+    return lpCompare(entry->zi, p2, p2_len);
			
 
				+}
			
 
				+
			
 
				+/* Returns a quicklist iterator 'iter'. After the initialization every
			
 
				+ * call to quicklistNext() will return the next element of the quicklist. */
			
 
				+quicklistIter *quicklistGetIterator(quicklist *quicklist, int direction) {
			
 
				+    quicklistIter *iter;
			
 
				+
			
 
				+    iter = zmalloc(sizeof(*iter));
			
 
				+
			
 
				+    if (direction == AL_START_HEAD) {
			
 
				+        iter->current = quicklist->head;
			
 
				+        iter->offset = 0;
			
 
				+    } else if (direction == AL_START_TAIL) {
			
 
				+        iter->current = quicklist->tail;
			
 
				+        iter->offset = -1;
			
 
				+    }
			
 
				+
			
 
				+    iter->direction = direction;
			
 
				+    iter->quicklist = quicklist;
			
 
				+
			
 
				+    iter->zi = NULL;
			
 
				+
			
 
				+    return iter;
			
 
				+}
			
 
				+
			
 
				+/* Initialize an iterator at a specific offset 'idx' and make the iterator
			
 
				+ * return nodes in 'direction' direction. */
			
 
				+quicklistIter *quicklistGetIteratorAtIdx(quicklist *quicklist,
			
 
				+                                         const int direction,
			
 
				+                                         const long long idx)
			
 
				+{
			
 
				+    quicklistNode *n;
			
 
				+    unsigned long long accum = 0;
			
 
				+    unsigned long long index;
			
 
				+    int forward = idx < 0 ? 0 : 1; /* < 0 -> reverse, 0+ -> forward */
			
 
				+
			
 
				+    index = forward ? idx : (-idx) - 1;
			
 
				+    if (index >= quicklist->count)
			
 
				+        return NULL;
			
 
				+
			
 
				+    /* Seek in the other direction if that way is shorter. */
			
 
				+    int seek_forward = forward;
			
 
				+    unsigned long long seek_index = index;
			
 
				+    if (index > (quicklist->count - 1) / 2) {
			
 
				+        seek_forward = !forward;
			
 
				+        seek_index = quicklist->count - 1 - index;
			
 
				+    }
			
 
				+
			
 
				+    n = seek_forward ? quicklist->head : quicklist->tail;
			
 
				+    while (likely(n)) {
			
 
				+        if ((accum + n->count) > seek_index) {
			
 
				+            break;
			
 
				+        } else {
			
 
				+            D("Skipping over (%p) %u at accum %lld", (void *)n, n->count,
			
 
				+              accum);
			
 
				+            accum += n->count;
			
 
				+            n = seek_forward ? n->next : n->prev;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    if (!n)
			
 
				+        return NULL;
			
 
				+
			
 
				+    /* Fix accum so it looks like we seeked in the other direction. */
			
 
				+    if (seek_forward != forward) accum = quicklist->count - n->count - accum;
			
 
				+
			
 
				+    D("Found node: %p at accum %llu, idx %llu, sub+ %llu, sub- %llu", (void *)n,
			
 
				+      accum, index, index - accum, (-index) - 1 + accum);
			
 
				+
			
 
				+    quicklistIter *iter = quicklistGetIterator(quicklist, direction);
			
 
				+    iter->current = n;
			
 
				+    if (forward) {
			
 
				+        /* forward = normal head-to-tail offset. */
			
 
				+        iter->offset = index - accum;
			
 
				+    } else {
			
 
				+        /* reverse = need negative offset for tail-to-head, so undo
			
 
				+         * the result of the original index = (-idx) - 1 above. */
			
 
				+        iter->offset = (-index) - 1 + accum;
			
 
				+    }
			
 
				+
			
 
				+    return iter;
			
 
				+}
			
 
				+
			
 
				+/* Release iterator.
			
 
				+ * If we still have a valid current node, then re-encode current node. */
			
 
				+void quicklistReleaseIterator(quicklistIter *iter) {
			
 
				+    if (!iter) return;
			
 
				+    if (iter->current)
			
 
				+        quicklistCompress(iter->quicklist, iter->current);
			
 
				+
			
 
				+    zfree(iter);
			
 
				+}
			
 
				+
			
 
				+/* Get next element in iterator.
			
 
				+ *
			
 
				+ * Note: You must NOT insert into the list while iterating over it.
			
 
				+ * You *may* delete from the list while iterating using the
			
 
				+ * quicklistDelEntry() function.
			
 
				+ * If you insert into the quicklist while iterating, you should
			
 
				+ * re-create the iterator after your addition.
			
 
				+ *
			
 
				+ * iter = quicklistGetIterator(quicklist,<direction>);
			
 
				+ * quicklistEntry entry;
			
 
				+ * while (quicklistNext(iter, &entry)) {
			
 
				+ *     if (entry.value)
			
 
				+ *          [[ use entry.value with entry.sz ]]
			
 
				+ *     else
			
 
				+ *          [[ use entry.longval ]]
			
 
				+ * }
			
 
				+ *
			
 
				+ * Populates 'entry' with values for this iteration.
			
 
				+ * Returns 0 when iteration is complete or if iteration not possible.
			
 
				+ * If return value is 0, the contents of 'entry' are not valid.
			
 
				+ */
			
 
				+int quicklistNext(quicklistIter *iter, quicklistEntry *entry) {
			
 
				+    initEntry(entry);
			
 
				+
			
 
				+    if (!iter) {
			
 
				+        D("Returning because no iter!");
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    entry->quicklist = iter->quicklist;
			
 
				+    entry->node = iter->current;
			
 
				+
			
 
				+    if (!iter->current) {
			
 
				+        D("Returning because current node is NULL");
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    unsigned char *(*nextFn)(unsigned char *, unsigned char *) = NULL;
			
 
				+    int offset_update = 0;
			
 
				+
			
 
				+    int plain = QL_NODE_IS_PLAIN(iter->current);
			
 
				+    if (!iter->zi) {
			
 
				+        /* If !zi, use current index. */
			
 
				+        quicklistDecompressNodeForUse(iter->current);
			
 
				+        if (unlikely(plain))
			
 
				+            iter->zi = iter->current->entry;
			
 
				+        else
			
 
				+            iter->zi = lpSeek(iter->current->entry, iter->offset);
			
 
				+    } else if (unlikely(plain)) {
			
 
				+        iter->zi = NULL;
			
 
				+    } else {
			
 
				+        /* else, use existing iterator offset and get prev/next as necessary. */
			
 
				+        if (iter->direction == AL_START_HEAD) {
			
 
				+            nextFn = lpNext;
			
 
				+            offset_update = 1;
			
 
				+        } else if (iter->direction == AL_START_TAIL) {
			
 
				+            nextFn = lpPrev;
			
 
				+            offset_update = -1;
			
 
				+        }
			
 
				+        iter->zi = nextFn(iter->current->entry, iter->zi);
			
 
				+        iter->offset += offset_update;
			
 
				+    }
			
 
				+
			
 
				+    entry->zi = iter->zi;
			
 
				+    entry->offset = iter->offset;
			
 
				+
			
 
				+    if (iter->zi) {
			
 
				+        if (unlikely(plain)) {
			
 
				+            entry->value = entry->node->entry;
			
 
				+            entry->sz = entry->node->sz;
			
 
				+            return 1;
			
 
				+        }
			
 
				+        /* Populate value from existing listpack position */
			
 
				+        unsigned int sz = 0;
			
 
				+        entry->value = lpGetValue(entry->zi, &sz, &entry->longval);
			
 
				+        entry->sz = sz;
			
 
				+        return 1;
			
 
				+    } else {
			
 
				+        /* We ran out of listpack entries.
			
 
				+         * Pick next node, update offset, then re-run retrieval. */
			
 
				+        quicklistCompress(iter->quicklist, iter->current);
			
 
				+        if (iter->direction == AL_START_HEAD) {
			
 
				+            /* Forward traversal */
			
 
				+            D("Jumping to start of next node");
			
 
				+            iter->current = iter->current->next;
			
 
				+            iter->offset = 0;
			
 
				+        } else if (iter->direction == AL_START_TAIL) {
			
 
				+            /* Reverse traversal */
			
 
				+            D("Jumping to end of previous node");
			
 
				+            iter->current = iter->current->prev;
			
 
				+            iter->offset = -1;
			
 
				+        }
			
 
				+        iter->zi = NULL;
			
 
				+        return quicklistNext(iter, entry);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Sets the direction of a quicklist iterator. */
			
 
				+void quicklistSetDirection(quicklistIter *iter, int direction) {
			
 
				+    iter->direction = direction;
			
 
				+}
			
 
				+
			
 
				+/* Duplicate the quicklist.
			
 
				+ * On success a copy of the original quicklist is returned.
			
 
				+ *
			
 
				+ * The original quicklist both on success or error is never modified.
			
 
				+ *
			
 
				+ * Returns newly allocated quicklist. */
			
 
				+quicklist *quicklistDup(quicklist *orig) {
			
 
				+    quicklist *copy;
			
 
				+
			
 
				+    copy = quicklistNew(orig->fill, orig->compress);
			
 
				+
			
 
				+    for (quicklistNode *current = orig->head; current;
			
 
				+         current = current->next) {
			
 
				+        quicklistNode *node = quicklistCreateNode();
			
 
				+
			
 
				+        if (current->encoding == QUICKLIST_NODE_ENCODING_LZF) {
			
 
				+            quicklistLZF *lzf = (quicklistLZF *)current->entry;
			
 
				+            size_t lzf_sz = sizeof(*lzf) + lzf->sz;
			
 
				+            node->entry = zmalloc(lzf_sz);
			
 
				+            memcpy(node->entry, current->entry, lzf_sz);
			
 
				+        } else if (current->encoding == QUICKLIST_NODE_ENCODING_RAW) {
			
 
				+            node->entry = zmalloc(current->sz);
			
 
				+            memcpy(node->entry, current->entry, current->sz);
			
 
				+        }
			
 
				+
			
 
				+        node->count = current->count;
			
 
				+        copy->count += node->count;
			
 
				+        node->sz = current->sz;
			
 
				+        node->encoding = current->encoding;
			
 
				+        node->container = current->container;
			
 
				+
			
 
				+        _quicklistInsertNodeAfter(copy, copy->tail, node);
			
 
				+    }
			
 
				+
			
 
				+    /* copy->count must equal orig->count here */
			
 
				+    return copy;
			
 
				+}
			
 
				+
			
 
				+/* Populate 'entry' with the element at the specified zero-based index
			
 
				+ * where 0 is the head, 1 is the element next to head
			
 
				+ * and so on. Negative integers are used in order to count
			
 
				+ * from the tail, -1 is the last element, -2 the penultimate
			
 
				+ * and so on. If the index is out of range 0 is returned.
			
 
				+ *
			
 
				+ * Returns an iterator at a specific offset 'idx' if element found
			
 
				+ * Returns NULL if element not found */
			
 
				+quicklistIter *quicklistGetIteratorEntryAtIdx(quicklist *quicklist, const long long idx,
			
 
				+                                              quicklistEntry *entry)
			
 
				+{
			
 
				+    quicklistIter *iter = quicklistGetIteratorAtIdx(quicklist, AL_START_TAIL, idx);
			
 
				+    if (!iter) return NULL;
			
 
				+    assert(quicklistNext(iter, entry));
			
 
				+    return iter;
			
 
				+}
			
 
				+
			
 
				+static void quicklistRotatePlain(quicklist *quicklist) {
			
 
				+    quicklistNode *new_head = quicklist->tail;
			
 
				+    quicklistNode *new_tail = quicklist->tail->prev;
			
 
				+    quicklist->head->prev = new_head;
			
 
				+    new_tail->next = NULL;
			
 
				+    new_head->next = quicklist->head;
			
 
				+    new_head->prev = NULL;
			
 
				+    quicklist->head = new_head;
			
 
				+    quicklist->tail = new_tail;
			
 
				+}
			
 
				+
			
 
				+/* Rotate quicklist by moving the tail element to the head. */
			
 
				+void quicklistRotate(quicklist *quicklist) {
			
 
				+    if (quicklist->count <= 1)
			
 
				+        return;
			
 
				+
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(quicklist->tail))) {
			
 
				+        quicklistRotatePlain(quicklist);
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    /* First, get the tail entry */
			
 
				+    unsigned char *p = lpSeek(quicklist->tail->entry, -1);
			
 
				+    unsigned char *value, *tmp;
			
 
				+    long long longval;
			
 
				+    unsigned int sz;
			
 
				+    char longstr[32] = {0};
			
 
				+    tmp = lpGetValue(p, &sz, &longval);
			
 
				+
			
 
				+    /* If value found is NULL, then lpGet populated longval instead */
			
 
				+    if (!tmp) {
			
 
				+        /* Write the longval as a string so we can re-add it */
			
 
				+        sz = ll2string(longstr, sizeof(longstr), longval);
			
 
				+        value = (unsigned char *)longstr;
			
 
				+    } else if (quicklist->len == 1) {
			
 
				+        /* Copy buffer since there could be a memory overlap when move
			
 
				+         * entity from tail to head in the same listpack. */
			
 
				+        value = zmalloc(sz);
			
 
				+        memcpy(value, tmp, sz);
			
 
				+    } else {
			
 
				+        value = tmp;
			
 
				+    }
			
 
				+
			
 
				+    /* Add tail entry to head (must happen before tail is deleted). */
			
 
				+    quicklistPushHead(quicklist, value, sz);
			
 
				+
			
 
				+    /* If quicklist has only one node, the head listpack is also the
			
 
				+     * tail listpack and PushHead() could have reallocated our single listpack,
			
 
				+     * which would make our pre-existing 'p' unusable. */
			
 
				+    if (quicklist->len == 1) {
			
 
				+        p = lpSeek(quicklist->tail->entry, -1);
			
 
				+    }
			
 
				+
			
 
				+    /* Remove tail entry. */
			
 
				+    quicklistDelIndex(quicklist, quicklist->tail, &p);
			
 
				+    if (value != (unsigned char*)longstr && value != tmp)
			
 
				+        zfree(value);
			
 
				+}
			
 
				+
			
 
				+/* pop from quicklist and return result in 'data' ptr.  Value of 'data'
			
 
				+ * is the return value of 'saver' function pointer if the data is NOT a number.
			
 
				+ *
			
 
				+ * If the quicklist element is a long long, then the return value is returned in
			
 
				+ * 'sval'.
			
 
				+ *
			
 
				+ * Return value of 0 means no elements available.
			
 
				+ * Return value of 1 means check 'data' and 'sval' for values.
			
 
				+ * If 'data' is set, use 'data' and 'sz'.  Otherwise, use 'sval'. */
			
 
				+int quicklistPopCustom(quicklist *quicklist, int where, unsigned char **data,
			
 
				+                       size_t *sz, long long *sval,
			
 
				+                       void *(*saver)(unsigned char *data, size_t sz)) {
			
 
				+    unsigned char *p;
			
 
				+    unsigned char *vstr;
			
 
				+    unsigned int vlen;
			
 
				+    long long vlong;
			
 
				+    int pos = (where == QUICKLIST_HEAD) ? 0 : -1;
			
 
				+
			
 
				+    if (quicklist->count == 0)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (data)
			
 
				+        *data = NULL;
			
 
				+    if (sz)
			
 
				+        *sz = 0;
			
 
				+    if (sval)
			
 
				+        *sval = -123456789;
			
 
				+
			
 
				+    quicklistNode *node;
			
 
				+    if (where == QUICKLIST_HEAD && quicklist->head) {
			
 
				+        node = quicklist->head;
			
 
				+    } else if (where == QUICKLIST_TAIL && quicklist->tail) {
			
 
				+        node = quicklist->tail;
			
 
				+    } else {
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    /* The head and tail should never be compressed */
			
 
				+    assert(node->encoding != QUICKLIST_NODE_ENCODING_LZF);
			
 
				+
			
 
				+    if (unlikely(QL_NODE_IS_PLAIN(node))) {
			
 
				+        if (data)
			
 
				+            *data = saver(node->entry, node->sz);
			
 
				+        if (sz)
			
 
				+            *sz = node->sz;
			
 
				+        quicklistDelIndex(quicklist, node, NULL);
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    p = lpSeek(node->entry, pos);
			
 
				+    vstr = lpGetValue(p, &vlen, &vlong);
			
 
				+    if (vstr) {
			
 
				+        if (data)
			
 
				+            *data = saver(vstr, vlen);
			
 
				+        if (sz)
			
 
				+            *sz = vlen;
			
 
				+    } else {
			
 
				+        if (data)
			
 
				+            *data = NULL;
			
 
				+        if (sval)
			
 
				+            *sval = vlong;
			
 
				+    }
			
 
				+    quicklistDelIndex(quicklist, node, &p);
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Return a malloc'd copy of data passed in */
			
 
				+REDIS_STATIC void *_quicklistSaver(unsigned char *data, size_t sz) {
			
 
				+    unsigned char *vstr;
			
 
				+    if (data) {
			
 
				+        vstr = zmalloc(sz);
			
 
				+        memcpy(vstr, data, sz);
			
 
				+        return vstr;
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* Default pop function
			
 
				+ *
			
 
				+ * Returns malloc'd value from quicklist */
			
 
				+int quicklistPop(quicklist *quicklist, int where, unsigned char **data,
			
 
				+                 size_t *sz, long long *slong) {
			
 
				+    unsigned char *vstr;
			
 
				+    size_t vlen;
			
 
				+    long long vlong;
			
 
				+    if (quicklist->count == 0)
			
 
				+        return 0;
			
 
				+    int ret = quicklistPopCustom(quicklist, where, &vstr, &vlen, &vlong,
			
 
				+                                 _quicklistSaver);
			
 
				+    if (data)
			
 
				+        *data = vstr;
			
 
				+    if (slong)
			
 
				+        *slong = vlong;
			
 
				+    if (sz)
			
 
				+        *sz = vlen;
			
 
				+    return ret;
			
 
				+}
			
 
				+
			
 
				+/* Wrapper to allow argument-based switching between HEAD/TAIL pop */
			
 
				+void quicklistPush(quicklist *quicklist, void *value, const size_t sz,
			
 
				+                   int where) {
			
 
				+    /* The head and tail should never be compressed (we don't attempt to decompress them) */
			
 
				+    if (quicklist->head)
			
 
				+        assert(quicklist->head->encoding != QUICKLIST_NODE_ENCODING_LZF);
			
 
				+    if (quicklist->tail)
			
 
				+        assert(quicklist->tail->encoding != QUICKLIST_NODE_ENCODING_LZF);
			
 
				+
			
 
				+    if (where == QUICKLIST_HEAD) {
			
 
				+        quicklistPushHead(quicklist, value, sz);
			
 
				+    } else if (where == QUICKLIST_TAIL) {
			
 
				+        quicklistPushTail(quicklist, value, sz);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Print info of quicklist which is used in debugCommand. */
			
 
				+void quicklistRepr(unsigned char *ql, int full) {
			
 
				+    int i = 0;
			
 
				+    quicklist *quicklist  = (struct quicklist*) ql;
			
 
				+    printf("{count : %ld}\n", quicklist->count);
			
 
				+    printf("{len : %ld}\n", quicklist->len);
			
 
				+    printf("{fill : %d}\n", quicklist->fill);
			
 
				+    printf("{compress : %d}\n", quicklist->compress);
			
 
				+    printf("{bookmark_count : %d}\n", quicklist->bookmark_count);
			
 
				+    quicklistNode* node = quicklist->head;
			
 
				+
			
 
				+    while(node != NULL) {
			
 
				+        printf("{quicklist node(%d)\n", i++);
			
 
				+        printf("{container : %s, encoding: %s, size: %zu, recompress: %d, attempted_compress: %d}\n",
			
 
				+               QL_NODE_IS_PLAIN(node) ? "PLAIN": "PACKED",
			
 
				+               (node->encoding == QUICKLIST_NODE_ENCODING_RAW) ? "RAW": "LZF",
			
 
				+               node->sz,
			
 
				+               node->recompress,
			
 
				+               node->attempted_compress);
			
 
				+
			
 
				+        if (full) {
			
 
				+            quicklistDecompressNode(node);
			
 
				+            if (node->container == QUICKLIST_NODE_CONTAINER_PACKED) {
			
 
				+                printf("{ listpack:\n");
			
 
				+                lpRepr(node->entry);
			
 
				+                printf("}\n");
			
 
				+
			
 
				+            } else if (QL_NODE_IS_PLAIN(node)) {
			
 
				+                printf("{ entry : %s }\n", node->entry);
			
 
				+            }
			
 
				+            printf("}\n");
			
 
				+            quicklistRecompressOnly(node);
			
 
				+        }
			
 
				+        node = node->next;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Create or update a bookmark in the list which will be updated to the next node
			
 
				+ * automatically when the one referenced gets deleted.
			
 
				+ * Returns 1 on success (creation of new bookmark or override of an existing one).
			
 
				+ * Returns 0 on failure (reached the maximum supported number of bookmarks).
			
 
				+ * NOTE: use short simple names, so that string compare on find is quick.
			
 
				+ * NOTE: bookmark creation may re-allocate the quicklist, so the input pointer
			
 
				+         may change and it's the caller responsibility to update the reference.
			
 
				+ */
			
 
				+int quicklistBookmarkCreate(quicklist **ql_ref, const char *name, quicklistNode *node) {
			
 
				+    quicklist *ql = *ql_ref;
			
 
				+    if (ql->bookmark_count >= QL_MAX_BM)
			
 
				+        return 0;
			
 
				+    quicklistBookmark *bm = _quicklistBookmarkFindByName(ql, name);
			
 
				+    if (bm) {
			
 
				+        bm->node = node;
			
 
				+        return 1;
			
 
				+    }
			
 
				+    ql = zrealloc(ql, sizeof(quicklist) + (ql->bookmark_count+1) * sizeof(quicklistBookmark));
			
 
				+    *ql_ref = ql;
			
 
				+    ql->bookmarks[ql->bookmark_count].node = node;
			
 
				+    ql->bookmarks[ql->bookmark_count].name = zstrdup(name);
			
 
				+    ql->bookmark_count++;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Find the quicklist node referenced by a named bookmark.
			
 
				+ * When the bookmarked node is deleted the bookmark is updated to the next node,
			
 
				+ * and if that's the last node, the bookmark is deleted (so find returns NULL). */
			
 
				+quicklistNode *quicklistBookmarkFind(quicklist *ql, const char *name) {
			
 
				+    quicklistBookmark *bm = _quicklistBookmarkFindByName(ql, name);
			
 
				+    if (!bm) return NULL;
			
 
				+    return bm->node;
			
 
				+}
			
 
				+
			
 
				+/* Delete a named bookmark.
			
 
				+ * returns 0 if bookmark was not found, and 1 if deleted.
			
 
				+ * Note that the bookmark memory is not freed yet, and is kept for future use. */
			
 
				+int quicklistBookmarkDelete(quicklist *ql, const char *name) {
			
 
				+    quicklistBookmark *bm = _quicklistBookmarkFindByName(ql, name);
			
 
				+    if (!bm)
			
 
				+        return 0;
			
 
				+    _quicklistBookmarkDelete(ql, bm);
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+quicklistBookmark *_quicklistBookmarkFindByName(quicklist *ql, const char *name) {
			
 
				+    unsigned i;
			
 
				+    for (i=0; i<ql->bookmark_count; i++) {
			
 
				+        if (!strcmp(ql->bookmarks[i].name, name)) {
			
 
				+            return &ql->bookmarks[i];
			
 
				+        }
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+quicklistBookmark *_quicklistBookmarkFindByNode(quicklist *ql, quicklistNode *node) {
			
 
				+    unsigned i;
			
 
				+    for (i=0; i<ql->bookmark_count; i++) {
			
 
				+        if (ql->bookmarks[i].node == node) {
			
 
				+            return &ql->bookmarks[i];
			
 
				+        }
			
 
				+    }
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+void _quicklistBookmarkDelete(quicklist *ql, quicklistBookmark *bm) {
			
 
				+    int index = bm - ql->bookmarks;
			
 
				+    zfree(bm->name);
			
 
				+    ql->bookmark_count--;
			
 
				+    memmove(bm, bm+1, (ql->bookmark_count - index)* sizeof(*bm));
			
 
				+    /* NOTE: We do not shrink (realloc) the quicklist yet (to avoid resonance,
			
 
				+     * it may be re-used later (a call to realloc may NOP). */
			
 
				+}
			
 
				+
			
 
				+void quicklistBookmarksClear(quicklist *ql) {
			
 
				+    while (ql->bookmark_count)
			
 
				+        zfree(ql->bookmarks[--ql->bookmark_count].name);
			
 
				+    /* NOTE: We do not shrink (realloc) the quick list. main use case for this
			
 
				+     * function is just before releasing the allocation. */
			
 
				+}
			
 
				+
			
 
				+/* The rest of this file is test cases and test helpers. */
			
 
				+#ifdef REDIS_TEST
			
 
				+#include <stdint.h>
			
 
				+#include <sys/time.h>
			
 
				+#include "testhelp.h"
			
 
				+#include <stdlib.h>
			
 
				+
			
 
				+#define yell(str, ...) printf("ERROR! " str "\n\n", __VA_ARGS__)
			
 
				+
			
 
				+#define ERROR                                                                  \
			
 
				+    do {                                                                       \
			
 
				+        printf("\tERROR!\n");                                                  \
			
 
				+        err++;                                                                 \
			
 
				+    } while (0)
			
 
				+
			
 
				+#define ERR(x, ...)                                                            \
			
 
				+    do {                                                                       \
			
 
				+        printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__);                   \
			
 
				+        printf("ERROR! " x "\n", __VA_ARGS__);                                 \
			
 
				+        err++;                                                                 \
			
 
				+    } while (0)
			
 
				+
			
 
				+#define TEST(name) printf("test — %s\n", name);
			
 
				+#define TEST_DESC(name, ...) printf("test — " name "\n", __VA_ARGS__);
			
 
				+
			
 
				+#define QL_TEST_VERBOSE 0
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+static void ql_info(quicklist *ql) {
			
 
				+#if QL_TEST_VERBOSE
			
 
				+    printf("Container length: %lu\n", ql->len);
			
 
				+    printf("Container size: %lu\n", ql->count);
			
 
				+    if (ql->head)
			
 
				+        printf("\t(zsize head: %lu)\n", lpLength(ql->head->entry));
			
 
				+    if (ql->tail)
			
 
				+        printf("\t(zsize tail: %lu)\n", lpLength(ql->tail->entry));
			
 
				+    printf("\n");
			
 
				+#else
			
 
				+    UNUSED(ql);
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Return the UNIX time in microseconds */
			
 
				+static long long ustime(void) {
			
 
				+    struct timeval tv;
			
 
				+    long long ust;
			
 
				+
			
 
				+    gettimeofday(&tv, NULL);
			
 
				+    ust = ((long long)tv.tv_sec) * 1000000;
			
 
				+    ust += tv.tv_usec;
			
 
				+    return ust;
			
 
				+}
			
 
				+
			
 
				+/* Return the UNIX time in milliseconds */
			
 
				+static long long mstime(void) { return ustime() / 1000; }
			
 
				+
			
 
				+/* Iterate over an entire quicklist.
			
 
				+ * Print the list if 'print' == 1.
			
 
				+ *
			
 
				+ * Returns physical count of elements found by iterating over the list. */
			
 
				+static int _itrprintr(quicklist *ql, int print, int forward) {
			
 
				+    quicklistIter *iter =
			
 
				+        quicklistGetIterator(ql, forward ? AL_START_HEAD : AL_START_TAIL);
			
 
				+    quicklistEntry entry;
			
 
				+    int i = 0;
			
 
				+    int p = 0;
			
 
				+    quicklistNode *prev = NULL;
			
 
				+    while (quicklistNext(iter, &entry)) {
			
 
				+        if (entry.node != prev) {
			
 
				+            /* Count the number of list nodes too */
			
 
				+            p++;
			
 
				+            prev = entry.node;
			
 
				+        }
			
 
				+        if (print) {
			
 
				+            int size = (entry.sz > (1<<20)) ? 1<<20 : entry.sz;
			
 
				+            printf("[%3d (%2d)]: [%.*s] (%lld)\n", i, p, size,
			
 
				+                   (char *)entry.value, entry.longval);
			
 
				+        }
			
 
				+        i++;
			
 
				+    }
			
 
				+    quicklistReleaseIterator(iter);
			
 
				+    return i;
			
 
				+}
			
 
				+static int itrprintr(quicklist *ql, int print) {
			
 
				+    return _itrprintr(ql, print, 1);
			
 
				+}
			
 
				+
			
 
				+static int itrprintr_rev(quicklist *ql, int print) {
			
 
				+    return _itrprintr(ql, print, 0);
			
 
				+}
			
 
				+
			
 
				+#define ql_verify(a, b, c, d, e)                                               \
			
 
				+    do {                                                                       \
			
 
				+        err += _ql_verify((a), (b), (c), (d), (e));                            \
			
 
				+    } while (0)
			
 
				+
			
 
				+static int _ql_verify_compress(quicklist *ql) {
			
 
				+    int errors = 0;
			
 
				+    if (quicklistAllowsCompression(ql)) {
			
 
				+        quicklistNode *node = ql->head;
			
 
				+        unsigned int low_raw = ql->compress;
			
 
				+        unsigned int high_raw = ql->len - ql->compress;
			
 
				+
			
 
				+        for (unsigned int at = 0; at < ql->len; at++, node = node->next) {
			
 
				+            if (node && (at < low_raw || at >= high_raw)) {
			
 
				+                if (node->encoding != QUICKLIST_NODE_ENCODING_RAW) {
			
 
				+                    yell("Incorrect compression: node %d is "
			
 
				+                         "compressed at depth %d ((%u, %u); total "
			
 
				+                         "nodes: %lu; size: %zu; recompress: %d)",
			
 
				+                         at, ql->compress, low_raw, high_raw, ql->len, node->sz,
			
 
				+                         node->recompress);
			
 
				+                    errors++;
			
 
				+                }
			
 
				+            } else {
			
 
				+                if (node->encoding != QUICKLIST_NODE_ENCODING_LZF &&
			
 
				+                    !node->attempted_compress) {
			
 
				+                    yell("Incorrect non-compression: node %d is NOT "
			
 
				+                         "compressed at depth %d ((%u, %u); total "
			
 
				+                         "nodes: %lu; size: %zu; recompress: %d; attempted: %d)",
			
 
				+                         at, ql->compress, low_raw, high_raw, ql->len, node->sz,
			
 
				+                         node->recompress, node->attempted_compress);
			
 
				+                    errors++;
			
 
				+                }
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    return errors;
			
 
				+}
			
 
				+
			
 
				+/* Verify list metadata matches physical list contents. */
			
 
				+static int _ql_verify(quicklist *ql, uint32_t len, uint32_t count,
			
 
				+                      uint32_t head_count, uint32_t tail_count) {
			
 
				+    int errors = 0;
			
 
				+
			
 
				+    ql_info(ql);
			
 
				+    if (len != ql->len) {
			
 
				+        yell("quicklist length wrong: expected %d, got %lu", len, ql->len);
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    if (count != ql->count) {
			
 
				+        yell("quicklist count wrong: expected %d, got %lu", count, ql->count);
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    int loopr = itrprintr(ql, 0);
			
 
				+    if (loopr != (int)ql->count) {
			
 
				+        yell("quicklist cached count not match actual count: expected %lu, got "
			
 
				+             "%d",
			
 
				+             ql->count, loopr);
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    int rloopr = itrprintr_rev(ql, 0);
			
 
				+    if (loopr != rloopr) {
			
 
				+        yell("quicklist has different forward count than reverse count!  "
			
 
				+             "Forward count is %d, reverse count is %d.",
			
 
				+             loopr, rloopr);
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    if (ql->len == 0 && !errors) {
			
 
				+        return errors;
			
 
				+    }
			
 
				+
			
 
				+    if (ql->head && head_count != ql->head->count &&
			
 
				+        head_count != lpLength(ql->head->entry)) {
			
 
				+        yell("quicklist head count wrong: expected %d, "
			
 
				+             "got cached %d vs. actual %lu",
			
 
				+             head_count, ql->head->count, lpLength(ql->head->entry));
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    if (ql->tail && tail_count != ql->tail->count &&
			
 
				+        tail_count != lpLength(ql->tail->entry)) {
			
 
				+        yell("quicklist tail count wrong: expected %d, "
			
 
				+             "got cached %u vs. actual %lu",
			
 
				+             tail_count, ql->tail->count, lpLength(ql->tail->entry));
			
 
				+        errors++;
			
 
				+    }
			
 
				+
			
 
				+    errors += _ql_verify_compress(ql);
			
 
				+    return errors;
			
 
				+}
			
 
				+
			
 
				+/* Release iterator and verify compress correctly. */
			
 
				+static void ql_release_iterator(quicklistIter *iter) {
			
 
				+    quicklist *ql = NULL;
			
 
				+    if (iter) ql = iter->quicklist;
			
 
				+    quicklistReleaseIterator(iter);
			
 
				+    if (ql) assert(!_ql_verify_compress(ql));
			
 
				+}
			
 
				+
			
 
				+/* Generate new string concatenating integer i against string 'prefix' */
			
 
				+static char *genstr(char *prefix, int i) {
			
 
				+    static char result[64] = {0};
			
 
				+    snprintf(result, sizeof(result), "%s%d", prefix, i);
			
 
				+    return result;
			
 
				+}
			
 
				+
			
 
				+static void randstring(unsigned char *target, size_t sz) {
			
 
				+    size_t p = 0;
			
 
				+    int minval, maxval;
			
 
				+    switch(rand() % 3) {
			
 
				+    case 0:
			
 
				+        minval = 'a';
			
 
				+        maxval = 'z';
			
 
				+    break;
			
 
				+    case 1:
			
 
				+        minval = '0';
			
 
				+        maxval = '9';
			
 
				+    break;
			
 
				+    case 2:
			
 
				+        minval = 'A';
			
 
				+        maxval = 'Z';
			
 
				+    break;
			
 
				+    default:
			
 
				+        assert(NULL);
			
 
				+    }
			
 
				+
			
 
				+    while(p < sz)
			
 
				+        target[p++] = minval+rand()%(maxval-minval+1);
			
 
				+}
			
 
				+
			
 
				+/* main test, but callable from other files */
			
 
				+int quicklistTest(int argc, char *argv[], int flags) {
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+
			
 
				+    int accurate = (flags & REDIS_TEST_ACCURATE);
			
 
				+    unsigned int err = 0;
			
 
				+    int optimize_start =
			
 
				+        -(int)(sizeof(optimization_level) / sizeof(*optimization_level));
			
 
				+
			
 
				+    printf("Starting optimization offset at: %d\n", optimize_start);
			
 
				+
			
 
				+    int options[] = {0, 1, 2, 3, 4, 5, 6, 10};
			
 
				+    int fills[] = {-5, -4, -3, -2, -1, 0,
			
 
				+                   1, 2, 32, 66, 128, 999};
			
 
				+    size_t option_count = sizeof(options) / sizeof(*options);
			
 
				+    int fill_count = (int)(sizeof(fills) / sizeof(*fills));
			
 
				+    long long runtime[option_count];
			
 
				+
			
 
				+    for (int _i = 0; _i < (int)option_count; _i++) {
			
 
				+        printf("Testing Compression option %d\n", options[_i]);
			
 
				+        long long start = mstime();
			
 
				+        quicklistIter *iter;
			
 
				+
			
 
				+        TEST("create list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("add to tail of empty list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushTail(ql, "hello", 6);
			
 
				+            /* 1 for head and 1 for tail because 1 node = head = tail */
			
 
				+            ql_verify(ql, 1, 1, 1, 1);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("add to head of empty list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, "hello", 6);
			
 
				+            /* 1 for head and 1 for tail because 1 node = head = tail */
			
 
				+            ql_verify(ql, 1, 1, 1, 1);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("add to tail 5x at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 5; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i), 32);
			
 
				+                if (ql->count != 5)
			
 
				+                    ERROR;
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 5, 5, 5);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("add to head 5x at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 5; i++)
			
 
				+                    quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+                if (ql->count != 5)
			
 
				+                    ERROR;
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 5, 5, 5);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("add to tail 500x at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i), 64);
			
 
				+                if (ql->count != 500)
			
 
				+                    ERROR;
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 16, 500, 32, 20);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("add to head 500x at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+                if (ql->count != 500)
			
 
				+                    ERROR;
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 16, 500, 20, 32);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST("rotate empty") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistRotate(ql);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("Comprassion Plain node") {
			
 
				+            char buf[256];
			
 
				+            quicklistisSetPackedThreshold(1);
			
 
				+            quicklist *ql = quicklistNew(-2, 1);
			
 
				+            for (int i = 0; i < 500; i++) {
			
 
				+                /* Set to 256 to allow the node to be triggered to compress,
			
 
				+                 * if it is less than 48(nocompress), the test will be successful. */
			
 
				+                snprintf(buf, sizeof(buf), "hello%d", i);
			
 
				+                quicklistPushHead(ql, buf, 256);
			
 
				+            }
			
 
				+
			
 
				+            quicklistIter *iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+            quicklistEntry entry;
			
 
				+            int i = 0;
			
 
				+            while (quicklistNext(iter, &entry)) {
			
 
				+                snprintf(buf, sizeof(buf), "hello%d", i);
			
 
				+                if (strcmp((char *)entry.value, buf))
			
 
				+                    ERR("value [%s] didn't match [%s] at position %d",
			
 
				+                        entry.value, buf, i);
			
 
				+                i++;
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("NEXT plain node")
			
 
				+        {
			
 
				+            packed_threshold = 3;
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            char *strings[] = {"hello1", "hello2", "h3", "h4", "hello5"};
			
 
				+
			
 
				+            for (int i = 0; i < 5; ++i)
			
 
				+                quicklistPushHead(ql, strings[i], strlen(strings[i]));
			
 
				+
			
 
				+            quicklistEntry entry;
			
 
				+            quicklistIter *iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+            int j = 0;
			
 
				+
			
 
				+            while(quicklistNext(iter, &entry) != 0) {
			
 
				+                assert(strncmp(strings[j], (char *)entry.value, strlen(strings[j])) == 0);
			
 
				+                j++;
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("rotate plain node ") {
			
 
				+            unsigned char *data = NULL;
			
 
				+            size_t sz;
			
 
				+            long long lv;
			
 
				+            int i =0;
			
 
				+            packed_threshold = 5;
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, "hello1", 6);
			
 
				+            quicklistPushHead(ql, "hello4", 6);
			
 
				+            quicklistPushHead(ql, "hello3", 6);
			
 
				+            quicklistPushHead(ql, "hello2", 6);
			
 
				+            quicklistRotate(ql);
			
 
				+
			
 
				+            for(i = 1 ; i < 5; i++) {
			
 
				+                quicklistPop(ql, QUICKLIST_HEAD, &data, &sz, &lv);
			
 
				+                int temp_char = data[5];
			
 
				+                zfree(data);
			
 
				+                assert(temp_char == ('0' + i));
			
 
				+            }
			
 
				+
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+            packed_threshold = (1 << 30);
			
 
				+        }
			
 
				+
			
 
				+        TEST("rotate one val once") {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                quicklistPushHead(ql, "hello", 6);
			
 
				+                quicklistRotate(ql);
			
 
				+                /* Ignore compression verify because listpack is
			
 
				+                 * too small to compress. */
			
 
				+                ql_verify(ql, 1, 1, 1, 1);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("rotate 500 val 5000 times at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                quicklistPushHead(ql, "900", 3);
			
 
				+                quicklistPushHead(ql, "7000", 4);
			
 
				+                quicklistPushHead(ql, "-1200", 5);
			
 
				+                quicklistPushHead(ql, "42", 2);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushHead(ql, genstr("hello", i), 64);
			
 
				+                ql_info(ql);
			
 
				+                for (int i = 0; i < 5000; i++) {
			
 
				+                    ql_info(ql);
			
 
				+                    quicklistRotate(ql);
			
 
				+                }
			
 
				+                if (fills[f] == 1)
			
 
				+                    ql_verify(ql, 504, 504, 1, 1);
			
 
				+                else if (fills[f] == 2)
			
 
				+                    ql_verify(ql, 252, 504, 2, 2);
			
 
				+                else if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 16, 504, 32, 24);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST("pop empty") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPop(ql, QUICKLIST_HEAD, NULL, NULL, NULL);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("pop 1 string from 1") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            char *populate = genstr("hello", 331);
			
 
				+            quicklistPushHead(ql, populate, 32);
			
 
				+            unsigned char *data;
			
 
				+            size_t sz;
			
 
				+            long long lv;
			
 
				+            ql_info(ql);
			
 
				+            assert(quicklistPop(ql, QUICKLIST_HEAD, &data, &sz, &lv));
			
 
				+            assert(data != NULL);
			
 
				+            assert(sz == 32);
			
 
				+            if (strcmp(populate, (char *)data)) {
			
 
				+                int size = sz;
			
 
				+                ERR("Pop'd value (%.*s) didn't equal original value (%s)", size,
			
 
				+                    data, populate);
			
 
				+            }
			
 
				+            zfree(data);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("pop head 1 number from 1") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, "55513", 5);
			
 
				+            unsigned char *data;
			
 
				+            size_t sz;
			
 
				+            long long lv;
			
 
				+            ql_info(ql);
			
 
				+            assert(quicklistPop(ql, QUICKLIST_HEAD, &data, &sz, &lv));
			
 
				+            assert(data == NULL);
			
 
				+            assert(lv == 55513);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("pop head 500 from 500") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            ql_info(ql);
			
 
				+            for (int i = 0; i < 500; i++) {
			
 
				+                unsigned char *data;
			
 
				+                size_t sz;
			
 
				+                long long lv;
			
 
				+                int ret = quicklistPop(ql, QUICKLIST_HEAD, &data, &sz, &lv);
			
 
				+                assert(ret == 1);
			
 
				+                assert(data != NULL);
			
 
				+                assert(sz == 32);
			
 
				+                if (strcmp(genstr("hello", 499 - i), (char *)data)) {
			
 
				+                    int size = sz;
			
 
				+                    ERR("Pop'd value (%.*s) didn't equal original value (%s)",
			
 
				+                        size, data, genstr("hello", 499 - i));
			
 
				+                }
			
 
				+                zfree(data);
			
 
				+            }
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("pop head 5000 from 500") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            for (int i = 0; i < 5000; i++) {
			
 
				+                unsigned char *data;
			
 
				+                size_t sz;
			
 
				+                long long lv;
			
 
				+                int ret = quicklistPop(ql, QUICKLIST_HEAD, &data, &sz, &lv);
			
 
				+                if (i < 500) {
			
 
				+                    assert(ret == 1);
			
 
				+                    assert(data != NULL);
			
 
				+                    assert(sz == 32);
			
 
				+                    if (strcmp(genstr("hello", 499 - i), (char *)data)) {
			
 
				+                        int size = sz;
			
 
				+                        ERR("Pop'd value (%.*s) didn't equal original value "
			
 
				+                            "(%s)",
			
 
				+                            size, data, genstr("hello", 499 - i));
			
 
				+                    }
			
 
				+                    zfree(data);
			
 
				+                } else {
			
 
				+                    assert(ret == 0);
			
 
				+                }
			
 
				+            }
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("iterate forward over 500 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            quicklistIter *iter = quicklistGetIterator(ql, AL_START_HEAD);
			
 
				+            quicklistEntry entry;
			
 
				+            int i = 499, count = 0;
			
 
				+            while (quicklistNext(iter, &entry)) {
			
 
				+                char *h = genstr("hello", i);
			
 
				+                if (strcmp((char *)entry.value, h))
			
 
				+                    ERR("value [%s] didn't match [%s] at position %d",
			
 
				+                        entry.value, h, i);
			
 
				+                i--;
			
 
				+                count++;
			
 
				+            }
			
 
				+            if (count != 500)
			
 
				+                ERR("Didn't iterate over exactly 500 elements (%d)", i);
			
 
				+            ql_verify(ql, 16, 500, 20, 32);
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("iterate reverse over 500 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            quicklistIter *iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+            quicklistEntry entry;
			
 
				+            int i = 0;
			
 
				+            while (quicklistNext(iter, &entry)) {
			
 
				+                char *h = genstr("hello", i);
			
 
				+                if (strcmp((char *)entry.value, h))
			
 
				+                    ERR("value [%s] didn't match [%s] at position %d",
			
 
				+                        entry.value, h, i);
			
 
				+                i++;
			
 
				+            }
			
 
				+            if (i != 500)
			
 
				+                ERR("Didn't iterate over exactly 500 elements (%d)", i);
			
 
				+            ql_verify(ql, 16, 500, 20, 32);
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("insert after 1 element") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, "hello", 6);
			
 
				+            quicklistEntry entry;
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+            quicklistInsertAfter(iter, &entry, "abc", 4);
			
 
				+            ql_release_iterator(iter);
			
 
				+            ql_verify(ql, 1, 2, 2, 2);
			
 
				+
			
 
				+            /* verify results */
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+            int sz = entry.sz;
			
 
				+            if (strncmp((char *)entry.value, "hello", 5)) {
			
 
				+                ERR("Value 0 didn't match, instead got: %.*s", sz,
			
 
				+                    entry.value);
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 1, &entry);
			
 
				+            sz = entry.sz;
			
 
				+            if (strncmp((char *)entry.value, "abc", 3)) {
			
 
				+                ERR("Value 1 didn't match, instead got: %.*s", sz,
			
 
				+                    entry.value);
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("insert before 1 element") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, "hello", 6);
			
 
				+            quicklistEntry entry;
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+            quicklistInsertBefore(iter, &entry, "abc", 4);
			
 
				+            ql_release_iterator(iter);
			
 
				+            ql_verify(ql, 1, 2, 2, 2);
			
 
				+
			
 
				+            /* verify results */
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+            int sz = entry.sz;
			
 
				+            if (strncmp((char *)entry.value, "abc", 3)) {
			
 
				+                ERR("Value 0 didn't match, instead got: %.*s", sz,
			
 
				+                    entry.value);
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 1, &entry);
			
 
				+            sz = entry.sz;
			
 
				+            if (strncmp((char *)entry.value, "hello", 5)) {
			
 
				+                ERR("Value 1 didn't match, instead got: %.*s", sz,
			
 
				+                    entry.value);
			
 
				+            }
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("insert head while head node is full") {
			
 
				+            quicklist *ql = quicklistNew(4, options[_i]);
			
 
				+            for (int i = 0; i < 10; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i), 6);
			
 
				+            quicklistSetFill(ql, -1);
			
 
				+            quicklistEntry entry;
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -10, &entry);
			
 
				+            char buf[4096] = {0};
			
 
				+            quicklistInsertBefore(iter, &entry, buf, 4096);
			
 
				+            ql_release_iterator(iter);
			
 
				+            ql_verify(ql, 4, 11, 1, 2);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("insert tail while tail node is full") {
			
 
				+            quicklist *ql = quicklistNew(4, options[_i]);
			
 
				+            for (int i = 0; i < 10; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 6);
			
 
				+            quicklistSetFill(ql, -1);
			
 
				+            quicklistEntry entry;
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -1, &entry);
			
 
				+            char buf[4096] = {0};
			
 
				+            quicklistInsertAfter(iter, &entry, buf, 4096);
			
 
				+            ql_release_iterator(iter);
			
 
				+            ql_verify(ql, 4, 11, 2, 1);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("insert once in elements while iterating at compress %d",
			
 
				+                  options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                quicklistPushTail(ql, "abc", 3);
			
 
				+                quicklistSetFill(ql, 1);
			
 
				+                quicklistPushTail(ql, "def", 3); /* force to unique node */
			
 
				+                quicklistSetFill(ql, f);
			
 
				+                quicklistPushTail(ql, "bob", 3); /* force to reset for +3 */
			
 
				+                quicklistPushTail(ql, "foo", 3);
			
 
				+                quicklistPushTail(ql, "zoo", 3);
			
 
				+
			
 
				+                itrprintr(ql, 0);
			
 
				+                /* insert "bar" before "bob" while iterating over list. */
			
 
				+                quicklistIter *iter = quicklistGetIterator(ql, AL_START_HEAD);
			
 
				+                quicklistEntry entry;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (!strncmp((char *)entry.value, "bob", 3)) {
			
 
				+                        /* Insert as fill = 1 so it spills into new node. */
			
 
				+                        quicklistInsertBefore(iter, &entry, "bar", 3);
			
 
				+                        break; /* didn't we fix insert-while-iterating? */
			
 
				+                    }
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+                itrprintr(ql, 0);
			
 
				+
			
 
				+                /* verify results */
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+                int sz = entry.sz;
			
 
				+
			
 
				+                if (strncmp((char *)entry.value, "abc", 3))
			
 
				+                    ERR("Value 0 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 1, &entry);
			
 
				+                if (strncmp((char *)entry.value, "def", 3))
			
 
				+                    ERR("Value 1 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 2, &entry);
			
 
				+                if (strncmp((char *)entry.value, "bar", 3))
			
 
				+                    ERR("Value 2 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 3, &entry);
			
 
				+                if (strncmp((char *)entry.value, "bob", 3))
			
 
				+                    ERR("Value 3 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 4, &entry);
			
 
				+                if (strncmp((char *)entry.value, "foo", 3))
			
 
				+                    ERR("Value 4 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 5, &entry);
			
 
				+                if (strncmp((char *)entry.value, "zoo", 3))
			
 
				+                    ERR("Value 5 didn't match, instead got: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("insert [before] 250 new in middle of 500 elements at compress %d",
			
 
				+                  options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i), 32);
			
 
				+                for (int i = 0; i < 250; i++) {
			
 
				+                    quicklistEntry entry;
			
 
				+                    iter = quicklistGetIteratorEntryAtIdx(ql, 250, &entry);
			
 
				+                    quicklistInsertBefore(iter, &entry, genstr("abc", i), 32);
			
 
				+                    ql_release_iterator(iter);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 25, 750, 32, 20);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("insert [after] 250 new in middle of 500 elements at compress %d",
			
 
				+                  options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+                for (int i = 0; i < 250; i++) {
			
 
				+                    quicklistEntry entry;
			
 
				+                    iter = quicklistGetIteratorEntryAtIdx(ql, 250, &entry);
			
 
				+                    quicklistInsertAfter(iter, &entry, genstr("abc", i), 32);
			
 
				+                    ql_release_iterator(iter);
			
 
				+                }
			
 
				+
			
 
				+                if (ql->count != 750)
			
 
				+                    ERR("List size not 750, but rather %ld", ql->count);
			
 
				+
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 26, 750, 20, 32);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST("duplicate empty list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklist *copy = quicklistDup(ql);
			
 
				+            ql_verify(copy, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+            quicklistRelease(copy);
			
 
				+        }
			
 
				+
			
 
				+        TEST("duplicate list of 1 element") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushHead(ql, genstr("hello", 3), 32);
			
 
				+            ql_verify(ql, 1, 1, 1, 1);
			
 
				+            quicklist *copy = quicklistDup(ql);
			
 
				+            ql_verify(copy, 1, 1, 1, 1);
			
 
				+            quicklistRelease(ql);
			
 
				+            quicklistRelease(copy);
			
 
				+        }
			
 
				+
			
 
				+        TEST("duplicate list of 500") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            ql_verify(ql, 16, 500, 20, 32);
			
 
				+
			
 
				+            quicklist *copy = quicklistDup(ql);
			
 
				+            ql_verify(copy, 16, 500, 20, 32);
			
 
				+            quicklistRelease(ql);
			
 
				+            quicklistRelease(copy);
			
 
				+        }
			
 
				+
			
 
				+        for (int f = 0; f < fill_count; f++) {
			
 
				+            TEST_DESC("index 1,200 from 500 list at fill %d at compress %d", f,
			
 
				+                      options[_i]) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+                quicklistEntry entry;
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 1, &entry);
			
 
				+                if (strcmp((char *)entry.value, "hello2") != 0)
			
 
				+                    ERR("Value: %s", entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 200, &entry);
			
 
				+                if (strcmp((char *)entry.value, "hello201") != 0)
			
 
				+                    ERR("Value: %s", entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+
			
 
				+            TEST_DESC("index -1,-2 from 500 list at fill %d at compress %d",
			
 
				+                      fills[f], options[_i]) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+                quicklistEntry entry;
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, -1, &entry);
			
 
				+                if (strcmp((char *)entry.value, "hello500") != 0)
			
 
				+                    ERR("Value: %s", entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, -2, &entry);
			
 
				+                if (strcmp((char *)entry.value, "hello499") != 0)
			
 
				+                    ERR("Value: %s", entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+
			
 
				+            TEST_DESC("index -100 from 500 list at fill %d at compress %d",
			
 
				+                      fills[f], options[_i]) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 500; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+                quicklistEntry entry;
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, -100, &entry);
			
 
				+                if (strcmp((char *)entry.value, "hello401") != 0)
			
 
				+                    ERR("Value: %s", entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+
			
 
				+            TEST_DESC("index too big +1 from 50 list at fill %d at compress %d",
			
 
				+                      fills[f], options[_i]) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                for (int i = 0; i < 50; i++)
			
 
				+                    quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+                quicklistEntry entry;
			
 
				+                int sz = entry.sz;
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 50, &entry);
			
 
				+                if (iter)
			
 
				+                    ERR("Index found at 50 with 50 list: %.*s", sz,
			
 
				+                        entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete range empty list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistDelRange(ql, 5, 20);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete range of entire node in list of one node") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            for (int i = 0; i < 32; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            ql_verify(ql, 1, 32, 32, 32);
			
 
				+            quicklistDelRange(ql, 0, 32);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete range of entire node with overflow counts") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            for (int i = 0; i < 32; i++)
			
 
				+                quicklistPushHead(ql, genstr("hello", i), 32);
			
 
				+            ql_verify(ql, 1, 32, 32, 32);
			
 
				+            quicklistDelRange(ql, 0, 128);
			
 
				+            ql_verify(ql, 0, 0, 0, 0);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete middle 100 of 500 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            ql_verify(ql, 16, 500, 32, 20);
			
 
				+            quicklistDelRange(ql, 200, 100);
			
 
				+            ql_verify(ql, 14, 400, 32, 20);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete less than fill but across nodes") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            ql_verify(ql, 16, 500, 32, 20);
			
 
				+            quicklistDelRange(ql, 60, 10);
			
 
				+            ql_verify(ql, 16, 490, 32, 20);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete negative 1 from 500 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            ql_verify(ql, 16, 500, 32, 20);
			
 
				+            quicklistDelRange(ql, -1, 1);
			
 
				+            ql_verify(ql, 16, 499, 32, 19);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete negative 1 from 500 list with overflow counts") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            ql_verify(ql, 16, 500, 32, 20);
			
 
				+            quicklistDelRange(ql, -1, 128);
			
 
				+            ql_verify(ql, 16, 499, 32, 19);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete negative 100 from 500 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 500; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            quicklistDelRange(ql, -100, 100);
			
 
				+            ql_verify(ql, 13, 400, 32, 16);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("delete -10 count 5 from 50 list") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            for (int i = 0; i < 50; i++)
			
 
				+                quicklistPushTail(ql, genstr("hello", i + 1), 32);
			
 
				+            ql_verify(ql, 2, 50, 32, 18);
			
 
				+            quicklistDelRange(ql, -10, 5);
			
 
				+            ql_verify(ql, 2, 45, 32, 13);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("numbers only list read") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushTail(ql, "1111", 4);
			
 
				+            quicklistPushTail(ql, "2222", 4);
			
 
				+            quicklistPushTail(ql, "3333", 4);
			
 
				+            quicklistPushTail(ql, "4444", 4);
			
 
				+            ql_verify(ql, 1, 4, 4, 4);
			
 
				+            quicklistEntry entry;
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+            if (entry.longval != 1111)
			
 
				+                ERR("Not 1111, %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 1, &entry);
			
 
				+            if (entry.longval != 2222)
			
 
				+                ERR("Not 2222, %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 2, &entry);
			
 
				+            if (entry.longval != 3333)
			
 
				+                ERR("Not 3333, %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 3, &entry);
			
 
				+            if (entry.longval != 4444)
			
 
				+                ERR("Not 4444, %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 4, &entry);
			
 
				+            if (iter)
			
 
				+                ERR("Index past elements: %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+            
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -1, &entry);
			
 
				+            if (entry.longval != 4444)
			
 
				+                ERR("Not 4444 (reverse), %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -2, &entry);
			
 
				+            if (entry.longval != 3333)
			
 
				+                ERR("Not 3333 (reverse), %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -3, &entry);
			
 
				+            if (entry.longval != 2222)
			
 
				+                ERR("Not 2222 (reverse), %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+            
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -4, &entry);
			
 
				+            if (entry.longval != 1111)
			
 
				+                ERR("Not 1111 (reverse), %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+            
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, -5, &entry);
			
 
				+            if (iter)
			
 
				+                ERR("Index past elements (reverse), %lld", entry.longval);
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("numbers larger list read") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistSetFill(ql, 32);
			
 
				+            char num[32];
			
 
				+            long long nums[5000];
			
 
				+            for (int i = 0; i < 5000; i++) {
			
 
				+                nums[i] = -5157318210846258176 + i;
			
 
				+                int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                quicklistPushTail(ql, num, sz);
			
 
				+            }
			
 
				+            quicklistPushTail(ql, "xxxxxxxxxxxxxxxxxxxx", 20);
			
 
				+            quicklistEntry entry;
			
 
				+            for (int i = 0; i < 5000; i++) {
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, i, &entry);
			
 
				+                if (entry.longval != nums[i])
			
 
				+                    ERR("[%d] Not longval %lld but rather %lld", i, nums[i],
			
 
				+                        entry.longval);
			
 
				+                entry.longval = 0xdeadbeef;
			
 
				+                ql_release_iterator(iter);
			
 
				+            }
			
 
				+            iter = quicklistGetIteratorEntryAtIdx(ql, 5000, &entry);
			
 
				+            if (strncmp((char *)entry.value, "xxxxxxxxxxxxxxxxxxxx", 20))
			
 
				+                ERR("String val not match: %s", entry.value);
			
 
				+            ql_verify(ql, 157, 5001, 32, 9);
			
 
				+            ql_release_iterator(iter);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST("numbers larger list read B") {
			
 
				+            quicklist *ql = quicklistNew(-2, options[_i]);
			
 
				+            quicklistPushTail(ql, "99", 2);
			
 
				+            quicklistPushTail(ql, "98", 2);
			
 
				+            quicklistPushTail(ql, "xxxxxxxxxxxxxxxxxxxx", 20);
			
 
				+            quicklistPushTail(ql, "96", 2);
			
 
				+            quicklistPushTail(ql, "95", 2);
			
 
				+            quicklistReplaceAtIndex(ql, 1, "foo", 3);
			
 
				+            quicklistReplaceAtIndex(ql, -1, "bar", 3);
			
 
				+            quicklistRelease(ql);
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("lrem test at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                char *words[] = {"abc", "foo", "bar",  "foobar", "foobared",
			
 
				+                                 "zap", "bar", "test", "foo"};
			
 
				+                char *result[] = {"abc", "foo",  "foobar", "foobared",
			
 
				+                                  "zap", "test", "foo"};
			
 
				+                char *resultB[] = {"abc",      "foo", "foobar",
			
 
				+                                   "foobared", "zap", "test"};
			
 
				+                for (int i = 0; i < 9; i++)
			
 
				+                    quicklistPushTail(ql, words[i], strlen(words[i]));
			
 
				+
			
 
				+                /* lrem 0 bar */
			
 
				+                quicklistIter *iter = quicklistGetIterator(ql, AL_START_HEAD);
			
 
				+                quicklistEntry entry;
			
 
				+                int i = 0;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (quicklistCompare(&entry, (unsigned char *)"bar", 3)) {
			
 
				+                        quicklistDelEntry(iter, &entry);
			
 
				+                    }
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                /* check result of lrem 0 bar */
			
 
				+                iter = quicklistGetIterator(ql, AL_START_HEAD);
			
 
				+                i = 0;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    /* Result must be: abc, foo, foobar, foobared, zap, test,
			
 
				+                     * foo */
			
 
				+                    int sz = entry.sz;
			
 
				+                    if (strncmp((char *)entry.value, result[i], entry.sz)) {
			
 
				+                        ERR("No match at position %d, got %.*s instead of %s",
			
 
				+                            i, sz, entry.value, result[i]);
			
 
				+                    }
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                quicklistPushTail(ql, "foo", 3);
			
 
				+
			
 
				+                /* lrem -2 foo */
			
 
				+                iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+                i = 0;
			
 
				+                int del = 2;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (quicklistCompare(&entry, (unsigned char *)"foo", 3)) {
			
 
				+                        quicklistDelEntry(iter, &entry);
			
 
				+                        del--;
			
 
				+                    }
			
 
				+                    if (!del)
			
 
				+                        break;
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                /* check result of lrem -2 foo */
			
 
				+                /* (we're ignoring the '2' part and still deleting all foo
			
 
				+                 * because
			
 
				+                 * we only have two foo) */
			
 
				+                iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+                i = 0;
			
 
				+                size_t resB = sizeof(resultB) / sizeof(*resultB);
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    /* Result must be: abc, foo, foobar, foobared, zap, test,
			
 
				+                     * foo */
			
 
				+                    int sz = entry.sz;
			
 
				+                    if (strncmp((char *)entry.value, resultB[resB - 1 - i],
			
 
				+                                sz)) {
			
 
				+                        ERR("No match at position %d, got %.*s instead of %s",
			
 
				+                            i, sz, entry.value, resultB[resB - 1 - i]);
			
 
				+                    }
			
 
				+                    i++;
			
 
				+                }
			
 
				+
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("iterate reverse + delete at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                quicklistPushTail(ql, "abc", 3);
			
 
				+                quicklistPushTail(ql, "def", 3);
			
 
				+                quicklistPushTail(ql, "hij", 3);
			
 
				+                quicklistPushTail(ql, "jkl", 3);
			
 
				+                quicklistPushTail(ql, "oop", 3);
			
 
				+
			
 
				+                quicklistEntry entry;
			
 
				+                quicklistIter *iter = quicklistGetIterator(ql, AL_START_TAIL);
			
 
				+                int i = 0;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (quicklistCompare(&entry, (unsigned char *)"hij", 3)) {
			
 
				+                        quicklistDelEntry(iter, &entry);
			
 
				+                    }
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                if (i != 5)
			
 
				+                    ERR("Didn't iterate 5 times, iterated %d times.", i);
			
 
				+
			
 
				+                /* Check results after deletion of "hij" */
			
 
				+                iter = quicklistGetIterator(ql, AL_START_HEAD);
			
 
				+                i = 0;
			
 
				+                char *vals[] = {"abc", "def", "jkl", "oop"};
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (!quicklistCompare(&entry, (unsigned char *)vals[i],
			
 
				+                                          3)) {
			
 
				+                        ERR("Value at %d didn't match %s\n", i, vals[i]);
			
 
				+                    }
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("iterator at index test at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                char num[32];
			
 
				+                long long nums[5000];
			
 
				+                for (int i = 0; i < 760; i++) {
			
 
				+                    nums[i] = -5157318210846258176 + i;
			
 
				+                    int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                    quicklistPushTail(ql, num, sz);
			
 
				+                }
			
 
				+
			
 
				+                quicklistEntry entry;
			
 
				+                quicklistIter *iter =
			
 
				+                    quicklistGetIteratorAtIdx(ql, AL_START_HEAD, 437);
			
 
				+                int i = 437;
			
 
				+                while (quicklistNext(iter, &entry)) {
			
 
				+                    if (entry.longval != nums[i])
			
 
				+                        ERR("Expected %lld, but got %lld", entry.longval,
			
 
				+                            nums[i]);
			
 
				+                    i++;
			
 
				+                }
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("ltrim test A at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                char num[32];
			
 
				+                long long nums[5000];
			
 
				+                for (int i = 0; i < 32; i++) {
			
 
				+                    nums[i] = -5157318210846258176 + i;
			
 
				+                    int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                    quicklistPushTail(ql, num, sz);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 32, 32, 32);
			
 
				+                /* ltrim 25 53 (keep [25,32] inclusive = 7 remaining) */
			
 
				+                quicklistDelRange(ql, 0, 25);
			
 
				+                quicklistDelRange(ql, 0, 0);
			
 
				+                quicklistEntry entry;
			
 
				+                for (int i = 0; i < 7; i++) {
			
 
				+                    iter = quicklistGetIteratorEntryAtIdx(ql, i, &entry);
			
 
				+                    if (entry.longval != nums[25 + i])
			
 
				+                        ERR("Deleted invalid range!  Expected %lld but got "
			
 
				+                            "%lld",
			
 
				+                            entry.longval, nums[25 + i]);
			
 
				+                    ql_release_iterator(iter);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 7, 7, 7);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("ltrim test B at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                /* Force-disable compression because our 33 sequential
			
 
				+                 * integers don't compress and the check always fails. */
			
 
				+                quicklist *ql = quicklistNew(fills[f], QUICKLIST_NOCOMPRESS);
			
 
				+                char num[32];
			
 
				+                long long nums[5000];
			
 
				+                for (int i = 0; i < 33; i++) {
			
 
				+                    nums[i] = i;
			
 
				+                    int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                    quicklistPushTail(ql, num, sz);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 2, 33, 32, 1);
			
 
				+                /* ltrim 5 16 (keep [5,16] inclusive = 12 remaining) */
			
 
				+                quicklistDelRange(ql, 0, 5);
			
 
				+                quicklistDelRange(ql, -16, 16);
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 12, 12, 12);
			
 
				+                quicklistEntry entry;
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+                if (entry.longval != 5)
			
 
				+                    ERR("A: longval not 5, but %lld", entry.longval);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, -1, &entry);
			
 
				+                if (entry.longval != 16)
			
 
				+                    ERR("B! got instead: %lld", entry.longval);
			
 
				+                quicklistPushTail(ql, "bobobob", 7);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, -1, &entry);
			
 
				+                int sz = entry.sz;
			
 
				+                if (strncmp((char *)entry.value, "bobobob", 7))
			
 
				+                    ERR("Tail doesn't match bobobob, it's %.*s instead",
			
 
				+                        sz, entry.value);
			
 
				+                ql_release_iterator(iter);
			
 
				+
			
 
				+                for (int i = 0; i < 12; i++) {
			
 
				+                    iter = quicklistGetIteratorEntryAtIdx(ql, i, &entry);
			
 
				+                    if (entry.longval != nums[5 + i])
			
 
				+                        ERR("Deleted invalid range!  Expected %lld but got "
			
 
				+                            "%lld",
			
 
				+                            entry.longval, nums[5 + i]);
			
 
				+                    ql_release_iterator(iter);
			
 
				+                }
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("ltrim test C at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                char num[32];
			
 
				+                long long nums[5000];
			
 
				+                for (int i = 0; i < 33; i++) {
			
 
				+                    nums[i] = -5157318210846258176 + i;
			
 
				+                    int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                    quicklistPushTail(ql, num, sz);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 2, 33, 32, 1);
			
 
				+                /* ltrim 3 3 (keep [3,3] inclusive = 1 remaining) */
			
 
				+                quicklistDelRange(ql, 0, 3);
			
 
				+                quicklistDelRange(ql, -29,
			
 
				+                                  4000); /* make sure not loop forever */
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 1, 1, 1, 1);
			
 
				+                quicklistEntry entry;
			
 
				+                iter = quicklistGetIteratorEntryAtIdx(ql, 0, &entry);
			
 
				+                if (entry.longval != -5157318210846258173)
			
 
				+                    ERROR;
			
 
				+                ql_release_iterator(iter);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        TEST_DESC("ltrim test D at compress %d", options[_i]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                quicklist *ql = quicklistNew(fills[f], options[_i]);
			
 
				+                char num[32];
			
 
				+                long long nums[5000];
			
 
				+                for (int i = 0; i < 33; i++) {
			
 
				+                    nums[i] = -5157318210846258176 + i;
			
 
				+                    int sz = ll2string(num, sizeof(num), nums[i]);
			
 
				+                    quicklistPushTail(ql, num, sz);
			
 
				+                }
			
 
				+                if (fills[f] == 32)
			
 
				+                    ql_verify(ql, 2, 33, 32, 1);
			
 
				+                quicklistDelRange(ql, -12, 3);
			
 
				+                if (ql->count != 30)
			
 
				+                    ERR("Didn't delete exactly three elements!  Count is: %lu",
			
 
				+                        ql->count);
			
 
				+                quicklistRelease(ql);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        long long stop = mstime();
			
 
				+        runtime[_i] = stop - start;
			
 
				+    }
			
 
				+
			
 
				+    /* Run a longer test of compression depth outside of primary test loop. */
			
 
				+    int list_sizes[] = {250, 251, 500, 999, 1000};
			
 
				+    long long start = mstime();
			
 
				+    int list_count = accurate ? (int)(sizeof(list_sizes) / sizeof(*list_sizes)) : 1;
			
 
				+    for (int list = 0; list < list_count; list++) {
			
 
				+        TEST_DESC("verify specific compression of interior nodes with %d list ",
			
 
				+                  list_sizes[list]) {
			
 
				+            for (int f = 0; f < fill_count; f++) {
			
 
				+                for (int depth = 1; depth < 40; depth++) {
			
 
				+                    /* skip over many redundant test cases */
			
 
				+                    quicklist *ql = quicklistNew(fills[f], depth);
			
 
				+                    for (int i = 0; i < list_sizes[list]; i++) {
			
 
				+                        quicklistPushTail(ql, genstr("hello TAIL", i + 1), 64);
			
 
				+                        quicklistPushHead(ql, genstr("hello HEAD", i + 1), 64);
			
 
				+                    }
			
 
				+
			
 
				+                    for (int step = 0; step < 2; step++) {
			
 
				+                        /* test remove node */
			
 
				+                        if (step == 1) {
			
 
				+                            for (int i = 0; i < list_sizes[list] / 2; i++) {
			
 
				+                                unsigned char *data;
			
 
				+                                assert(quicklistPop(ql, QUICKLIST_HEAD, &data,
			
 
				+                                                    NULL, NULL));
			
 
				+                                zfree(data);
			
 
				+                                assert(quicklistPop(ql, QUICKLIST_TAIL, &data,
			
 
				+                                                    NULL, NULL));
			
 
				+                                zfree(data);
			
 
				+                            }
			
 
				+                        }
			
 
				+                        quicklistNode *node = ql->head;
			
 
				+                        unsigned int low_raw = ql->compress;
			
 
				+                        unsigned int high_raw = ql->len - ql->compress;
			
 
				+
			
 
				+                        for (unsigned int at = 0; at < ql->len;
			
 
				+                            at++, node = node->next) {
			
 
				+                            if (at < low_raw || at >= high_raw) {
			
 
				+                                if (node->encoding != QUICKLIST_NODE_ENCODING_RAW) {
			
 
				+                                    ERR("Incorrect compression: node %d is "
			
 
				+                                        "compressed at depth %d ((%u, %u); total "
			
 
				+                                        "nodes: %lu; size: %zu)",
			
 
				+                                        at, depth, low_raw, high_raw, ql->len,
			
 
				+                                        node->sz);
			
 
				+                                }
			
 
				+                            } else {
			
 
				+                                if (node->encoding != QUICKLIST_NODE_ENCODING_LZF) {
			
 
				+                                    ERR("Incorrect non-compression: node %d is NOT "
			
 
				+                                        "compressed at depth %d ((%u, %u); total "
			
 
				+                                        "nodes: %lu; size: %zu; attempted: %d)",
			
 
				+                                        at, depth, low_raw, high_raw, ql->len,
			
 
				+                                        node->sz, node->attempted_compress);
			
 
				+                                }
			
 
				+                            }
			
 
				+                        }
			
 
				+                    }
			
 
				+
			
 
				+                    quicklistRelease(ql);
			
 
				+                }
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    long long stop = mstime();
			
 
				+
			
 
				+    printf("\n");
			
 
				+    for (size_t i = 0; i < option_count; i++)
			
 
				+        printf("Test Loop %02d: %0.2f seconds.\n", options[i],
			
 
				+               (float)runtime[i] / 1000);
			
 
				+    printf("Compressions: %0.2f seconds.\n", (float)(stop - start) / 1000);
			
 
				+    printf("\n");
			
 
				+
			
 
				+    TEST("bookmark get updated to next item") {
			
 
				+        quicklist *ql = quicklistNew(1, 0);
			
 
				+        quicklistPushTail(ql, "1", 1);
			
 
				+        quicklistPushTail(ql, "2", 1);
			
 
				+        quicklistPushTail(ql, "3", 1);
			
 
				+        quicklistPushTail(ql, "4", 1);
			
 
				+        quicklistPushTail(ql, "5", 1);
			
 
				+        assert(ql->len==5);
			
 
				+        /* add two bookmarks, one pointing to the node before the last. */
			
 
				+        assert(quicklistBookmarkCreate(&ql, "_dummy", ql->head->next));
			
 
				+        assert(quicklistBookmarkCreate(&ql, "_test", ql->tail->prev));
			
 
				+        /* test that the bookmark returns the right node, delete it and see that the bookmark points to the last node */
			
 
				+        assert(quicklistBookmarkFind(ql, "_test") == ql->tail->prev);
			
 
				+        assert(quicklistDelRange(ql, -2, 1));
			
 
				+        assert(quicklistBookmarkFind(ql, "_test") == ql->tail);
			
 
				+        /* delete the last node, and see that the bookmark was deleted. */
			
 
				+        assert(quicklistDelRange(ql, -1, 1));
			
 
				+        assert(quicklistBookmarkFind(ql, "_test") == NULL);
			
 
				+        /* test that other bookmarks aren't affected */
			
 
				+        assert(quicklistBookmarkFind(ql, "_dummy") == ql->head->next);
			
 
				+        assert(quicklistBookmarkFind(ql, "_missing") == NULL);
			
 
				+        assert(ql->len==3);
			
 
				+        quicklistBookmarksClear(ql); /* for coverage */
			
 
				+        assert(quicklistBookmarkFind(ql, "_dummy") == NULL);
			
 
				+        quicklistRelease(ql);
			
 
				+    }
			
 
				+
			
 
				+    TEST("bookmark limit") {
			
 
				+        int i;
			
 
				+        quicklist *ql = quicklistNew(1, 0);
			
 
				+        quicklistPushHead(ql, "1", 1);
			
 
				+        for (i=0; i<QL_MAX_BM; i++)
			
 
				+            assert(quicklistBookmarkCreate(&ql, genstr("",i), ql->head));
			
 
				+        /* when all bookmarks are used, creation fails */
			
 
				+        assert(!quicklistBookmarkCreate(&ql, "_test", ql->head));
			
 
				+        /* delete one and see that we can now create another */
			
 
				+        assert(quicklistBookmarkDelete(ql, "0"));
			
 
				+        assert(quicklistBookmarkCreate(&ql, "_test", ql->head));
			
 
				+        /* delete one and see that the rest survive */
			
 
				+        assert(quicklistBookmarkDelete(ql, "_test"));
			
 
				+        for (i=1; i<QL_MAX_BM; i++)
			
 
				+            assert(quicklistBookmarkFind(ql, genstr("",i)) == ql->head);
			
 
				+        /* make sure the deleted ones are indeed gone */
			
 
				+        assert(!quicklistBookmarkFind(ql, "0"));
			
 
				+        assert(!quicklistBookmarkFind(ql, "_test"));
			
 
				+        quicklistRelease(ql);
			
 
				+    }
			
 
				+
			
 
				+    if (flags & REDIS_TEST_LARGE_MEMORY) {
			
 
				+        TEST("compress and decompress quicklist listpack node") {
			
 
				+            quicklistNode *node = quicklistCreateNode();
			
 
				+            node->entry = lpNew(0);
			
 
				+            
			
 
				+            /* Create a rand string */
			
 
				+            size_t sz = (1 << 25); /* 32MB per one entry */
			
 
				+            unsigned char *s = zmalloc(sz);
			
 
				+            randstring(s, sz);
			
 
				+
			
 
				+            /* Keep filling the node, until it reaches 1GB */
			
 
				+            for (int i = 0; i < 32; i++) {
			
 
				+                node->entry = lpAppend(node->entry, s, sz);
			
 
				+                quicklistNodeUpdateSz(node);
			
 
				+
			
 
				+                long long start = mstime();
			
 
				+                assert(__quicklistCompressNode(node));
			
 
				+                assert(__quicklistDecompressNode(node));
			
 
				+                printf("Compress and decompress: %zu MB in %.2f seconds.\n",
			
 
				+                       node->sz/1024/1024, (float)(mstime() - start) / 1000);
			
 
				+            }
			
 
				+
			
 
				+            zfree(s);
			
 
				+            zfree(node->entry);
			
 
				+            zfree(node);
			
 
				+        }
			
 
				+
			
 
				+#if ULONG_MAX >= 0xffffffffffffffff
			
 
				+        TEST("compress and decomress quicklist plain node large than UINT32_MAX") {
			
 
				+            size_t sz = (1ull << 32);
			
 
				+            unsigned char *s = zmalloc(sz);
			
 
				+            randstring(s, sz);
			
 
				+            memcpy(s, "helloworld", 10);
			
 
				+            memcpy(s + sz - 10, "1234567890", 10);
			
 
				+
			
 
				+            quicklistNode *node = __quicklistCreatePlainNode(s, sz);
			
 
				+
			
 
				+            long long start = mstime();
			
 
				+            assert(__quicklistCompressNode(node));
			
 
				+            assert(__quicklistDecompressNode(node));
			
 
				+            printf("Compress and decompress: %zu MB in %.2f seconds.\n",
			
 
				+                   node->sz/1024/1024, (float)(mstime() - start) / 1000);
			
 
				+
			
 
				+            assert(memcmp(node->entry, "helloworld", 10) == 0);
			
 
				+            assert(memcmp(node->entry + sz - 10, "1234567890", 10) == 0);
			
 
				+            zfree(node->entry);
			
 
				+            zfree(node);
			
 
				+        }
			
 
				+#endif
			
 
				+    }
			
 
				+
			
 
				+    if (!err)
			
 
				+        printf("ALL TESTS PASSED!\n");
			
 
				+    else
			
 
				+        ERR("Sorry, not all tests passed!  In fact, %d tests failed.", err);
			
 
				+
			
 
				+    return err;
			
 
				+}
			
 
				+#endif
			
--- a/src/quicklist.h
+++ b/src/quicklist.h
@@ -0,0 +1,211 @@
 
				+/* quicklist.h - A generic doubly linked quicklist implementation
			
 
				+ *
			
 
				+ * Copyright (c) 2014, Matt Stancliff <matt@genges.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 quicklist of conditions and the following disclaimer.
			
 
				+ *   * Redistributions in binary form must reproduce the above copyright
			
 
				+ *     notice, this quicklist 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdint.h> // for UINTPTR_MAX
			
 
				+
			
 
				+#ifndef __QUICKLIST_H__
			
 
				+#define __QUICKLIST_H__
			
 
				+
			
 
				+/* Node, quicklist, and Iterator are the only data structures used currently. */
			
 
				+
			
 
				+/* quicklistNode is a 32 byte struct describing a listpack for a quicklist.
			
 
				+ * We use bit fields keep the quicklistNode at 32 bytes.
			
 
				+ * count: 16 bits, max 65536 (max lp bytes is 65k, so max count actually < 32k).
			
 
				+ * encoding: 2 bits, RAW=1, LZF=2.
			
 
				+ * container: 2 bits, PLAIN=1, PACKED=2.
			
 
				+ * recompress: 1 bit, bool, true if node is temporary decompressed for usage.
			
 
				+ * attempted_compress: 1 bit, boolean, used for verifying during testing.
			
 
				+ * extra: 10 bits, free for future use; pads out the remainder of 32 bits */
			
 
				+typedef struct quicklistNode {
			
 
				+    struct quicklistNode *prev;
			
 
				+    struct quicklistNode *next;
			
 
				+    unsigned char *entry;
			
 
				+    size_t sz;             /* entry size in bytes */
			
 
				+    unsigned int count : 16;     /* count of items in listpack */
			
 
				+    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */
			
 
				+    unsigned int container : 2;  /* PLAIN==1 or PACKED==2 */
			
 
				+    unsigned int recompress : 1; /* was this node previous compressed? */
			
 
				+    unsigned int attempted_compress : 1; /* node can't compress; too small */
			
 
				+    unsigned int extra : 10; /* more bits to steal for future usage */
			
 
				+} quicklistNode;
			
 
				+
			
 
				+/* quicklistLZF is a 8+N byte struct holding 'sz' followed by 'compressed'.
			
 
				+ * 'sz' is byte length of 'compressed' field.
			
 
				+ * 'compressed' is LZF data with total (compressed) length 'sz'
			
 
				+ * NOTE: uncompressed length is stored in quicklistNode->sz.
			
 
				+ * When quicklistNode->entry is compressed, node->entry points to a quicklistLZF */
			
 
				+typedef struct quicklistLZF {
			
 
				+    size_t sz; /* LZF size in bytes*/
			
 
				+    char compressed[];
			
 
				+} quicklistLZF;
			
 
				+
			
 
				+/* Bookmarks are padded with realloc at the end of of the quicklist struct.
			
 
				+ * They should only be used for very big lists if thousands of nodes were the
			
 
				+ * excess memory usage is negligible, and there's a real need to iterate on them
			
 
				+ * in portions.
			
 
				+ * When not used, they don't add any memory overhead, but when used and then
			
 
				+ * deleted, some overhead remains (to avoid resonance).
			
 
				+ * The number of bookmarks used should be kept to minimum since it also adds
			
 
				+ * overhead on node deletion (searching for a bookmark to update). */
			
 
				+typedef struct quicklistBookmark {
			
 
				+    quicklistNode *node;
			
 
				+    char *name;
			
 
				+} quicklistBookmark;
			
 
				+
			
 
				+#if UINTPTR_MAX == 0xffffffff
			
 
				+/* 32-bit */
			
 
				+#   define QL_FILL_BITS 14
			
 
				+#   define QL_COMP_BITS 14
			
 
				+#   define QL_BM_BITS 4
			
 
				+#elif UINTPTR_MAX == 0xffffffffffffffff
			
 
				+/* 64-bit */
			
 
				+#   define QL_FILL_BITS 16
			
 
				+#   define QL_COMP_BITS 16
			
 
				+#   define QL_BM_BITS 4 /* we can encode more, but we rather limit the user
			
 
				+                           since they cause performance degradation. */
			
 
				+#else
			
 
				+#   error unknown arch bits count
			
 
				+#endif
			
 
				+
			
 
				+/* quicklist is a 40 byte struct (on 64-bit systems) describing a quicklist.
			
 
				+ * 'count' is the number of total entries.
			
 
				+ * 'len' is the number of quicklist nodes.
			
 
				+ * 'compress' is: 0 if compression disabled, otherwise it's the number
			
 
				+ *                of quicklistNodes to leave uncompressed at ends of quicklist.
			
 
				+ * 'fill' is the user-requested (or default) fill factor.
			
 
				+ * 'bookmarks are an optional feature that is used by realloc this struct,
			
 
				+ *      so that they don't consume memory when not used. */
			
 
				+typedef struct quicklist {
			
 
				+    quicklistNode *head;
			
 
				+    quicklistNode *tail;
			
 
				+    unsigned long count;        /* total count of all entries in all listpacks */
			
 
				+    unsigned long len;          /* number of quicklistNodes */
			
 
				+    int fill : QL_FILL_BITS;              /* fill factor for individual nodes */
			
 
				+    unsigned int compress : QL_COMP_BITS; /* depth of end nodes not to compress;0=off */
			
 
				+    unsigned int bookmark_count: QL_BM_BITS;
			
 
				+    quicklistBookmark bookmarks[];
			
 
				+} quicklist;
			
 
				+
			
 
				+typedef struct quicklistIter {
			
 
				+    quicklist *quicklist;
			
 
				+    quicklistNode *current;
			
 
				+    unsigned char *zi;
			
 
				+    long offset; /* offset in current listpack */
			
 
				+    int direction;
			
 
				+} quicklistIter;
			
 
				+
			
 
				+typedef struct quicklistEntry {
			
 
				+    const quicklist *quicklist;
			
 
				+    quicklistNode *node;
			
 
				+    unsigned char *zi;
			
 
				+    unsigned char *value;
			
 
				+    long long longval;
			
 
				+    size_t sz;
			
 
				+    int offset;
			
 
				+} quicklistEntry;
			
 
				+
			
 
				+#define QUICKLIST_HEAD 0
			
 
				+#define QUICKLIST_TAIL -1
			
 
				+
			
 
				+/* quicklist node encodings */
			
 
				+#define QUICKLIST_NODE_ENCODING_RAW 1
			
 
				+#define QUICKLIST_NODE_ENCODING_LZF 2
			
 
				+
			
 
				+/* quicklist compression disable */
			
 
				+#define QUICKLIST_NOCOMPRESS 0
			
 
				+
			
 
				+/* quicklist container formats */
			
 
				+#define QUICKLIST_NODE_CONTAINER_PLAIN 1
			
 
				+#define QUICKLIST_NODE_CONTAINER_PACKED 2
			
 
				+
			
 
				+#define QL_NODE_IS_PLAIN(node) ((node)->container == QUICKLIST_NODE_CONTAINER_PLAIN)
			
 
				+
			
 
				+#define quicklistNodeIsCompressed(node)                                        \
			
 
				+    ((node)->encoding == QUICKLIST_NODE_ENCODING_LZF)
			
 
				+
			
 
				+/* Prototypes */
			
 
				+quicklist *quicklistCreate(void);
			
 
				+quicklist *quicklistNew(int fill, int compress);
			
 
				+void quicklistSetCompressDepth(quicklist *quicklist, int depth);
			
 
				+void quicklistSetFill(quicklist *quicklist, int fill);
			
 
				+void quicklistSetOptions(quicklist *quicklist, int fill, int depth);
			
 
				+void quicklistRelease(quicklist *quicklist);
			
 
				+int quicklistPushHead(quicklist *quicklist, void *value, const size_t sz);
			
 
				+int quicklistPushTail(quicklist *quicklist, void *value, const size_t sz);
			
 
				+void quicklistPush(quicklist *quicklist, void *value, const size_t sz,
			
 
				+                   int where);
			
 
				+void quicklistAppendListpack(quicklist *quicklist, unsigned char *zl);
			
 
				+void quicklistAppendPlainNode(quicklist *quicklist, unsigned char *data, size_t sz);
			
 
				+void quicklistInsertAfter(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                          void *value, const size_t sz);
			
 
				+void quicklistInsertBefore(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                           void *value, const size_t sz);
			
 
				+void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry);
			
 
				+void quicklistReplaceEntry(quicklistIter *iter, quicklistEntry *entry,
			
 
				+                           void *data, size_t sz);
			
 
				+int quicklistReplaceAtIndex(quicklist *quicklist, long index, void *data,
			
 
				+                            const size_t sz);
			
 
				+int quicklistDelRange(quicklist *quicklist, const long start, const long stop);
			
 
				+quicklistIter *quicklistGetIterator(quicklist *quicklist, int direction);
			
 
				+quicklistIter *quicklistGetIteratorAtIdx(quicklist *quicklist,
			
 
				+                                         int direction, const long long idx);
			
 
				+quicklistIter *quicklistGetIteratorEntryAtIdx(quicklist *quicklist, const long long index,
			
 
				+                                              quicklistEntry *entry);
			
 
				+int quicklistNext(quicklistIter *iter, quicklistEntry *entry);
			
 
				+void quicklistSetDirection(quicklistIter *iter, int direction);
			
 
				+void quicklistReleaseIterator(quicklistIter *iter);
			
 
				+quicklist *quicklistDup(quicklist *orig);
			
 
				+void quicklistRotate(quicklist *quicklist);
			
 
				+int quicklistPopCustom(quicklist *quicklist, int where, unsigned char **data,
			
 
				+                       size_t *sz, long long *sval,
			
 
				+                       void *(*saver)(unsigned char *data, size_t sz));
			
 
				+int quicklistPop(quicklist *quicklist, int where, unsigned char **data,
			
 
				+                 size_t *sz, long long *slong);
			
 
				+unsigned long quicklistCount(const quicklist *ql);
			
 
				+int quicklistCompare(quicklistEntry *entry, unsigned char *p2, const size_t p2_len);
			
 
				+size_t quicklistGetLzf(const quicklistNode *node, void **data);
			
 
				+void quicklistRepr(unsigned char *ql, int full);
			
 
				+
			
 
				+/* bookmarks */
			
 
				+int quicklistBookmarkCreate(quicklist **ql_ref, const char *name, quicklistNode *node);
			
 
				+int quicklistBookmarkDelete(quicklist *ql, const char *name);
			
 
				+quicklistNode *quicklistBookmarkFind(quicklist *ql, const char *name);
			
 
				+void quicklistBookmarksClear(quicklist *ql);
			
 
				+int quicklistisSetPackedThreshold(size_t sz);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int quicklistTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+/* Directions for iterators */
			
 
				+#define AL_START_HEAD 0
			
 
				+#define AL_START_TAIL 1
			
 
				+
			
 
				+#endif /* __QUICKLIST_H__ */
			
--- a/src/rand.c
+++ b/src/rand.c
@@ -0,0 +1,93 @@
 
				+/* Pseudo random number generation functions derived from the drand48()
			
 
				+ * function obtained from pysam source code.
			
 
				+ *
			
 
				+ * This functions are used in order to replace the default math.random()
			
 
				+ * Lua implementation with something having exactly the same behavior
			
 
				+ * across different systems (by default Lua uses libc's rand() that is not
			
 
				+ * required to implement a specific PRNG generating the same sequence
			
 
				+ * in different systems if seeded with the same integer).
			
 
				+ *
			
 
				+ * The original code appears to be under the public domain.
			
 
				+ * I modified it removing the non needed functions and all the
			
 
				+ * 1960-style C coding stuff...
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2010-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+#define N	16
			
 
				+#define MASK	((1 << (N - 1)) + (1 << (N - 1)) - 1)
			
 
				+#define LOW(x)	((unsigned)(x) & MASK)
			
 
				+#define HIGH(x)	LOW((x) >> N)
			
 
				+#define MUL(x, y, z)	{ int32_t l = (long)(x) * (long)(y); \
			
 
				+		(z)[0] = LOW(l); (z)[1] = HIGH(l); }
			
 
				+#define CARRY(x, y)	((int32_t)(x) + (long)(y) > MASK)
			
 
				+#define ADDEQU(x, y, z)	(z = CARRY(x, (y)), x = LOW(x + (y)))
			
 
				+#define X0	0x330E
			
 
				+#define X1	0xABCD
			
 
				+#define X2	0x1234
			
 
				+#define A0	0xE66D
			
 
				+#define A1	0xDEEC
			
 
				+#define A2	0x5
			
 
				+#define C	0xB
			
 
				+#define SET3(x, x0, x1, x2)	((x)[0] = (x0), (x)[1] = (x1), (x)[2] = (x2))
			
 
				+#define SETLOW(x, y, n) SET3(x, LOW((y)[n]), LOW((y)[(n)+1]), LOW((y)[(n)+2]))
			
 
				+#define SEED(x0, x1, x2) (SET3(x, x0, x1, x2), SET3(a, A0, A1, A2), c = C)
			
 
				+#define REST(v)	for (i = 0; i < 3; i++) { xsubi[i] = x[i]; x[i] = temp[i]; } \
			
 
				+		return (v);
			
 
				+#define HI_BIT	(1L << (2 * N - 1))
			
 
				+
			
 
				+static uint32_t x[3] = { X0, X1, X2 }, a[3] = { A0, A1, A2 }, c = C;
			
 
				+static void next(void);
			
 
				+
			
 
				+int32_t redisLrand48() {
			
 
				+    next();
			
 
				+    return (((int32_t)x[2] << (N - 1)) + (x[1] >> 1));
			
 
				+}
			
 
				+
			
 
				+void redisSrand48(int32_t seedval) {
			
 
				+    SEED(X0, LOW(seedval), HIGH(seedval));
			
 
				+}
			
 
				+
			
 
				+static void next(void) {
			
 
				+    uint32_t p[2], q[2], r[2], carry0, carry1;
			
 
				+
			
 
				+    MUL(a[0], x[0], p);
			
 
				+    ADDEQU(p[0], c, carry0);
			
 
				+    ADDEQU(p[1], carry0, carry1);
			
 
				+    MUL(a[0], x[1], q);
			
 
				+    ADDEQU(p[1], q[0], carry0);
			
 
				+    MUL(a[1], x[0], r);
			
 
				+    x[2] = LOW(carry0 + carry1 + CARRY(p[1], r[0]) + q[1] + r[1] +
			
 
				+            a[0] * x[2] + a[1] * x[1] + a[2] * x[0]);
			
 
				+    x[1] = LOW(p[1] + r[0]);
			
 
				+    x[0] = LOW(p[0]);
			
 
				+}
			
--- a/src/rand.h
+++ b/src/rand.h
@@ -0,0 +1,38 @@
 
				+/*
			
 
				+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef REDIS_RANDOM_H
			
 
				+#define REDIS_RANDOM_H
			
 
				+
			
 
				+int32_t redisLrand48();
			
 
				+void redisSrand48(int32_t seedval);
			
 
				+
			
 
				+#define REDIS_LRAND48_MAX INT32_MAX
			
 
				+
			
 
				+#endif
			
--- a/src/rax.c
+++ b/src/rax.c
@@ -0,0 +1,1927 @@
 
				+/* Rax -- A radix tree implementation.
			
 
				+ *
			
 
				+ * Version 1.2 -- 7 February 2019
			
 
				+ *
			
 
				+ * Copyright (c) 2017-2019, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+#include <assert.h>
			
 
				+#include <stdio.h>
			
 
				+#include <errno.h>
			
 
				+#include <math.h>
			
 
				+#include "rax.h"
			
 
				+
			
 
				+#ifndef RAX_MALLOC_INCLUDE
			
 
				+#define RAX_MALLOC_INCLUDE "rax_malloc.h"
			
 
				+#endif
			
 
				+
			
 
				+#include RAX_MALLOC_INCLUDE
			
 
				+
			
 
				+/* This is a special pointer that is guaranteed to never have the same value
			
 
				+ * of a radix tree node. It's used in order to report "not found" error without
			
 
				+ * requiring the function to have multiple return values. */
			
 
				+void *raxNotFound = (void*)"rax-not-found-pointer";
			
 
				+
			
 
				+/* -------------------------------- Debugging ------------------------------ */
			
 
				+
			
 
				+void raxDebugShowNode(const char *msg, raxNode *n);
			
 
				+
			
 
				+/* Turn debugging messages on/off by compiling with RAX_DEBUG_MSG macro on.
			
 
				+ * When RAX_DEBUG_MSG is defined by default Rax operations will emit a lot
			
 
				+ * of debugging info to the standard output, however you can still turn
			
 
				+ * debugging on/off in order to enable it only when you suspect there is an
			
 
				+ * operation causing a bug using the function raxSetDebugMsg(). */
			
 
				+#ifdef RAX_DEBUG_MSG
			
 
				+#define debugf(...)                                                            \
			
 
				+    if (raxDebugMsg) {                                                         \
			
 
				+        printf("%s:%s:%d:\t", __FILE__, __func__, __LINE__);                   \
			
 
				+        printf(__VA_ARGS__);                                                   \
			
 
				+        fflush(stdout);                                                        \
			
 
				+    }
			
 
				+
			
 
				+#define debugnode(msg,n) raxDebugShowNode(msg,n)
			
 
				+#else
			
 
				+#define debugf(...)
			
 
				+#define debugnode(msg,n)
			
 
				+#endif
			
 
				+
			
 
				+/* By default log debug info if RAX_DEBUG_MSG is defined. */
			
 
				+static int raxDebugMsg = 1;
			
 
				+
			
 
				+/* When debug messages are enabled, turn them on/off dynamically. By
			
 
				+ * default they are enabled. Set the state to 0 to disable, and 1 to
			
 
				+ * re-enable. */
			
 
				+void raxSetDebugMsg(int onoff) {
			
 
				+    raxDebugMsg = onoff;
			
 
				+}
			
 
				+
			
 
				+/* ------------------------- raxStack functions --------------------------
			
 
				+ * The raxStack is a simple stack of pointers that is capable of switching
			
 
				+ * from using a stack-allocated array to dynamic heap once a given number of
			
 
				+ * items are reached. It is used in order to retain the list of parent nodes
			
 
				+ * while walking the radix tree in order to implement certain operations that
			
 
				+ * need to navigate the tree upward.
			
 
				+ * ------------------------------------------------------------------------- */
			
 
				+
			
 
				+/* Initialize the stack. */
			
 
				+static inline void raxStackInit(raxStack *ts) {
			
 
				+    ts->stack = ts->static_items;
			
 
				+    ts->items = 0;
			
 
				+    ts->maxitems = RAX_STACK_STATIC_ITEMS;
			
 
				+    ts->oom = 0;
			
 
				+}
			
 
				+
			
 
				+/* Push an item into the stack, returns 1 on success, 0 on out of memory. */
			
 
				+static inline int raxStackPush(raxStack *ts, void *ptr) {
			
 
				+    if (ts->items == ts->maxitems) {
			
 
				+        if (ts->stack == ts->static_items) {
			
 
				+            ts->stack = rax_malloc(sizeof(void*)*ts->maxitems*2);
			
 
				+            if (ts->stack == NULL) {
			
 
				+                ts->stack = ts->static_items;
			
 
				+                ts->oom = 1;
			
 
				+                errno = ENOMEM;
			
 
				+                return 0;
			
 
				+            }
			
 
				+            memcpy(ts->stack,ts->static_items,sizeof(void*)*ts->maxitems);
			
 
				+        } else {
			
 
				+            void **newalloc = rax_realloc(ts->stack,sizeof(void*)*ts->maxitems*2);
			
 
				+            if (newalloc == NULL) {
			
 
				+                ts->oom = 1;
			
 
				+                errno = ENOMEM;
			
 
				+                return 0;
			
 
				+            }
			
 
				+            ts->stack = newalloc;
			
 
				+        }
			
 
				+        ts->maxitems *= 2;
			
 
				+    }
			
 
				+    ts->stack[ts->items] = ptr;
			
 
				+    ts->items++;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Pop an item from the stack, the function returns NULL if there are no
			
 
				+ * items to pop. */
			
 
				+static inline void *raxStackPop(raxStack *ts) {
			
 
				+    if (ts->items == 0) return NULL;
			
 
				+    ts->items--;
			
 
				+    return ts->stack[ts->items];
			
 
				+}
			
 
				+
			
 
				+/* Return the stack item at the top of the stack without actually consuming
			
 
				+ * it. */
			
 
				+static inline void *raxStackPeek(raxStack *ts) {
			
 
				+    if (ts->items == 0) return NULL;
			
 
				+    return ts->stack[ts->items-1];
			
 
				+}
			
 
				+
			
 
				+/* Free the stack in case we used heap allocation. */
			
 
				+static inline void raxStackFree(raxStack *ts) {
			
 
				+    if (ts->stack != ts->static_items) rax_free(ts->stack);
			
 
				+}
			
 
				+
			
 
				+/* ----------------------------------------------------------------------------
			
 
				+ * Radix tree implementation
			
 
				+ * --------------------------------------------------------------------------*/
			
 
				+
			
 
				+/* Return the padding needed in the characters section of a node having size
			
 
				+ * 'nodesize'. The padding is needed to store the child pointers to aligned
			
 
				+ * addresses. Note that we add 4 to the node size because the node has a four
			
 
				+ * bytes header. */
			
 
				+#define raxPadding(nodesize) ((sizeof(void*)-((nodesize+4) % sizeof(void*))) & (sizeof(void*)-1))
			
 
				+
			
 
				+/* Return the pointer to the last child pointer in a node. For the compressed
			
 
				+ * nodes this is the only child pointer. */
			
 
				+#define raxNodeLastChildPtr(n) ((raxNode**) ( \
			
 
				+    ((char*)(n)) + \
			
 
				+    raxNodeCurrentLength(n) - \
			
 
				+    sizeof(raxNode*) - \
			
 
				+    (((n)->iskey && !(n)->isnull) ? sizeof(void*) : 0) \
			
 
				+))
			
 
				+
			
 
				+/* Return the pointer to the first child pointer. */
			
 
				+#define raxNodeFirstChildPtr(n) ((raxNode**) ( \
			
 
				+    (n)->data + \
			
 
				+    (n)->size + \
			
 
				+    raxPadding((n)->size)))
			
 
				+
			
 
				+/* Return the current total size of the node. Note that the second line
			
 
				+ * computes the padding after the string of characters, needed in order to
			
 
				+ * save pointers to aligned addresses. */
			
 
				+#define raxNodeCurrentLength(n) ( \
			
 
				+    sizeof(raxNode)+(n)->size+ \
			
 
				+    raxPadding((n)->size)+ \
			
 
				+    ((n)->iscompr ? sizeof(raxNode*) : sizeof(raxNode*)*(n)->size)+ \
			
 
				+    (((n)->iskey && !(n)->isnull)*sizeof(void*)) \
			
 
				+)
			
 
				+
			
 
				+/* Allocate a new non compressed node with the specified number of children.
			
 
				+ * If datafield is true, the allocation is made large enough to hold the
			
 
				+ * associated data pointer.
			
 
				+ * Returns the new node pointer. On out of memory NULL is returned. */
			
 
				+raxNode *raxNewNode(size_t children, int datafield) {
			
 
				+    size_t nodesize = sizeof(raxNode)+children+raxPadding(children)+
			
 
				+                      sizeof(raxNode*)*children;
			
 
				+    if (datafield) nodesize += sizeof(void*);
			
 
				+    raxNode *node = rax_malloc(nodesize);
			
 
				+    if (node == NULL) return NULL;
			
 
				+    node->iskey = 0;
			
 
				+    node->isnull = 0;
			
 
				+    node->iscompr = 0;
			
 
				+    node->size = children;
			
 
				+    return node;
			
 
				+}
			
 
				+
			
 
				+/* Allocate a new rax and return its pointer. On out of memory the function
			
 
				+ * returns NULL. */
			
 
				+rax *raxNew(void) {
			
 
				+    rax *rax = rax_malloc(sizeof(*rax));
			
 
				+    if (rax == NULL) return NULL;
			
 
				+    rax->numele = 0;
			
 
				+    rax->numnodes = 1;
			
 
				+    rax->head = raxNewNode(0,0);
			
 
				+    if (rax->head == NULL) {
			
 
				+        rax_free(rax);
			
 
				+        return NULL;
			
 
				+    } else {
			
 
				+        return rax;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* realloc the node to make room for auxiliary data in order
			
 
				+ * to store an item in that node. On out of memory NULL is returned. */
			
 
				+raxNode *raxReallocForData(raxNode *n, void *data) {
			
 
				+    if (data == NULL) return n; /* No reallocation needed, setting isnull=1 */
			
 
				+    size_t curlen = raxNodeCurrentLength(n);
			
 
				+    return rax_realloc(n,curlen+sizeof(void*));
			
 
				+}
			
 
				+
			
 
				+/* Set the node auxiliary data to the specified pointer. */
			
 
				+void raxSetData(raxNode *n, void *data) {
			
 
				+    n->iskey = 1;
			
 
				+    if (data != NULL) {
			
 
				+        n->isnull = 0;
			
 
				+        void **ndata = (void**)
			
 
				+            ((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
			
 
				+        memcpy(ndata,&data,sizeof(data));
			
 
				+    } else {
			
 
				+        n->isnull = 1;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Get the node auxiliary data. */
			
 
				+void *raxGetData(raxNode *n) {
			
 
				+    if (n->isnull) return NULL;
			
 
				+    void **ndata =(void**)((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
			
 
				+    void *data;
			
 
				+    memcpy(&data,ndata,sizeof(data));
			
 
				+    return data;
			
 
				+}
			
 
				+
			
 
				+/* Add a new child to the node 'n' representing the character 'c' and return
			
 
				+ * its new pointer, as well as the child pointer by reference. Additionally
			
 
				+ * '***parentlink' is populated with the raxNode pointer-to-pointer of where
			
 
				+ * the new child was stored, which is useful for the caller to replace the
			
 
				+ * child pointer if it gets reallocated.
			
 
				+ *
			
 
				+ * On success the new parent node pointer is returned (it may change because
			
 
				+ * of the realloc, so the caller should discard 'n' and use the new value).
			
 
				+ * On out of memory NULL is returned, and the old node is still valid. */
			
 
				+raxNode *raxAddChild(raxNode *n, unsigned char c, raxNode **childptr, raxNode ***parentlink) {
			
 
				+    assert(n->iscompr == 0);
			
 
				+
			
 
				+    size_t curlen = raxNodeCurrentLength(n);
			
 
				+    n->size++;
			
 
				+    size_t newlen = raxNodeCurrentLength(n);
			
 
				+    n->size--; /* For now restore the original size. We'll update it only on
			
 
				+                  success at the end. */
			
 
				+
			
 
				+    /* Alloc the new child we will link to 'n'. */
			
 
				+    raxNode *child = raxNewNode(0,0);
			
 
				+    if (child == NULL) return NULL;
			
 
				+
			
 
				+    /* Make space in the original node. */
			
 
				+    raxNode *newn = rax_realloc(n,newlen);
			
 
				+    if (newn == NULL) {
			
 
				+        rax_free(child);
			
 
				+        return NULL;
			
 
				+    }
			
 
				+    n = newn;
			
 
				+
			
 
				+    /* After the reallocation, we have up to 8/16 (depending on the system
			
 
				+     * pointer size, and the required node padding) bytes at the end, that is,
			
 
				+     * the additional char in the 'data' section, plus one pointer to the new
			
 
				+     * child, plus the padding needed in order to store addresses into aligned
			
 
				+     * locations.
			
 
				+     *
			
 
				+     * So if we start with the following node, having "abde" edges.
			
 
				+     *
			
 
				+     * Note:
			
 
				+     * - We assume 4 bytes pointer for simplicity.
			
 
				+     * - Each space below corresponds to one byte
			
 
				+     *
			
 
				+     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr]|AUXP|
			
 
				+     *
			
 
				+     * After the reallocation we need: 1 byte for the new edge character
			
 
				+     * plus 4 bytes for a new child pointer (assuming 32 bit machine).
			
 
				+     * However after adding 1 byte to the edge char, the header + the edge
			
 
				+     * characters are no longer aligned, so we also need 3 bytes of padding.
			
 
				+     * In total the reallocation will add 1+4+3 bytes = 8 bytes:
			
 
				+     *
			
 
				+     * (Blank bytes are represented by ".")
			
 
				+     *
			
 
				+     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr]|AUXP|[....][....]
			
 
				+     *
			
 
				+     * Let's find where to insert the new child in order to make sure
			
 
				+     * it is inserted in-place lexicographically. Assuming we are adding
			
 
				+     * a child "c" in our case pos will be = 2 after the end of the following
			
 
				+     * loop. */
			
 
				+    int pos;
			
 
				+    for (pos = 0; pos < n->size; pos++) {
			
 
				+        if (n->data[pos] > c) break;
			
 
				+    }
			
 
				+
			
 
				+    /* Now, if present, move auxiliary data pointer at the end
			
 
				+     * so that we can mess with the other data without overwriting it.
			
 
				+     * We will obtain something like that:
			
 
				+     *
			
 
				+     * [HDR*][abde][Aptr][Bptr][Dptr][Eptr][....][....]|AUXP|
			
 
				+     */
			
 
				+    unsigned char *src, *dst;
			
 
				+    if (n->iskey && !n->isnull) {
			
 
				+        src = ((unsigned char*)n+curlen-sizeof(void*));
			
 
				+        dst = ((unsigned char*)n+newlen-sizeof(void*));
			
 
				+        memmove(dst,src,sizeof(void*));
			
 
				+    }
			
 
				+
			
 
				+    /* Compute the "shift", that is, how many bytes we need to move the
			
 
				+     * pointers section forward because of the addition of the new child
			
 
				+     * byte in the string section. Note that if we had no padding, that
			
 
				+     * would be always "1", since we are adding a single byte in the string
			
 
				+     * section of the node (where now there is "abde" basically).
			
 
				+     *
			
 
				+     * However we have padding, so it could be zero, or up to 8.
			
 
				+     *
			
 
				+     * Another way to think at the shift is, how many bytes we need to
			
 
				+     * move child pointers forward *other than* the obvious sizeof(void*)
			
 
				+     * needed for the additional pointer itself. */
			
 
				+    size_t shift = newlen - curlen - sizeof(void*);
			
 
				+
			
 
				+    /* We said we are adding a node with edge 'c'. The insertion
			
 
				+     * point is between 'b' and 'd', so the 'pos' variable value is
			
 
				+     * the index of the first child pointer that we need to move forward
			
 
				+     * to make space for our new pointer.
			
 
				+     *
			
 
				+     * To start, move all the child pointers after the insertion point
			
 
				+     * of shift+sizeof(pointer) bytes on the right, to obtain:
			
 
				+     *
			
 
				+     * [HDR*][abde][Aptr][Bptr][....][....][Dptr][Eptr]|AUXP|
			
 
				+     */
			
 
				+    src = n->data+n->size+
			
 
				+          raxPadding(n->size)+
			
 
				+          sizeof(raxNode*)*pos;
			
 
				+    memmove(src+shift+sizeof(raxNode*),src,sizeof(raxNode*)*(n->size-pos));
			
 
				+
			
 
				+    /* Move the pointers to the left of the insertion position as well. Often
			
 
				+     * we don't need to do anything if there was already some padding to use. In
			
 
				+     * that case the final destination of the pointers will be the same, however
			
 
				+     * in our example there was no pre-existing padding, so we added one byte
			
 
				+     * plus there bytes of padding. After the next memmove() things will look
			
 
				+     * like that:
			
 
				+     *
			
 
				+     * [HDR*][abde][....][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
			
 
				+     */
			
 
				+    if (shift) {
			
 
				+        src = (unsigned char*) raxNodeFirstChildPtr(n);
			
 
				+        memmove(src+shift,src,sizeof(raxNode*)*pos);
			
 
				+    }
			
 
				+
			
 
				+    /* Now make the space for the additional char in the data section,
			
 
				+     * but also move the pointers before the insertion point to the right
			
 
				+     * by shift bytes, in order to obtain the following:
			
 
				+     *
			
 
				+     * [HDR*][ab.d][e...][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
			
 
				+     */
			
 
				+    src = n->data+pos;
			
 
				+    memmove(src+1,src,n->size-pos);
			
 
				+
			
 
				+    /* We can now set the character and its child node pointer to get:
			
 
				+     *
			
 
				+     * [HDR*][abcd][e...][Aptr][Bptr][....][Dptr][Eptr]|AUXP|
			
 
				+     * [HDR*][abcd][e...][Aptr][Bptr][Cptr][Dptr][Eptr]|AUXP|
			
 
				+     */
			
 
				+    n->data[pos] = c;
			
 
				+    n->size++;
			
 
				+    src = (unsigned char*) raxNodeFirstChildPtr(n);
			
 
				+    raxNode **childfield = (raxNode**)(src+sizeof(raxNode*)*pos);
			
 
				+    memcpy(childfield,&child,sizeof(child));
			
 
				+    *childptr = child;
			
 
				+    *parentlink = childfield;
			
 
				+    return n;
			
 
				+}
			
 
				+
			
 
				+/* Turn the node 'n', that must be a node without any children, into a
			
 
				+ * compressed node representing a set of nodes linked one after the other
			
 
				+ * and having exactly one child each. The node can be a key or not: this
			
 
				+ * property and the associated value if any will be preserved.
			
 
				+ *
			
 
				+ * The function also returns a child node, since the last node of the
			
 
				+ * compressed chain cannot be part of the chain: it has zero children while
			
 
				+ * we can only compress inner nodes with exactly one child each. */
			
 
				+raxNode *raxCompressNode(raxNode *n, unsigned char *s, size_t len, raxNode **child) {
			
 
				+    assert(n->size == 0 && n->iscompr == 0);
			
 
				+    void *data = NULL; /* Initialized only to avoid warnings. */
			
 
				+    size_t newsize;
			
 
				+
			
 
				+    debugf("Compress node: %.*s\n", (int)len,s);
			
 
				+
			
 
				+    /* Allocate the child to link to this node. */
			
 
				+    *child = raxNewNode(0,0);
			
 
				+    if (*child == NULL) return NULL;
			
 
				+
			
 
				+    /* Make space in the parent node. */
			
 
				+    newsize = sizeof(raxNode)+len+raxPadding(len)+sizeof(raxNode*);
			
 
				+    if (n->iskey) {
			
 
				+        data = raxGetData(n); /* To restore it later. */
			
 
				+        if (!n->isnull) newsize += sizeof(void*);
			
 
				+    }
			
 
				+    raxNode *newn = rax_realloc(n,newsize);
			
 
				+    if (newn == NULL) {
			
 
				+        rax_free(*child);
			
 
				+        return NULL;
			
 
				+    }
			
 
				+    n = newn;
			
 
				+
			
 
				+    n->iscompr = 1;
			
 
				+    n->size = len;
			
 
				+    memcpy(n->data,s,len);
			
 
				+    if (n->iskey) raxSetData(n,data);
			
 
				+    raxNode **childfield = raxNodeLastChildPtr(n);
			
 
				+    memcpy(childfield,child,sizeof(*child));
			
 
				+    return n;
			
 
				+}
			
 
				+
			
 
				+/* Low level function that walks the tree looking for the string
			
 
				+ * 's' of 'len' bytes. The function returns the number of characters
			
 
				+ * of the key that was possible to process: if the returned integer
			
 
				+ * is the same as 'len', then it means that the node corresponding to the
			
 
				+ * string was found (however it may not be a key in case the node->iskey is
			
 
				+ * zero or if simply we stopped in the middle of a compressed node, so that
			
 
				+ * 'splitpos' is non zero).
			
 
				+ *
			
 
				+ * Otherwise if the returned integer is not the same as 'len', there was an
			
 
				+ * early stop during the tree walk because of a character mismatch.
			
 
				+ *
			
 
				+ * The node where the search ended (because the full string was processed
			
 
				+ * or because there was an early stop) is returned by reference as
			
 
				+ * '*stopnode' if the passed pointer is not NULL. This node link in the
			
 
				+ * parent's node is returned as '*plink' if not NULL. Finally, if the
			
 
				+ * search stopped in a compressed node, '*splitpos' returns the index
			
 
				+ * inside the compressed node where the search ended. This is useful to
			
 
				+ * know where to split the node for insertion.
			
 
				+ *
			
 
				+ * Note that when we stop in the middle of a compressed node with
			
 
				+ * a perfect match, this function will return a length equal to the
			
 
				+ * 'len' argument (all the key matched), and will return a *splitpos which is
			
 
				+ * always positive (that will represent the index of the character immediately
			
 
				+ * *after* the last match in the current compressed node).
			
 
				+ *
			
 
				+ * When instead we stop at a compressed node and *splitpos is zero, it
			
 
				+ * means that the current node represents the key (that is, none of the
			
 
				+ * compressed node characters are needed to represent the key, just all
			
 
				+ * its parents nodes). */
			
 
				+static inline size_t raxLowWalk(rax *rax, unsigned char *s, size_t len, raxNode **stopnode, raxNode ***plink, int *splitpos, raxStack *ts) {
			
 
				+    raxNode *h = rax->head;
			
 
				+    raxNode **parentlink = &rax->head;
			
 
				+
			
 
				+    size_t i = 0; /* Position in the string. */
			
 
				+    size_t j = 0; /* Position in the node children (or bytes if compressed).*/
			
 
				+    while(h->size && i < len) {
			
 
				+        debugnode("Lookup current node",h);
			
 
				+        unsigned char *v = h->data;
			
 
				+
			
 
				+        if (h->iscompr) {
			
 
				+            for (j = 0; j < h->size && i < len; j++, i++) {
			
 
				+                if (v[j] != s[i]) break;
			
 
				+            }
			
 
				+            if (j != h->size) break;
			
 
				+        } else {
			
 
				+            /* Even when h->size is large, linear scan provides good
			
 
				+             * performances compared to other approaches that are in theory
			
 
				+             * more sounding, like performing a binary search. */
			
 
				+            for (j = 0; j < h->size; j++) {
			
 
				+                if (v[j] == s[i]) break;
			
 
				+            }
			
 
				+            if (j == h->size) break;
			
 
				+            i++;
			
 
				+        }
			
 
				+
			
 
				+        if (ts) raxStackPush(ts,h); /* Save stack of parent nodes. */
			
 
				+        raxNode **children = raxNodeFirstChildPtr(h);
			
 
				+        if (h->iscompr) j = 0; /* Compressed node only child is at index 0. */
			
 
				+        memcpy(&h,children+j,sizeof(h));
			
 
				+        parentlink = children+j;
			
 
				+        j = 0; /* If the new node is non compressed and we do not
			
 
				+                  iterate again (since i == len) set the split
			
 
				+                  position to 0 to signal this node represents
			
 
				+                  the searched key. */
			
 
				+    }
			
 
				+    debugnode("Lookup stop node is",h);
			
 
				+    if (stopnode) *stopnode = h;
			
 
				+    if (plink) *plink = parentlink;
			
 
				+    if (splitpos && h->iscompr) *splitpos = j;
			
 
				+    return i;
			
 
				+}
			
 
				+
			
 
				+/* Insert the element 's' of size 'len', setting as auxiliary data
			
 
				+ * the pointer 'data'. If the element is already present, the associated
			
 
				+ * data is updated (only if 'overwrite' is set to 1), and 0 is returned,
			
 
				+ * otherwise the element is inserted and 1 is returned. On out of memory the
			
 
				+ * function returns 0 as well but sets errno to ENOMEM, otherwise errno will
			
 
				+ * be set to 0.
			
 
				+ */
			
 
				+int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old, int overwrite) {
			
 
				+    size_t i;
			
 
				+    int j = 0; /* Split position. If raxLowWalk() stops in a compressed
			
 
				+                  node, the index 'j' represents the char we stopped within the
			
 
				+                  compressed node, that is, the position where to split the
			
 
				+                  node for insertion. */
			
 
				+    raxNode *h, **parentlink;
			
 
				+
			
 
				+    debugf("### Insert %.*s with value %p\n", (int)len, s, data);
			
 
				+    i = raxLowWalk(rax,s,len,&h,&parentlink,&j,NULL);
			
 
				+
			
 
				+    /* If i == len we walked following the whole string. If we are not
			
 
				+     * in the middle of a compressed node, the string is either already
			
 
				+     * inserted or this middle node is currently not a key, but can represent
			
 
				+     * our key. We have just to reallocate the node and make space for the
			
 
				+     * data pointer. */
			
 
				+    if (i == len && (!h->iscompr || j == 0 /* not in the middle if j is 0 */)) {
			
 
				+        debugf("### Insert: node representing key exists\n");
			
 
				+        /* Make space for the value pointer if needed. */
			
 
				+        if (!h->iskey || (h->isnull && overwrite)) {
			
 
				+            h = raxReallocForData(h,data);
			
 
				+            if (h) memcpy(parentlink,&h,sizeof(h));
			
 
				+        }
			
 
				+        if (h == NULL) {
			
 
				+            errno = ENOMEM;
			
 
				+            return 0;
			
 
				+        }
			
 
				+
			
 
				+        /* Update the existing key if there is already one. */
			
 
				+        if (h->iskey) {
			
 
				+            if (old) *old = raxGetData(h);
			
 
				+            if (overwrite) raxSetData(h,data);
			
 
				+            errno = 0;
			
 
				+            return 0; /* Element already exists. */
			
 
				+        }
			
 
				+
			
 
				+        /* Otherwise set the node as a key. Note that raxSetData()
			
 
				+         * will set h->iskey. */
			
 
				+        raxSetData(h,data);
			
 
				+        rax->numele++;
			
 
				+        return 1; /* Element inserted. */
			
 
				+    }
			
 
				+
			
 
				+    /* If the node we stopped at is a compressed node, we need to
			
 
				+     * split it before to continue.
			
 
				+     *
			
 
				+     * Splitting a compressed node have a few possible cases.
			
 
				+     * Imagine that the node 'h' we are currently at is a compressed
			
 
				+     * node containing the string "ANNIBALE" (it means that it represents
			
 
				+     * nodes A -> N -> N -> I -> B -> A -> L -> E with the only child
			
 
				+     * pointer of this node pointing at the 'E' node, because remember that
			
 
				+     * we have characters at the edges of the graph, not inside the nodes
			
 
				+     * themselves.
			
 
				+     *
			
 
				+     * In order to show a real case imagine our node to also point to
			
 
				+     * another compressed node, that finally points at the node without
			
 
				+     * children, representing 'O':
			
 
				+     *
			
 
				+     *     "ANNIBALE" -> "SCO" -> []
			
 
				+     *
			
 
				+     * When inserting we may face the following cases. Note that all the cases
			
 
				+     * require the insertion of a non compressed node with exactly two
			
 
				+     * children, except for the last case which just requires splitting a
			
 
				+     * compressed node.
			
 
				+     *
			
 
				+     * 1) Inserting "ANNIENTARE"
			
 
				+     *
			
 
				+     *               |B| -> "ALE" -> "SCO" -> []
			
 
				+     *     "ANNI" -> |-|
			
 
				+     *               |E| -> (... continue algo ...) "NTARE" -> []
			
 
				+     *
			
 
				+     * 2) Inserting "ANNIBALI"
			
 
				+     *
			
 
				+     *                  |E| -> "SCO" -> []
			
 
				+     *     "ANNIBAL" -> |-|
			
 
				+     *                  |I| -> (... continue algo ...) []
			
 
				+     *
			
 
				+     * 3) Inserting "AGO" (Like case 1, but set iscompr = 0 into original node)
			
 
				+     *
			
 
				+     *            |N| -> "NIBALE" -> "SCO" -> []
			
 
				+     *     |A| -> |-|
			
 
				+     *            |G| -> (... continue algo ...) |O| -> []
			
 
				+     *
			
 
				+     * 4) Inserting "CIAO"
			
 
				+     *
			
 
				+     *     |A| -> "NNIBALE" -> "SCO" -> []
			
 
				+     *     |-|
			
 
				+     *     |C| -> (... continue algo ...) "IAO" -> []
			
 
				+     *
			
 
				+     * 5) Inserting "ANNI"
			
 
				+     *
			
 
				+     *     "ANNI" -> "BALE" -> "SCO" -> []
			
 
				+     *
			
 
				+     * The final algorithm for insertion covering all the above cases is as
			
 
				+     * follows.
			
 
				+     *
			
 
				+     * ============================= ALGO 1 =============================
			
 
				+     *
			
 
				+     * For the above cases 1 to 4, that is, all cases where we stopped in
			
 
				+     * the middle of a compressed node for a character mismatch, do:
			
 
				+     *
			
 
				+     * Let $SPLITPOS be the zero-based index at which, in the
			
 
				+     * compressed node array of characters, we found the mismatching
			
 
				+     * character. For example if the node contains "ANNIBALE" and we add
			
 
				+     * "ANNIENTARE" the $SPLITPOS is 4, that is, the index at which the
			
 
				+     * mismatching character is found.
			
 
				+     *
			
 
				+     * 1. Save the current compressed node $NEXT pointer (the pointer to the
			
 
				+     *    child element, that is always present in compressed nodes).
			
 
				+     *
			
 
				+     * 2. Create "split node" having as child the non common letter
			
 
				+     *    at the compressed node. The other non common letter (at the key)
			
 
				+     *    will be added later as we continue the normal insertion algorithm
			
 
				+     *    at step "6".
			
 
				+     *
			
 
				+     * 3a. IF $SPLITPOS == 0:
			
 
				+     *     Replace the old node with the split node, by copying the auxiliary
			
 
				+     *     data if any. Fix parent's reference. Free old node eventually
			
 
				+     *     (we still need its data for the next steps of the algorithm).
			
 
				+     *
			
 
				+     * 3b. IF $SPLITPOS != 0:
			
 
				+     *     Trim the compressed node (reallocating it as well) in order to
			
 
				+     *     contain $splitpos characters. Change child pointer in order to link
			
 
				+     *     to the split node. If new compressed node len is just 1, set
			
 
				+     *     iscompr to 0 (layout is the same). Fix parent's reference.
			
 
				+     *
			
 
				+     * 4a. IF the postfix len (the length of the remaining string of the
			
 
				+     *     original compressed node after the split character) is non zero,
			
 
				+     *     create a "postfix node". If the postfix node has just one character
			
 
				+     *     set iscompr to 0, otherwise iscompr to 1. Set the postfix node
			
 
				+     *     child pointer to $NEXT.
			
 
				+     *
			
 
				+     * 4b. IF the postfix len is zero, just use $NEXT as postfix pointer.
			
 
				+     *
			
 
				+     * 5. Set child[0] of split node to postfix node.
			
 
				+     *
			
 
				+     * 6. Set the split node as the current node, set current index at child[1]
			
 
				+     *    and continue insertion algorithm as usually.
			
 
				+     *
			
 
				+     * ============================= ALGO 2 =============================
			
 
				+     *
			
 
				+     * For case 5, that is, if we stopped in the middle of a compressed
			
 
				+     * node but no mismatch was found, do:
			
 
				+     *
			
 
				+     * Let $SPLITPOS be the zero-based index at which, in the
			
 
				+     * compressed node array of characters, we stopped iterating because
			
 
				+     * there were no more keys character to match. So in the example of
			
 
				+     * the node "ANNIBALE", adding the string "ANNI", the $SPLITPOS is 4.
			
 
				+     *
			
 
				+     * 1. Save the current compressed node $NEXT pointer (the pointer to the
			
 
				+     *    child element, that is always present in compressed nodes).
			
 
				+     *
			
 
				+     * 2. Create a "postfix node" containing all the characters from $SPLITPOS
			
 
				+     *    to the end. Use $NEXT as the postfix node child pointer.
			
 
				+     *    If the postfix node length is 1, set iscompr to 0.
			
 
				+     *    Set the node as a key with the associated value of the new
			
 
				+     *    inserted key.
			
 
				+     *
			
 
				+     * 3. Trim the current node to contain the first $SPLITPOS characters.
			
 
				+     *    As usually if the new node length is just 1, set iscompr to 0.
			
 
				+     *    Take the iskey / associated value as it was in the original node.
			
 
				+     *    Fix the parent's reference.
			
 
				+     *
			
 
				+     * 4. Set the postfix node as the only child pointer of the trimmed
			
 
				+     *    node created at step 1.
			
 
				+     */
			
 
				+
			
 
				+    /* ------------------------- ALGORITHM 1 --------------------------- */
			
 
				+    if (h->iscompr && i != len) {
			
 
				+        debugf("ALGO 1: Stopped at compressed node %.*s (%p)\n",
			
 
				+            h->size, h->data, (void*)h);
			
 
				+        debugf("Still to insert: %.*s\n", (int)(len-i), s+i);
			
 
				+        debugf("Splitting at %d: '%c'\n", j, ((char*)h->data)[j]);
			
 
				+        debugf("Other (key) letter is '%c'\n", s[i]);
			
 
				+
			
 
				+        /* 1: Save next pointer. */
			
 
				+        raxNode **childfield = raxNodeLastChildPtr(h);
			
 
				+        raxNode *next;
			
 
				+        memcpy(&next,childfield,sizeof(next));
			
 
				+        debugf("Next is %p\n", (void*)next);
			
 
				+        debugf("iskey %d\n", h->iskey);
			
 
				+        if (h->iskey) {
			
 
				+            debugf("key value is %p\n", raxGetData(h));
			
 
				+        }
			
 
				+
			
 
				+        /* Set the length of the additional nodes we will need. */
			
 
				+        size_t trimmedlen = j;
			
 
				+        size_t postfixlen = h->size - j - 1;
			
 
				+        int split_node_is_key = !trimmedlen && h->iskey && !h->isnull;
			
 
				+        size_t nodesize;
			
 
				+
			
 
				+        /* 2: Create the split node. Also allocate the other nodes we'll need
			
 
				+         *    ASAP, so that it will be simpler to handle OOM. */
			
 
				+        raxNode *splitnode = raxNewNode(1, split_node_is_key);
			
 
				+        raxNode *trimmed = NULL;
			
 
				+        raxNode *postfix = NULL;
			
 
				+
			
 
				+        if (trimmedlen) {
			
 
				+            nodesize = sizeof(raxNode)+trimmedlen+raxPadding(trimmedlen)+
			
 
				+                       sizeof(raxNode*);
			
 
				+            if (h->iskey && !h->isnull) nodesize += sizeof(void*);
			
 
				+            trimmed = rax_malloc(nodesize);
			
 
				+        }
			
 
				+
			
 
				+        if (postfixlen) {
			
 
				+            nodesize = sizeof(raxNode)+postfixlen+raxPadding(postfixlen)+
			
 
				+                       sizeof(raxNode*);
			
 
				+            postfix = rax_malloc(nodesize);
			
 
				+        }
			
 
				+
			
 
				+        /* OOM? Abort now that the tree is untouched. */
			
 
				+        if (splitnode == NULL ||
			
 
				+            (trimmedlen && trimmed == NULL) ||
			
 
				+            (postfixlen && postfix == NULL))
			
 
				+        {
			
 
				+            rax_free(splitnode);
			
 
				+            rax_free(trimmed);
			
 
				+            rax_free(postfix);
			
 
				+            errno = ENOMEM;
			
 
				+            return 0;
			
 
				+        }
			
 
				+        splitnode->data[0] = h->data[j];
			
 
				+
			
 
				+        if (j == 0) {
			
 
				+            /* 3a: Replace the old node with the split node. */
			
 
				+            if (h->iskey) {
			
 
				+                void *ndata = raxGetData(h);
			
 
				+                raxSetData(splitnode,ndata);
			
 
				+            }
			
 
				+            memcpy(parentlink,&splitnode,sizeof(splitnode));
			
 
				+        } else {
			
 
				+            /* 3b: Trim the compressed node. */
			
 
				+            trimmed->size = j;
			
 
				+            memcpy(trimmed->data,h->data,j);
			
 
				+            trimmed->iscompr = j > 1 ? 1 : 0;
			
 
				+            trimmed->iskey = h->iskey;
			
 
				+            trimmed->isnull = h->isnull;
			
 
				+            if (h->iskey && !h->isnull) {
			
 
				+                void *ndata = raxGetData(h);
			
 
				+                raxSetData(trimmed,ndata);
			
 
				+            }
			
 
				+            raxNode **cp = raxNodeLastChildPtr(trimmed);
			
 
				+            memcpy(cp,&splitnode,sizeof(splitnode));
			
 
				+            memcpy(parentlink,&trimmed,sizeof(trimmed));
			
 
				+            parentlink = cp; /* Set parentlink to splitnode parent. */
			
 
				+            rax->numnodes++;
			
 
				+        }
			
 
				+
			
 
				+        /* 4: Create the postfix node: what remains of the original
			
 
				+         * compressed node after the split. */
			
 
				+        if (postfixlen) {
			
 
				+            /* 4a: create a postfix node. */
			
 
				+            postfix->iskey = 0;
			
 
				+            postfix->isnull = 0;
			
 
				+            postfix->size = postfixlen;
			
 
				+            postfix->iscompr = postfixlen > 1;
			
 
				+            memcpy(postfix->data,h->data+j+1,postfixlen);
			
 
				+            raxNode **cp = raxNodeLastChildPtr(postfix);
			
 
				+            memcpy(cp,&next,sizeof(next));
			
 
				+            rax->numnodes++;
			
 
				+        } else {
			
 
				+            /* 4b: just use next as postfix node. */
			
 
				+            postfix = next;
			
 
				+        }
			
 
				+
			
 
				+        /* 5: Set splitnode first child as the postfix node. */
			
 
				+        raxNode **splitchild = raxNodeLastChildPtr(splitnode);
			
 
				+        memcpy(splitchild,&postfix,sizeof(postfix));
			
 
				+
			
 
				+        /* 6. Continue insertion: this will cause the splitnode to
			
 
				+         * get a new child (the non common character at the currently
			
 
				+         * inserted key). */
			
 
				+        rax_free(h);
			
 
				+        h = splitnode;
			
 
				+    } else if (h->iscompr && i == len) {
			
 
				+    /* ------------------------- ALGORITHM 2 --------------------------- */
			
 
				+        debugf("ALGO 2: Stopped at compressed node %.*s (%p) j = %d\n",
			
 
				+            h->size, h->data, (void*)h, j);
			
 
				+
			
 
				+        /* Allocate postfix & trimmed nodes ASAP to fail for OOM gracefully. */
			
 
				+        size_t postfixlen = h->size - j;
			
 
				+        size_t nodesize = sizeof(raxNode)+postfixlen+raxPadding(postfixlen)+
			
 
				+                          sizeof(raxNode*);
			
 
				+        if (data != NULL) nodesize += sizeof(void*);
			
 
				+        raxNode *postfix = rax_malloc(nodesize);
			
 
				+
			
 
				+        nodesize = sizeof(raxNode)+j+raxPadding(j)+sizeof(raxNode*);
			
 
				+        if (h->iskey && !h->isnull) nodesize += sizeof(void*);
			
 
				+        raxNode *trimmed = rax_malloc(nodesize);
			
 
				+
			
 
				+        if (postfix == NULL || trimmed == NULL) {
			
 
				+            rax_free(postfix);
			
 
				+            rax_free(trimmed);
			
 
				+            errno = ENOMEM;
			
 
				+            return 0;
			
 
				+        }
			
 
				+
			
 
				+        /* 1: Save next pointer. */
			
 
				+        raxNode **childfield = raxNodeLastChildPtr(h);
			
 
				+        raxNode *next;
			
 
				+        memcpy(&next,childfield,sizeof(next));
			
 
				+
			
 
				+        /* 2: Create the postfix node. */
			
 
				+        postfix->size = postfixlen;
			
 
				+        postfix->iscompr = postfixlen > 1;
			
 
				+        postfix->iskey = 1;
			
 
				+        postfix->isnull = 0;
			
 
				+        memcpy(postfix->data,h->data+j,postfixlen);
			
 
				+        raxSetData(postfix,data);
			
 
				+        raxNode **cp = raxNodeLastChildPtr(postfix);
			
 
				+        memcpy(cp,&next,sizeof(next));
			
 
				+        rax->numnodes++;
			
 
				+
			
 
				+        /* 3: Trim the compressed node. */
			
 
				+        trimmed->size = j;
			
 
				+        trimmed->iscompr = j > 1;
			
 
				+        trimmed->iskey = 0;
			
 
				+        trimmed->isnull = 0;
			
 
				+        memcpy(trimmed->data,h->data,j);
			
 
				+        memcpy(parentlink,&trimmed,sizeof(trimmed));
			
 
				+        if (h->iskey) {
			
 
				+            void *aux = raxGetData(h);
			
 
				+            raxSetData(trimmed,aux);
			
 
				+        }
			
 
				+
			
 
				+        /* Fix the trimmed node child pointer to point to
			
 
				+         * the postfix node. */
			
 
				+        cp = raxNodeLastChildPtr(trimmed);
			
 
				+        memcpy(cp,&postfix,sizeof(postfix));
			
 
				+
			
 
				+        /* Finish! We don't need to continue with the insertion
			
 
				+         * algorithm for ALGO 2. The key is already inserted. */
			
 
				+        rax->numele++;
			
 
				+        rax_free(h);
			
 
				+        return 1; /* Key inserted. */
			
 
				+    }
			
 
				+
			
 
				+    /* We walked the radix tree as far as we could, but still there are left
			
 
				+     * chars in our string. We need to insert the missing nodes. */
			
 
				+    while(i < len) {
			
 
				+        raxNode *child;
			
 
				+
			
 
				+        /* If this node is going to have a single child, and there
			
 
				+         * are other characters, so that that would result in a chain
			
 
				+         * of single-childed nodes, turn it into a compressed node. */
			
 
				+        if (h->size == 0 && len-i > 1) {
			
 
				+            debugf("Inserting compressed node\n");
			
 
				+            size_t comprsize = len-i;
			
 
				+            if (comprsize > RAX_NODE_MAX_SIZE)
			
 
				+                comprsize = RAX_NODE_MAX_SIZE;
			
 
				+            raxNode *newh = raxCompressNode(h,s+i,comprsize,&child);
			
 
				+            if (newh == NULL) goto oom;
			
 
				+            h = newh;
			
 
				+            memcpy(parentlink,&h,sizeof(h));
			
 
				+            parentlink = raxNodeLastChildPtr(h);
			
 
				+            i += comprsize;
			
 
				+        } else {
			
 
				+            debugf("Inserting normal node\n");
			
 
				+            raxNode **new_parentlink;
			
 
				+            raxNode *newh = raxAddChild(h,s[i],&child,&new_parentlink);
			
 
				+            if (newh == NULL) goto oom;
			
 
				+            h = newh;
			
 
				+            memcpy(parentlink,&h,sizeof(h));
			
 
				+            parentlink = new_parentlink;
			
 
				+            i++;
			
 
				+        }
			
 
				+        rax->numnodes++;
			
 
				+        h = child;
			
 
				+    }
			
 
				+    raxNode *newh = raxReallocForData(h,data);
			
 
				+    if (newh == NULL) goto oom;
			
 
				+    h = newh;
			
 
				+    if (!h->iskey) rax->numele++;
			
 
				+    raxSetData(h,data);
			
 
				+    memcpy(parentlink,&h,sizeof(h));
			
 
				+    return 1; /* Element inserted. */
			
 
				+
			
 
				+oom:
			
 
				+    /* This code path handles out of memory after part of the sub-tree was
			
 
				+     * already modified. Set the node as a key, and then remove it. However we
			
 
				+     * do that only if the node is a terminal node, otherwise if the OOM
			
 
				+     * happened reallocating a node in the middle, we don't need to free
			
 
				+     * anything. */
			
 
				+    if (h->size == 0) {
			
 
				+        h->isnull = 1;
			
 
				+        h->iskey = 1;
			
 
				+        rax->numele++; /* Compensate the next remove. */
			
 
				+        assert(raxRemove(rax,s,i,NULL) != 0);
			
 
				+    }
			
 
				+    errno = ENOMEM;
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Overwriting insert. Just a wrapper for raxGenericInsert() that will
			
 
				+ * update the element if there is already one for the same key. */
			
 
				+int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
			
 
				+    return raxGenericInsert(rax,s,len,data,old,1);
			
 
				+}
			
 
				+
			
 
				+/* Non overwriting insert function: this if an element with the same key
			
 
				+ * exists, the value is not updated and the function returns 0.
			
 
				+ * This is a just a wrapper for raxGenericInsert(). */
			
 
				+int raxTryInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old) {
			
 
				+    return raxGenericInsert(rax,s,len,data,old,0);
			
 
				+}
			
 
				+
			
 
				+/* Find a key in the rax, returns raxNotFound special void pointer value
			
 
				+ * if the item was not found, otherwise the value associated with the
			
 
				+ * item is returned. */
			
 
				+void *raxFind(rax *rax, unsigned char *s, size_t len) {
			
 
				+    raxNode *h;
			
 
				+
			
 
				+    debugf("### Lookup: %.*s\n", (int)len, s);
			
 
				+    int splitpos = 0;
			
 
				+    size_t i = raxLowWalk(rax,s,len,&h,NULL,&splitpos,NULL);
			
 
				+    if (i != len || (h->iscompr && splitpos != 0) || !h->iskey)
			
 
				+        return raxNotFound;
			
 
				+    return raxGetData(h);
			
 
				+}
			
 
				+
			
 
				+/* Return the memory address where the 'parent' node stores the specified
			
 
				+ * 'child' pointer, so that the caller can update the pointer with another
			
 
				+ * one if needed. The function assumes it will find a match, otherwise the
			
 
				+ * operation is an undefined behavior (it will continue scanning the
			
 
				+ * memory without any bound checking). */
			
 
				+raxNode **raxFindParentLink(raxNode *parent, raxNode *child) {
			
 
				+    raxNode **cp = raxNodeFirstChildPtr(parent);
			
 
				+    raxNode *c;
			
 
				+    while(1) {
			
 
				+        memcpy(&c,cp,sizeof(c));
			
 
				+        if (c == child) break;
			
 
				+        cp++;
			
 
				+    }
			
 
				+    return cp;
			
 
				+}
			
 
				+
			
 
				+/* Low level child removal from node. The new node pointer (after the child
			
 
				+ * removal) is returned. Note that this function does not fix the pointer
			
 
				+ * of the parent node in its parent, so this task is up to the caller.
			
 
				+ * The function never fails for out of memory. */
			
 
				+raxNode *raxRemoveChild(raxNode *parent, raxNode *child) {
			
 
				+    debugnode("raxRemoveChild before", parent);
			
 
				+    /* If parent is a compressed node (having a single child, as for definition
			
 
				+     * of the data structure), the removal of the child consists into turning
			
 
				+     * it into a normal node without children. */
			
 
				+    if (parent->iscompr) {
			
 
				+        void *data = NULL;
			
 
				+        if (parent->iskey) data = raxGetData(parent);
			
 
				+        parent->isnull = 0;
			
 
				+        parent->iscompr = 0;
			
 
				+        parent->size = 0;
			
 
				+        if (parent->iskey) raxSetData(parent,data);
			
 
				+        debugnode("raxRemoveChild after", parent);
			
 
				+        return parent;
			
 
				+    }
			
 
				+
			
 
				+    /* Otherwise we need to scan for the child pointer and memmove()
			
 
				+     * accordingly.
			
 
				+     *
			
 
				+     * 1. To start we seek the first element in both the children
			
 
				+     *    pointers and edge bytes in the node. */
			
 
				+    raxNode **cp = raxNodeFirstChildPtr(parent);
			
 
				+    raxNode **c = cp;
			
 
				+    unsigned char *e = parent->data;
			
 
				+
			
 
				+    /* 2. Search the child pointer to remove inside the array of children
			
 
				+     *    pointers. */
			
 
				+    while(1) {
			
 
				+        raxNode *aux;
			
 
				+        memcpy(&aux,c,sizeof(aux));
			
 
				+        if (aux == child) break;
			
 
				+        c++;
			
 
				+        e++;
			
 
				+    }
			
 
				+
			
 
				+    /* 3. Remove the edge and the pointer by memmoving the remaining children
			
 
				+     *    pointer and edge bytes one position before. */
			
 
				+    int taillen = parent->size - (e - parent->data) - 1;
			
 
				+    debugf("raxRemoveChild tail len: %d\n", taillen);
			
 
				+    memmove(e,e+1,taillen);
			
 
				+
			
 
				+    /* Compute the shift, that is the amount of bytes we should move our
			
 
				+     * child pointers to the left, since the removal of one edge character
			
 
				+     * and the corresponding padding change, may change the layout.
			
 
				+     * We just check if in the old version of the node there was at the
			
 
				+     * end just a single byte and all padding: in that case removing one char
			
 
				+     * will remove a whole sizeof(void*) word. */
			
 
				+    size_t shift = ((parent->size+4) % sizeof(void*)) == 1 ? sizeof(void*) : 0;
			
 
				+
			
 
				+    /* Move the children pointers before the deletion point. */
			
 
				+    if (shift)
			
 
				+        memmove(((char*)cp)-shift,cp,(parent->size-taillen-1)*sizeof(raxNode**));
			
 
				+
			
 
				+    /* Move the remaining "tail" pointers at the right position as well. */
			
 
				+    size_t valuelen = (parent->iskey && !parent->isnull) ? sizeof(void*) : 0;
			
 
				+    memmove(((char*)c)-shift,c+1,taillen*sizeof(raxNode**)+valuelen);
			
 
				+
			
 
				+    /* 4. Update size. */
			
 
				+    parent->size--;
			
 
				+
			
 
				+    /* realloc the node according to the theoretical memory usage, to free
			
 
				+     * data if we are over-allocating right now. */
			
 
				+    raxNode *newnode = rax_realloc(parent,raxNodeCurrentLength(parent));
			
 
				+    if (newnode) {
			
 
				+        debugnode("raxRemoveChild after", newnode);
			
 
				+    }
			
 
				+    /* Note: if rax_realloc() fails we just return the old address, which
			
 
				+     * is valid. */
			
 
				+    return newnode ? newnode : parent;
			
 
				+}
			
 
				+
			
 
				+/* Remove the specified item. Returns 1 if the item was found and
			
 
				+ * deleted, 0 otherwise. */
			
 
				+int raxRemove(rax *rax, unsigned char *s, size_t len, void **old) {
			
 
				+    raxNode *h;
			
 
				+    raxStack ts;
			
 
				+
			
 
				+    debugf("### Delete: %.*s\n", (int)len, s);
			
 
				+    raxStackInit(&ts);
			
 
				+    int splitpos = 0;
			
 
				+    size_t i = raxLowWalk(rax,s,len,&h,NULL,&splitpos,&ts);
			
 
				+    if (i != len || (h->iscompr && splitpos != 0) || !h->iskey) {
			
 
				+        raxStackFree(&ts);
			
 
				+        return 0;
			
 
				+    }
			
 
				+    if (old) *old = raxGetData(h);
			
 
				+    h->iskey = 0;
			
 
				+    rax->numele--;
			
 
				+
			
 
				+    /* If this node has no children, the deletion needs to reclaim the
			
 
				+     * no longer used nodes. This is an iterative process that needs to
			
 
				+     * walk the three upward, deleting all the nodes with just one child
			
 
				+     * that are not keys, until the head of the rax is reached or the first
			
 
				+     * node with more than one child is found. */
			
 
				+
			
 
				+    int trycompress = 0; /* Will be set to 1 if we should try to optimize the
			
 
				+                            tree resulting from the deletion. */
			
 
				+
			
 
				+    if (h->size == 0) {
			
 
				+        debugf("Key deleted in node without children. Cleanup needed.\n");
			
 
				+        raxNode *child = NULL;
			
 
				+        while(h != rax->head) {
			
 
				+            child = h;
			
 
				+            debugf("Freeing child %p [%.*s] key:%d\n", (void*)child,
			
 
				+                (int)child->size, (char*)child->data, child->iskey);
			
 
				+            rax_free(child);
			
 
				+            rax->numnodes--;
			
 
				+            h = raxStackPop(&ts);
			
 
				+             /* If this node has more then one child, or actually holds
			
 
				+              * a key, stop here. */
			
 
				+            if (h->iskey || (!h->iscompr && h->size != 1)) break;
			
 
				+        }
			
 
				+        if (child) {
			
 
				+            debugf("Unlinking child %p from parent %p\n",
			
 
				+                (void*)child, (void*)h);
			
 
				+            raxNode *new = raxRemoveChild(h,child);
			
 
				+            if (new != h) {
			
 
				+                raxNode *parent = raxStackPeek(&ts);
			
 
				+                raxNode **parentlink;
			
 
				+                if (parent == NULL) {
			
 
				+                    parentlink = &rax->head;
			
 
				+                } else {
			
 
				+                    parentlink = raxFindParentLink(parent,h);
			
 
				+                }
			
 
				+                memcpy(parentlink,&new,sizeof(new));
			
 
				+            }
			
 
				+
			
 
				+            /* If after the removal the node has just a single child
			
 
				+             * and is not a key, we need to try to compress it. */
			
 
				+            if (new->size == 1 && new->iskey == 0) {
			
 
				+                trycompress = 1;
			
 
				+                h = new;
			
 
				+            }
			
 
				+        }
			
 
				+    } else if (h->size == 1) {
			
 
				+        /* If the node had just one child, after the removal of the key
			
 
				+         * further compression with adjacent nodes is potentially possible. */
			
 
				+        trycompress = 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Don't try node compression if our nodes pointers stack is not
			
 
				+     * complete because of OOM while executing raxLowWalk() */
			
 
				+    if (trycompress && ts.oom) trycompress = 0;
			
 
				+
			
 
				+    /* Recompression: if trycompress is true, 'h' points to a radix tree node
			
 
				+     * that changed in a way that could allow to compress nodes in this
			
 
				+     * sub-branch. Compressed nodes represent chains of nodes that are not
			
 
				+     * keys and have a single child, so there are two deletion events that
			
 
				+     * may alter the tree so that further compression is needed:
			
 
				+     *
			
 
				+     * 1) A node with a single child was a key and now no longer is a key.
			
 
				+     * 2) A node with two children now has just one child.
			
 
				+     *
			
 
				+     * We try to navigate upward till there are other nodes that can be
			
 
				+     * compressed, when we reach the upper node which is not a key and has
			
 
				+     * a single child, we scan the chain of children to collect the
			
 
				+     * compressible part of the tree, and replace the current node with the
			
 
				+     * new one, fixing the child pointer to reference the first non
			
 
				+     * compressible node.
			
 
				+     *
			
 
				+     * Example of case "1". A tree stores the keys "FOO" = 1 and
			
 
				+     * "FOOBAR" = 2:
			
 
				+     *
			
 
				+     *
			
 
				+     * "FOO" -> "BAR" -> [] (2)
			
 
				+     *           (1)
			
 
				+     *
			
 
				+     * After the removal of "FOO" the tree can be compressed as:
			
 
				+     *
			
 
				+     * "FOOBAR" -> [] (2)
			
 
				+     *
			
 
				+     *
			
 
				+     * Example of case "2". A tree stores the keys "FOOBAR" = 1 and
			
 
				+     * "FOOTER" = 2:
			
 
				+     *
			
 
				+     *          |B| -> "AR" -> [] (1)
			
 
				+     * "FOO" -> |-|
			
 
				+     *          |T| -> "ER" -> [] (2)
			
 
				+     *
			
 
				+     * After the removal of "FOOTER" the resulting tree is:
			
 
				+     *
			
 
				+     * "FOO" -> |B| -> "AR" -> [] (1)
			
 
				+     *
			
 
				+     * That can be compressed into:
			
 
				+     *
			
 
				+     * "FOOBAR" -> [] (1)
			
 
				+     */
			
 
				+    if (trycompress) {
			
 
				+        debugf("After removing %.*s:\n", (int)len, s);
			
 
				+        debugnode("Compression may be needed",h);
			
 
				+        debugf("Seek start node\n");
			
 
				+
			
 
				+        /* Try to reach the upper node that is compressible.
			
 
				+         * At the end of the loop 'h' will point to the first node we
			
 
				+         * can try to compress and 'parent' to its parent. */
			
 
				+        raxNode *parent;
			
 
				+        while(1) {
			
 
				+            parent = raxStackPop(&ts);
			
 
				+            if (!parent || parent->iskey ||
			
 
				+                (!parent->iscompr && parent->size != 1)) break;
			
 
				+            h = parent;
			
 
				+            debugnode("Going up to",h);
			
 
				+        }
			
 
				+        raxNode *start = h; /* Compression starting node. */
			
 
				+
			
 
				+        /* Scan chain of nodes we can compress. */
			
 
				+        size_t comprsize = h->size;
			
 
				+        int nodes = 1;
			
 
				+        while(h->size != 0) {
			
 
				+            raxNode **cp = raxNodeLastChildPtr(h);
			
 
				+            memcpy(&h,cp,sizeof(h));
			
 
				+            if (h->iskey || (!h->iscompr && h->size != 1)) break;
			
 
				+            /* Stop here if going to the next node would result into
			
 
				+             * a compressed node larger than h->size can hold. */
			
 
				+            if (comprsize + h->size > RAX_NODE_MAX_SIZE) break;
			
 
				+            nodes++;
			
 
				+            comprsize += h->size;
			
 
				+        }
			
 
				+        if (nodes > 1) {
			
 
				+            /* If we can compress, create the new node and populate it. */
			
 
				+            size_t nodesize =
			
 
				+                sizeof(raxNode)+comprsize+raxPadding(comprsize)+sizeof(raxNode*);
			
 
				+            raxNode *new = rax_malloc(nodesize);
			
 
				+            /* An out of memory here just means we cannot optimize this
			
 
				+             * node, but the tree is left in a consistent state. */
			
 
				+            if (new == NULL) {
			
 
				+                raxStackFree(&ts);
			
 
				+                return 1;
			
 
				+            }
			
 
				+            new->iskey = 0;
			
 
				+            new->isnull = 0;
			
 
				+            new->iscompr = 1;
			
 
				+            new->size = comprsize;
			
 
				+            rax->numnodes++;
			
 
				+
			
 
				+            /* Scan again, this time to populate the new node content and
			
 
				+             * to fix the new node child pointer. At the same time we free
			
 
				+             * all the nodes that we'll no longer use. */
			
 
				+            comprsize = 0;
			
 
				+            h = start;
			
 
				+            while(h->size != 0) {
			
 
				+                memcpy(new->data+comprsize,h->data,h->size);
			
 
				+                comprsize += h->size;
			
 
				+                raxNode **cp = raxNodeLastChildPtr(h);
			
 
				+                raxNode *tofree = h;
			
 
				+                memcpy(&h,cp,sizeof(h));
			
 
				+                rax_free(tofree); rax->numnodes--;
			
 
				+                if (h->iskey || (!h->iscompr && h->size != 1)) break;
			
 
				+            }
			
 
				+            debugnode("New node",new);
			
 
				+
			
 
				+            /* Now 'h' points to the first node that we still need to use,
			
 
				+             * so our new node child pointer will point to it. */
			
 
				+            raxNode **cp = raxNodeLastChildPtr(new);
			
 
				+            memcpy(cp,&h,sizeof(h));
			
 
				+
			
 
				+            /* Fix parent link. */
			
 
				+            if (parent) {
			
 
				+                raxNode **parentlink = raxFindParentLink(parent,start);
			
 
				+                memcpy(parentlink,&new,sizeof(new));
			
 
				+            } else {
			
 
				+                rax->head = new;
			
 
				+            }
			
 
				+
			
 
				+            debugf("Compressed %d nodes, %d total bytes\n",
			
 
				+                nodes, (int)comprsize);
			
 
				+        }
			
 
				+    }
			
 
				+    raxStackFree(&ts);
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* This is the core of raxFree(): performs a depth-first scan of the
			
 
				+ * tree and releases all the nodes found. */
			
 
				+void raxRecursiveFree(rax *rax, raxNode *n, void (*free_callback)(void*)) {
			
 
				+    debugnode("free traversing",n);
			
 
				+    int numchildren = n->iscompr ? 1 : n->size;
			
 
				+    raxNode **cp = raxNodeLastChildPtr(n);
			
 
				+    while(numchildren--) {
			
 
				+        raxNode *child;
			
 
				+        memcpy(&child,cp,sizeof(child));
			
 
				+        raxRecursiveFree(rax,child,free_callback);
			
 
				+        cp--;
			
 
				+    }
			
 
				+    debugnode("free depth-first",n);
			
 
				+    if (free_callback && n->iskey && !n->isnull)
			
 
				+        free_callback(raxGetData(n));
			
 
				+    rax_free(n);
			
 
				+    rax->numnodes--;
			
 
				+}
			
 
				+
			
 
				+/* Free a whole radix tree, calling the specified callback in order to
			
 
				+ * free the auxiliary data. */
			
 
				+void raxFreeWithCallback(rax *rax, void (*free_callback)(void*)) {
			
 
				+    raxRecursiveFree(rax,rax->head,free_callback);
			
 
				+    assert(rax->numnodes == 0);
			
 
				+    rax_free(rax);
			
 
				+}
			
 
				+
			
 
				+/* Free a whole radix tree. */
			
 
				+void raxFree(rax *rax) {
			
 
				+    raxFreeWithCallback(rax,NULL);
			
 
				+}
			
 
				+
			
 
				+/* ------------------------------- Iterator --------------------------------- */
			
 
				+
			
 
				+/* Initialize a Rax iterator. This call should be performed a single time
			
 
				+ * to initialize the iterator, and must be followed by a raxSeek() call,
			
 
				+ * otherwise the raxPrev()/raxNext() functions will just return EOF. */
			
 
				+void raxStart(raxIterator *it, rax *rt) {
			
 
				+    it->flags = RAX_ITER_EOF; /* No crash if the iterator is not seeked. */
			
 
				+    it->rt = rt;
			
 
				+    it->key_len = 0;
			
 
				+    it->key = it->key_static_string;
			
 
				+    it->key_max = RAX_ITER_STATIC_LEN;
			
 
				+    it->data = NULL;
			
 
				+    it->node_cb = NULL;
			
 
				+    raxStackInit(&it->stack);
			
 
				+}
			
 
				+
			
 
				+/* Append characters at the current key string of the iterator 'it'. This
			
 
				+ * is a low level function used to implement the iterator, not callable by
			
 
				+ * the user. Returns 0 on out of memory, otherwise 1 is returned. */
			
 
				+int raxIteratorAddChars(raxIterator *it, unsigned char *s, size_t len) {
			
 
				+    if (len == 0) return 1;
			
 
				+    if (it->key_max < it->key_len+len) {
			
 
				+        unsigned char *old = (it->key == it->key_static_string) ? NULL :
			
 
				+                                                                  it->key;
			
 
				+        size_t new_max = (it->key_len+len)*2;
			
 
				+        it->key = rax_realloc(old,new_max);
			
 
				+        if (it->key == NULL) {
			
 
				+            it->key = (!old) ? it->key_static_string : old;
			
 
				+            errno = ENOMEM;
			
 
				+            return 0;
			
 
				+        }
			
 
				+        if (old == NULL) memcpy(it->key,it->key_static_string,it->key_len);
			
 
				+        it->key_max = new_max;
			
 
				+    }
			
 
				+    /* Use memmove since there could be an overlap between 's' and
			
 
				+     * it->key when we use the current key in order to re-seek. */
			
 
				+    memmove(it->key+it->key_len,s,len);
			
 
				+    it->key_len += len;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Remove the specified number of chars from the right of the current
			
 
				+ * iterator key. */
			
 
				+void raxIteratorDelChars(raxIterator *it, size_t count) {
			
 
				+    it->key_len -= count;
			
 
				+}
			
 
				+
			
 
				+/* Do an iteration step towards the next element. At the end of the step the
			
 
				+ * iterator key will represent the (new) current key. If it is not possible
			
 
				+ * to step in the specified direction since there are no longer elements, the
			
 
				+ * iterator is flagged with RAX_ITER_EOF.
			
 
				+ *
			
 
				+ * If 'noup' is true the function starts directly scanning for the next
			
 
				+ * lexicographically smaller children, and the current node is already assumed
			
 
				+ * to be the parent of the last key node, so the first operation to go back to
			
 
				+ * the parent will be skipped. This option is used by raxSeek() when
			
 
				+ * implementing seeking a non existing element with the ">" or "<" options:
			
 
				+ * the starting node is not a key in that particular case, so we start the scan
			
 
				+ * from a node that does not represent the key set.
			
 
				+ *
			
 
				+ * The function returns 1 on success or 0 on out of memory. */
			
 
				+int raxIteratorNextStep(raxIterator *it, int noup) {
			
 
				+    if (it->flags & RAX_ITER_EOF) {
			
 
				+        return 1;
			
 
				+    } else if (it->flags & RAX_ITER_JUST_SEEKED) {
			
 
				+        it->flags &= ~RAX_ITER_JUST_SEEKED;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Save key len, stack items and the node where we are currently
			
 
				+     * so that on iterator EOF we can restore the current key and state. */
			
 
				+    size_t orig_key_len = it->key_len;
			
 
				+    size_t orig_stack_items = it->stack.items;
			
 
				+    raxNode *orig_node = it->node;
			
 
				+
			
 
				+    while(1) {
			
 
				+        int children = it->node->iscompr ? 1 : it->node->size;
			
 
				+        if (!noup && children) {
			
 
				+            debugf("GO DEEPER\n");
			
 
				+            /* Seek the lexicographically smaller key in this subtree, which
			
 
				+             * is the first one found always going towards the first child
			
 
				+             * of every successive node. */
			
 
				+            if (!raxStackPush(&it->stack,it->node)) return 0;
			
 
				+            raxNode **cp = raxNodeFirstChildPtr(it->node);
			
 
				+            if (!raxIteratorAddChars(it,it->node->data,
			
 
				+                it->node->iscompr ? it->node->size : 1)) return 0;
			
 
				+            memcpy(&it->node,cp,sizeof(it->node));
			
 
				+            /* Call the node callback if any, and replace the node pointer
			
 
				+             * if the callback returns true. */
			
 
				+            if (it->node_cb && it->node_cb(&it->node))
			
 
				+                memcpy(cp,&it->node,sizeof(it->node));
			
 
				+            /* For "next" step, stop every time we find a key along the
			
 
				+             * way, since the key is lexicographically smaller compared to
			
 
				+             * what follows in the sub-children. */
			
 
				+            if (it->node->iskey) {
			
 
				+                it->data = raxGetData(it->node);
			
 
				+                return 1;
			
 
				+            }
			
 
				+        } else {
			
 
				+            /* If we finished exploring the previous sub-tree, switch to the
			
 
				+             * new one: go upper until a node is found where there are
			
 
				+             * children representing keys lexicographically greater than the
			
 
				+             * current key. */
			
 
				+            while(1) {
			
 
				+                int old_noup = noup;
			
 
				+
			
 
				+                /* Already on head? Can't go up, iteration finished. */
			
 
				+                if (!noup && it->node == it->rt->head) {
			
 
				+                    it->flags |= RAX_ITER_EOF;
			
 
				+                    it->stack.items = orig_stack_items;
			
 
				+                    it->key_len = orig_key_len;
			
 
				+                    it->node = orig_node;
			
 
				+                    return 1;
			
 
				+                }
			
 
				+                /* If there are no children at the current node, try parent's
			
 
				+                 * next child. */
			
 
				+                unsigned char prevchild = it->key[it->key_len-1];
			
 
				+                if (!noup) {
			
 
				+                    it->node = raxStackPop(&it->stack);
			
 
				+                } else {
			
 
				+                    noup = 0;
			
 
				+                }
			
 
				+                /* Adjust the current key to represent the node we are
			
 
				+                 * at. */
			
 
				+                int todel = it->node->iscompr ? it->node->size : 1;
			
 
				+                raxIteratorDelChars(it,todel);
			
 
				+
			
 
				+                /* Try visiting the next child if there was at least one
			
 
				+                 * additional child. */
			
 
				+                if (!it->node->iscompr && it->node->size > (old_noup ? 0 : 1)) {
			
 
				+                    raxNode **cp = raxNodeFirstChildPtr(it->node);
			
 
				+                    int i = 0;
			
 
				+                    while (i < it->node->size) {
			
 
				+                        debugf("SCAN NEXT %c\n", it->node->data[i]);
			
 
				+                        if (it->node->data[i] > prevchild) break;
			
 
				+                        i++;
			
 
				+                        cp++;
			
 
				+                    }
			
 
				+                    if (i != it->node->size) {
			
 
				+                        debugf("SCAN found a new node\n");
			
 
				+                        raxIteratorAddChars(it,it->node->data+i,1);
			
 
				+                        if (!raxStackPush(&it->stack,it->node)) return 0;
			
 
				+                        memcpy(&it->node,cp,sizeof(it->node));
			
 
				+                        /* Call the node callback if any, and replace the node
			
 
				+                         * pointer if the callback returns true. */
			
 
				+                        if (it->node_cb && it->node_cb(&it->node))
			
 
				+                            memcpy(cp,&it->node,sizeof(it->node));
			
 
				+                        if (it->node->iskey) {
			
 
				+                            it->data = raxGetData(it->node);
			
 
				+                            return 1;
			
 
				+                        }
			
 
				+                        break;
			
 
				+                    }
			
 
				+                }
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Seek the greatest key in the subtree at the current node. Return 0 on
			
 
				+ * out of memory, otherwise 1. This is a helper function for different
			
 
				+ * iteration functions below. */
			
 
				+int raxSeekGreatest(raxIterator *it) {
			
 
				+    while(it->node->size) {
			
 
				+        if (it->node->iscompr) {
			
 
				+            if (!raxIteratorAddChars(it,it->node->data,
			
 
				+                it->node->size)) return 0;
			
 
				+        } else {
			
 
				+            if (!raxIteratorAddChars(it,it->node->data+it->node->size-1,1))
			
 
				+                return 0;
			
 
				+        }
			
 
				+        raxNode **cp = raxNodeLastChildPtr(it->node);
			
 
				+        if (!raxStackPush(&it->stack,it->node)) return 0;
			
 
				+        memcpy(&it->node,cp,sizeof(it->node));
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Like raxIteratorNextStep() but implements an iteration step moving
			
 
				+ * to the lexicographically previous element. The 'noup' option has a similar
			
 
				+ * effect to the one of raxIteratorNextStep(). */
			
 
				+int raxIteratorPrevStep(raxIterator *it, int noup) {
			
 
				+    if (it->flags & RAX_ITER_EOF) {
			
 
				+        return 1;
			
 
				+    } else if (it->flags & RAX_ITER_JUST_SEEKED) {
			
 
				+        it->flags &= ~RAX_ITER_JUST_SEEKED;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Save key len, stack items and the node where we are currently
			
 
				+     * so that on iterator EOF we can restore the current key and state. */
			
 
				+    size_t orig_key_len = it->key_len;
			
 
				+    size_t orig_stack_items = it->stack.items;
			
 
				+    raxNode *orig_node = it->node;
			
 
				+
			
 
				+    while(1) {
			
 
				+        int old_noup = noup;
			
 
				+
			
 
				+        /* Already on head? Can't go up, iteration finished. */
			
 
				+        if (!noup && it->node == it->rt->head) {
			
 
				+            it->flags |= RAX_ITER_EOF;
			
 
				+            it->stack.items = orig_stack_items;
			
 
				+            it->key_len = orig_key_len;
			
 
				+            it->node = orig_node;
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        unsigned char prevchild = it->key[it->key_len-1];
			
 
				+        if (!noup) {
			
 
				+            it->node = raxStackPop(&it->stack);
			
 
				+        } else {
			
 
				+            noup = 0;
			
 
				+        }
			
 
				+
			
 
				+        /* Adjust the current key to represent the node we are
			
 
				+         * at. */
			
 
				+        int todel = it->node->iscompr ? it->node->size : 1;
			
 
				+        raxIteratorDelChars(it,todel);
			
 
				+
			
 
				+        /* Try visiting the prev child if there is at least one
			
 
				+         * child. */
			
 
				+        if (!it->node->iscompr && it->node->size > (old_noup ? 0 : 1)) {
			
 
				+            raxNode **cp = raxNodeLastChildPtr(it->node);
			
 
				+            int i = it->node->size-1;
			
 
				+            while (i >= 0) {
			
 
				+                debugf("SCAN PREV %c\n", it->node->data[i]);
			
 
				+                if (it->node->data[i] < prevchild) break;
			
 
				+                i--;
			
 
				+                cp--;
			
 
				+            }
			
 
				+            /* If we found a new subtree to explore in this node,
			
 
				+             * go deeper following all the last children in order to
			
 
				+             * find the key lexicographically greater. */
			
 
				+            if (i != -1) {
			
 
				+                debugf("SCAN found a new node\n");
			
 
				+                /* Enter the node we just found. */
			
 
				+                if (!raxIteratorAddChars(it,it->node->data+i,1)) return 0;
			
 
				+                if (!raxStackPush(&it->stack,it->node)) return 0;
			
 
				+                memcpy(&it->node,cp,sizeof(it->node));
			
 
				+                /* Seek sub-tree max. */
			
 
				+                if (!raxSeekGreatest(it)) return 0;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        /* Return the key: this could be the key we found scanning a new
			
 
				+         * subtree, or if we did not find a new subtree to explore here,
			
 
				+         * before giving up with this node, check if it's a key itself. */
			
 
				+        if (it->node->iskey) {
			
 
				+            it->data = raxGetData(it->node);
			
 
				+            return 1;
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Seek an iterator at the specified element.
			
 
				+ * Return 0 if the seek failed for syntax error or out of memory. Otherwise
			
 
				+ * 1 is returned. When 0 is returned for out of memory, errno is set to
			
 
				+ * the ENOMEM value. */
			
 
				+int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len) {
			
 
				+    int eq = 0, lt = 0, gt = 0, first = 0, last = 0;
			
 
				+
			
 
				+    it->stack.items = 0; /* Just resetting. Initialized by raxStart(). */
			
 
				+    it->flags |= RAX_ITER_JUST_SEEKED;
			
 
				+    it->flags &= ~RAX_ITER_EOF;
			
 
				+    it->key_len = 0;
			
 
				+    it->node = NULL;
			
 
				+
			
 
				+    /* Set flags according to the operator used to perform the seek. */
			
 
				+    if (op[0] == '>') {
			
 
				+        gt = 1;
			
 
				+        if (op[1] == '=') eq = 1;
			
 
				+    } else if (op[0] == '<') {
			
 
				+        lt = 1;
			
 
				+        if (op[1] == '=') eq = 1;
			
 
				+    } else if (op[0] == '=') {
			
 
				+        eq = 1;
			
 
				+    } else if (op[0] == '^') {
			
 
				+        first = 1;
			
 
				+    } else if (op[0] == '$') {
			
 
				+        last = 1;
			
 
				+    } else {
			
 
				+        errno = 0;
			
 
				+        return 0; /* Error. */
			
 
				+    }
			
 
				+
			
 
				+    /* If there are no elements, set the EOF condition immediately and
			
 
				+     * return. */
			
 
				+    if (it->rt->numele == 0) {
			
 
				+        it->flags |= RAX_ITER_EOF;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    if (first) {
			
 
				+        /* Seeking the first key greater or equal to the empty string
			
 
				+         * is equivalent to seeking the smaller key available. */
			
 
				+        return raxSeek(it,">=",NULL,0);
			
 
				+    }
			
 
				+
			
 
				+    if (last) {
			
 
				+        /* Find the greatest key taking always the last child till a
			
 
				+         * final node is found. */
			
 
				+        it->node = it->rt->head;
			
 
				+        if (!raxSeekGreatest(it)) return 0;
			
 
				+        assert(it->node->iskey);
			
 
				+        it->data = raxGetData(it->node);
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* We need to seek the specified key. What we do here is to actually
			
 
				+     * perform a lookup, and later invoke the prev/next key code that
			
 
				+     * we already use for iteration. */
			
 
				+    int splitpos = 0;
			
 
				+    size_t i = raxLowWalk(it->rt,ele,len,&it->node,NULL,&splitpos,&it->stack);
			
 
				+
			
 
				+    /* Return OOM on incomplete stack info. */
			
 
				+    if (it->stack.oom) return 0;
			
 
				+
			
 
				+    if (eq && i == len && (!it->node->iscompr || splitpos == 0) &&
			
 
				+        it->node->iskey)
			
 
				+    {
			
 
				+        /* We found our node, since the key matches and we have an
			
 
				+         * "equal" condition. */
			
 
				+        if (!raxIteratorAddChars(it,ele,len)) return 0; /* OOM. */
			
 
				+        it->data = raxGetData(it->node);
			
 
				+    } else if (lt || gt) {
			
 
				+        /* Exact key not found or eq flag not set. We have to set as current
			
 
				+         * key the one represented by the node we stopped at, and perform
			
 
				+         * a next/prev operation to seek. */
			
 
				+        raxIteratorAddChars(it, ele, i-splitpos);
			
 
				+
			
 
				+        /* We need to set the iterator in the correct state to call next/prev
			
 
				+         * step in order to seek the desired element. */
			
 
				+        debugf("After initial seek: i=%d len=%d key=%.*s\n",
			
 
				+            (int)i, (int)len, (int)it->key_len, it->key);
			
 
				+        if (i != len && !it->node->iscompr) {
			
 
				+            /* If we stopped in the middle of a normal node because of a
			
 
				+             * mismatch, add the mismatching character to the current key
			
 
				+             * and call the iterator with the 'noup' flag so that it will try
			
 
				+             * to seek the next/prev child in the current node directly based
			
 
				+             * on the mismatching character. */
			
 
				+            if (!raxIteratorAddChars(it,ele+i,1)) return 0;
			
 
				+            debugf("Seek normal node on mismatch: %.*s\n",
			
 
				+                (int)it->key_len, (char*)it->key);
			
 
				+
			
 
				+            it->flags &= ~RAX_ITER_JUST_SEEKED;
			
 
				+            if (lt && !raxIteratorPrevStep(it,1)) return 0;
			
 
				+            if (gt && !raxIteratorNextStep(it,1)) return 0;
			
 
				+            it->flags |= RAX_ITER_JUST_SEEKED; /* Ignore next call. */
			
 
				+        } else if (i != len && it->node->iscompr) {
			
 
				+            debugf("Compressed mismatch: %.*s\n",
			
 
				+                (int)it->key_len, (char*)it->key);
			
 
				+            /* In case of a mismatch within a compressed node. */
			
 
				+            int nodechar = it->node->data[splitpos];
			
 
				+            int keychar = ele[i];
			
 
				+            it->flags &= ~RAX_ITER_JUST_SEEKED;
			
 
				+            if (gt) {
			
 
				+                /* If the key the compressed node represents is greater
			
 
				+                 * than our seek element, continue forward, otherwise set the
			
 
				+                 * state in order to go back to the next sub-tree. */
			
 
				+                if (nodechar > keychar) {
			
 
				+                    if (!raxIteratorNextStep(it,0)) return 0;
			
 
				+                } else {
			
 
				+                    if (!raxIteratorAddChars(it,it->node->data,it->node->size))
			
 
				+                        return 0;
			
 
				+                    if (!raxIteratorNextStep(it,1)) return 0;
			
 
				+                }
			
 
				+            }
			
 
				+            if (lt) {
			
 
				+                /* If the key the compressed node represents is smaller
			
 
				+                 * than our seek element, seek the greater key in this
			
 
				+                 * subtree, otherwise set the state in order to go back to
			
 
				+                 * the previous sub-tree. */
			
 
				+                if (nodechar < keychar) {
			
 
				+                    if (!raxSeekGreatest(it)) return 0;
			
 
				+                    it->data = raxGetData(it->node);
			
 
				+                } else {
			
 
				+                    if (!raxIteratorAddChars(it,it->node->data,it->node->size))
			
 
				+                        return 0;
			
 
				+                    if (!raxIteratorPrevStep(it,1)) return 0;
			
 
				+                }
			
 
				+            }
			
 
				+            it->flags |= RAX_ITER_JUST_SEEKED; /* Ignore next call. */
			
 
				+        } else {
			
 
				+            debugf("No mismatch: %.*s\n",
			
 
				+                (int)it->key_len, (char*)it->key);
			
 
				+            /* If there was no mismatch we are into a node representing the
			
 
				+             * key, (but which is not a key or the seek operator does not
			
 
				+             * include 'eq'), or we stopped in the middle of a compressed node
			
 
				+             * after processing all the key. Continue iterating as this was
			
 
				+             * a legitimate key we stopped at. */
			
 
				+            it->flags &= ~RAX_ITER_JUST_SEEKED;
			
 
				+            if (it->node->iscompr && it->node->iskey && splitpos && lt) {
			
 
				+                /* If we stopped in the middle of a compressed node with
			
 
				+                 * perfect match, and the condition is to seek a key "<" than
			
 
				+                 * the specified one, then if this node is a key it already
			
 
				+                 * represents our match. For instance we may have nodes:
			
 
				+                 *
			
 
				+                 * "f" -> "oobar" = 1 -> "" = 2
			
 
				+                 *
			
 
				+                 * Representing keys "f" = 1, "foobar" = 2. A seek for
			
 
				+                 * the key < "foo" will stop in the middle of the "oobar"
			
 
				+                 * node, but will be our match, representing the key "f".
			
 
				+                 *
			
 
				+                 * So in that case, we don't seek backward. */
			
 
				+                it->data = raxGetData(it->node);
			
 
				+            } else {
			
 
				+                if (gt && !raxIteratorNextStep(it,0)) return 0;
			
 
				+                if (lt && !raxIteratorPrevStep(it,0)) return 0;
			
 
				+            }
			
 
				+            it->flags |= RAX_ITER_JUST_SEEKED; /* Ignore next call. */
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* If we are here just eq was set but no match was found. */
			
 
				+        it->flags |= RAX_ITER_EOF;
			
 
				+        return 1;
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Go to the next element in the scope of the iterator 'it'.
			
 
				+ * If EOF (or out of memory) is reached, 0 is returned, otherwise 1 is
			
 
				+ * returned. In case 0 is returned because of OOM, errno is set to ENOMEM. */
			
 
				+int raxNext(raxIterator *it) {
			
 
				+    if (!raxIteratorNextStep(it,0)) {
			
 
				+        errno = ENOMEM;
			
 
				+        return 0;
			
 
				+    }
			
 
				+    if (it->flags & RAX_ITER_EOF) {
			
 
				+        errno = 0;
			
 
				+        return 0;
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Go to the previous element in the scope of the iterator 'it'.
			
 
				+ * If EOF (or out of memory) is reached, 0 is returned, otherwise 1 is
			
 
				+ * returned. In case 0 is returned because of OOM, errno is set to ENOMEM. */
			
 
				+int raxPrev(raxIterator *it) {
			
 
				+    if (!raxIteratorPrevStep(it,0)) {
			
 
				+        errno = ENOMEM;
			
 
				+        return 0;
			
 
				+    }
			
 
				+    if (it->flags & RAX_ITER_EOF) {
			
 
				+        errno = 0;
			
 
				+        return 0;
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Perform a random walk starting in the current position of the iterator.
			
 
				+ * Return 0 if the tree is empty or on out of memory. Otherwise 1 is returned
			
 
				+ * and the iterator is set to the node reached after doing a random walk
			
 
				+ * of 'steps' steps. If the 'steps' argument is 0, the random walk is performed
			
 
				+ * using a random number of steps between 1 and two times the logarithm of
			
 
				+ * the number of elements.
			
 
				+ *
			
 
				+ * NOTE: if you use this function to generate random elements from the radix
			
 
				+ * tree, expect a disappointing distribution. A random walk produces good
			
 
				+ * random elements if the tree is not sparse, however in the case of a radix
			
 
				+ * tree certain keys will be reported much more often than others. At least
			
 
				+ * this function should be able to explore every possible element eventually. */
			
 
				+int raxRandomWalk(raxIterator *it, size_t steps) {
			
 
				+    if (it->rt->numele == 0) {
			
 
				+        it->flags |= RAX_ITER_EOF;
			
 
				+        return 0;
			
 
				+    }
			
 
				+
			
 
				+    if (steps == 0) {
			
 
				+        size_t fle = 1+floor(log(it->rt->numele));
			
 
				+        fle *= 2;
			
 
				+        steps = 1 + rand() % fle;
			
 
				+    }
			
 
				+
			
 
				+    raxNode *n = it->node;
			
 
				+    while(steps > 0 || !n->iskey) {
			
 
				+        int numchildren = n->iscompr ? 1 : n->size;
			
 
				+        int r = rand() % (numchildren+(n != it->rt->head));
			
 
				+
			
 
				+        if (r == numchildren) {
			
 
				+            /* Go up to parent. */
			
 
				+            n = raxStackPop(&it->stack);
			
 
				+            int todel = n->iscompr ? n->size : 1;
			
 
				+            raxIteratorDelChars(it,todel);
			
 
				+        } else {
			
 
				+            /* Select a random child. */
			
 
				+            if (n->iscompr) {
			
 
				+                if (!raxIteratorAddChars(it,n->data,n->size)) return 0;
			
 
				+            } else {
			
 
				+                if (!raxIteratorAddChars(it,n->data+r,1)) return 0;
			
 
				+            }
			
 
				+            raxNode **cp = raxNodeFirstChildPtr(n)+r;
			
 
				+            if (!raxStackPush(&it->stack,n)) return 0;
			
 
				+            memcpy(&n,cp,sizeof(n));
			
 
				+        }
			
 
				+        if (n->iskey) steps--;
			
 
				+    }
			
 
				+    it->node = n;
			
 
				+    it->data = raxGetData(it->node);
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Compare the key currently pointed by the iterator to the specified
			
 
				+ * key according to the specified operator. Returns 1 if the comparison is
			
 
				+ * true, otherwise 0 is returned. */
			
 
				+int raxCompare(raxIterator *iter, const char *op, unsigned char *key, size_t key_len) {
			
 
				+    int eq = 0, lt = 0, gt = 0;
			
 
				+
			
 
				+    if (op[0] == '=' || op[1] == '=') eq = 1;
			
 
				+    if (op[0] == '>') gt = 1;
			
 
				+    else if (op[0] == '<') lt = 1;
			
 
				+    else if (op[1] != '=') return 0; /* Syntax error. */
			
 
				+
			
 
				+    size_t minlen = key_len < iter->key_len ? key_len : iter->key_len;
			
 
				+    int cmp = memcmp(iter->key,key,minlen);
			
 
				+
			
 
				+    /* Handle == */
			
 
				+    if (lt == 0 && gt == 0) return cmp == 0 && key_len == iter->key_len;
			
 
				+
			
 
				+    /* Handle >, >=, <, <= */
			
 
				+    if (cmp == 0) {
			
 
				+        /* Same prefix: longer wins. */
			
 
				+        if (eq && key_len == iter->key_len) return 1;
			
 
				+        else if (lt) return iter->key_len < key_len;
			
 
				+        else if (gt) return iter->key_len > key_len;
			
 
				+        else return 0; /* Avoid warning, just 'eq' is handled before. */
			
 
				+    } else if (cmp > 0) {
			
 
				+        return gt ? 1 : 0;
			
 
				+    } else /* (cmp < 0) */ {
			
 
				+        return lt ? 1 : 0;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Free the iterator. */
			
 
				+void raxStop(raxIterator *it) {
			
 
				+    if (it->key != it->key_static_string) rax_free(it->key);
			
 
				+    raxStackFree(&it->stack);
			
 
				+}
			
 
				+
			
 
				+/* Return if the iterator is in an EOF state. This happens when raxSeek()
			
 
				+ * failed to seek an appropriate element, so that raxNext() or raxPrev()
			
 
				+ * will return zero, or when an EOF condition was reached while iterating
			
 
				+ * with raxNext() and raxPrev(). */
			
 
				+int raxEOF(raxIterator *it) {
			
 
				+    return it->flags & RAX_ITER_EOF;
			
 
				+}
			
 
				+
			
 
				+/* Return the number of elements inside the radix tree. */
			
 
				+uint64_t raxSize(rax *rax) {
			
 
				+    return rax->numele;
			
 
				+}
			
 
				+
			
 
				+/* ----------------------------- Introspection ------------------------------ */
			
 
				+
			
 
				+/* This function is mostly used for debugging and learning purposes.
			
 
				+ * It shows an ASCII representation of a tree on standard output, outline
			
 
				+ * all the nodes and the contained keys.
			
 
				+ *
			
 
				+ * The representation is as follow:
			
 
				+ *
			
 
				+ *  "foobar" (compressed node)
			
 
				+ *  [abc] (normal node with three children)
			
 
				+ *  [abc]=0x12345678 (node is a key, pointing to value 0x12345678)
			
 
				+ *  [] (a normal empty node)
			
 
				+ *
			
 
				+ *  Children are represented in new indented lines, each children prefixed by
			
 
				+ *  the "`-(x)" string, where "x" is the edge byte.
			
 
				+ *
			
 
				+ *  [abc]
			
 
				+ *   `-(a) "ladin"
			
 
				+ *   `-(b) [kj]
			
 
				+ *   `-(c) []
			
 
				+ *
			
 
				+ *  However when a node has a single child the following representation
			
 
				+ *  is used instead:
			
 
				+ *
			
 
				+ *  [abc] -> "ladin" -> []
			
 
				+ */
			
 
				+
			
 
				+/* The actual implementation of raxShow(). */
			
 
				+void raxRecursiveShow(int level, int lpad, raxNode *n) {
			
 
				+    char s = n->iscompr ? '"' : '[';
			
 
				+    char e = n->iscompr ? '"' : ']';
			
 
				+
			
 
				+    int numchars = printf("%c%.*s%c", s, n->size, n->data, e);
			
 
				+    if (n->iskey) {
			
 
				+        numchars += printf("=%p",raxGetData(n));
			
 
				+    }
			
 
				+
			
 
				+    int numchildren = n->iscompr ? 1 : n->size;
			
 
				+    /* Note that 7 and 4 magic constants are the string length
			
 
				+     * of " `-(x) " and " -> " respectively. */
			
 
				+    if (level) {
			
 
				+        lpad += (numchildren > 1) ? 7 : 4;
			
 
				+        if (numchildren == 1) lpad += numchars;
			
 
				+    }
			
 
				+    raxNode **cp = raxNodeFirstChildPtr(n);
			
 
				+    for (int i = 0; i < numchildren; i++) {
			
 
				+        char *branch = " `-(%c) ";
			
 
				+        if (numchildren > 1) {
			
 
				+            printf("\n");
			
 
				+            for (int j = 0; j < lpad; j++) putchar(' ');
			
 
				+            printf(branch,n->data[i]);
			
 
				+        } else {
			
 
				+            printf(" -> ");
			
 
				+        }
			
 
				+        raxNode *child;
			
 
				+        memcpy(&child,cp,sizeof(child));
			
 
				+        raxRecursiveShow(level+1,lpad,child);
			
 
				+        cp++;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Show a tree, as outlined in the comment above. */
			
 
				+void raxShow(rax *rax) {
			
 
				+    raxRecursiveShow(0,0,rax->head);
			
 
				+    putchar('\n');
			
 
				+}
			
 
				+
			
 
				+/* Used by debugnode() macro to show info about a given node. */
			
 
				+void raxDebugShowNode(const char *msg, raxNode *n) {
			
 
				+    if (raxDebugMsg == 0) return;
			
 
				+    printf("%s: %p [%.*s] key:%u size:%u children:",
			
 
				+        msg, (void*)n, (int)n->size, (char*)n->data, n->iskey, n->size);
			
 
				+    int numcld = n->iscompr ? 1 : n->size;
			
 
				+    raxNode **cldptr = raxNodeLastChildPtr(n) - (numcld-1);
			
 
				+    while(numcld--) {
			
 
				+        raxNode *child;
			
 
				+        memcpy(&child,cldptr,sizeof(child));
			
 
				+        cldptr++;
			
 
				+        printf("%p ", (void*)child);
			
 
				+    }
			
 
				+    printf("\n");
			
 
				+    fflush(stdout);
			
 
				+}
			
 
				+
			
 
				+/* Touch all the nodes of a tree returning a check sum. This is useful
			
 
				+ * in order to make Valgrind detect if there is something wrong while
			
 
				+ * reading the data structure.
			
 
				+ *
			
 
				+ * This function was used in order to identify Rax bugs after a big refactoring
			
 
				+ * using this technique:
			
 
				+ *
			
 
				+ * 1. The rax-test is executed using Valgrind, adding a printf() so that for
			
 
				+ *    the fuzz tester we see what iteration in the loop we are in.
			
 
				+ * 2. After every modification of the radix tree made by the fuzz tester
			
 
				+ *    in rax-test.c, we add a call to raxTouch().
			
 
				+ * 3. Now as soon as an operation will corrupt the tree, raxTouch() will
			
 
				+ *    detect it (via Valgrind) immediately. We can add more calls to narrow
			
 
				+ *    the state.
			
 
				+ * 4. At this point a good idea is to enable Rax debugging messages immediately
			
 
				+ *    before the moment the tree is corrupted, to see what happens.
			
 
				+ */
			
 
				+unsigned long raxTouch(raxNode *n) {
			
 
				+    debugf("Touching %p\n", (void*)n);
			
 
				+    unsigned long sum = 0;
			
 
				+    if (n->iskey) {
			
 
				+        sum += (unsigned long)raxGetData(n);
			
 
				+    }
			
 
				+
			
 
				+    int numchildren = n->iscompr ? 1 : n->size;
			
 
				+    raxNode **cp = raxNodeFirstChildPtr(n);
			
 
				+    int count = 0;
			
 
				+    for (int i = 0; i < numchildren; i++) {
			
 
				+        if (numchildren > 1) {
			
 
				+            sum += (long)n->data[i];
			
 
				+        }
			
 
				+        raxNode *child;
			
 
				+        memcpy(&child,cp,sizeof(child));
			
 
				+        if (child == (void*)0x65d1760) count++;
			
 
				+        if (count > 1) exit(1);
			
 
				+        sum += raxTouch(child);
			
 
				+        cp++;
			
 
				+    }
			
 
				+    return sum;
			
 
				+}
			
--- a/src/rax.h
+++ b/src/rax.h
@@ -0,0 +1,216 @@
 
				+/* Rax -- A radix tree implementation.
			
 
				+ *
			
 
				+ * Copyright (c) 2017-2018, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef RAX_H
			
 
				+#define RAX_H
			
 
				+
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+/* Representation of a radix tree as implemented in this file, that contains
			
 
				+ * the strings "foo", "foobar" and "footer" after the insertion of each
			
 
				+ * word. When the node represents a key inside the radix tree, we write it
			
 
				+ * between [], otherwise it is written between ().
			
 
				+ *
			
 
				+ * This is the vanilla representation:
			
 
				+ *
			
 
				+ *              (f) ""
			
 
				+ *                \
			
 
				+ *                (o) "f"
			
 
				+ *                  \
			
 
				+ *                  (o) "fo"
			
 
				+ *                    \
			
 
				+ *                  [t   b] "foo"
			
 
				+ *                  /     \
			
 
				+ *         "foot" (e)     (a) "foob"
			
 
				+ *                /         \
			
 
				+ *      "foote" (r)         (r) "fooba"
			
 
				+ *              /             \
			
 
				+ *    "footer" []             [] "foobar"
			
 
				+ *
			
 
				+ * However, this implementation implements a very common optimization where
			
 
				+ * successive nodes having a single child are "compressed" into the node
			
 
				+ * itself as a string of characters, each representing a next-level child,
			
 
				+ * and only the link to the node representing the last character node is
			
 
				+ * provided inside the representation. So the above representation is turned
			
 
				+ * into:
			
 
				+ *
			
 
				+ *                  ["foo"] ""
			
 
				+ *                     |
			
 
				+ *                  [t   b] "foo"
			
 
				+ *                  /     \
			
 
				+ *        "foot" ("er")    ("ar") "foob"
			
 
				+ *                 /          \
			
 
				+ *       "footer" []          [] "foobar"
			
 
				+ *
			
 
				+ * However this optimization makes the implementation a bit more complex.
			
 
				+ * For instance if a key "first" is added in the above radix tree, a
			
 
				+ * "node splitting" operation is needed, since the "foo" prefix is no longer
			
 
				+ * composed of nodes having a single child one after the other. This is the
			
 
				+ * above tree and the resulting node splitting after this event happens:
			
 
				+ *
			
 
				+ *
			
 
				+ *                    (f) ""
			
 
				+ *                    /
			
 
				+ *                 (i o) "f"
			
 
				+ *                 /   \
			
 
				+ *    "firs"  ("rst")  (o) "fo"
			
 
				+ *              /        \
			
 
				+ *    "first" []       [t   b] "foo"
			
 
				+ *                     /     \
			
 
				+ *           "foot" ("er")    ("ar") "foob"
			
 
				+ *                    /          \
			
 
				+ *          "footer" []          [] "foobar"
			
 
				+ *
			
 
				+ * Similarly after deletion, if a new chain of nodes having a single child
			
 
				+ * is created (the chain must also not include nodes that represent keys),
			
 
				+ * it must be compressed back into a single node.
			
 
				+ *
			
 
				+ */
			
 
				+
			
 
				+#define RAX_NODE_MAX_SIZE ((1<<29)-1)
			
 
				+typedef struct raxNode {
			
 
				+    uint32_t iskey:1;     /* Does this node contain a key? */
			
 
				+    uint32_t isnull:1;    /* Associated value is NULL (don't store it). */
			
 
				+    uint32_t iscompr:1;   /* Node is compressed. */
			
 
				+    uint32_t size:29;     /* Number of children, or compressed string len. */
			
 
				+    /* Data layout is as follows:
			
 
				+     *
			
 
				+     * If node is not compressed we have 'size' bytes, one for each children
			
 
				+     * character, and 'size' raxNode pointers, point to each child node.
			
 
				+     * Note how the character is not stored in the children but in the
			
 
				+     * edge of the parents:
			
 
				+     *
			
 
				+     * [header iscompr=0][abc][a-ptr][b-ptr][c-ptr](value-ptr?)
			
 
				+     *
			
 
				+     * if node is compressed (iscompr bit is 1) the node has 1 children.
			
 
				+     * In that case the 'size' bytes of the string stored immediately at
			
 
				+     * the start of the data section, represent a sequence of successive
			
 
				+     * nodes linked one after the other, for which only the last one in
			
 
				+     * the sequence is actually represented as a node, and pointed to by
			
 
				+     * the current compressed node.
			
 
				+     *
			
 
				+     * [header iscompr=1][xyz][z-ptr](value-ptr?)
			
 
				+     *
			
 
				+     * Both compressed and not compressed nodes can represent a key
			
 
				+     * with associated data in the radix tree at any level (not just terminal
			
 
				+     * nodes).
			
 
				+     *
			
 
				+     * If the node has an associated key (iskey=1) and is not NULL
			
 
				+     * (isnull=0), then after the raxNode pointers pointing to the
			
 
				+     * children, an additional value pointer is present (as you can see
			
 
				+     * in the representation above as "value-ptr" field).
			
 
				+     */
			
 
				+    unsigned char data[];
			
 
				+} raxNode;
			
 
				+
			
 
				+typedef struct rax {
			
 
				+    raxNode *head;
			
 
				+    uint64_t numele;
			
 
				+    uint64_t numnodes;
			
 
				+} rax;
			
 
				+
			
 
				+/* Stack data structure used by raxLowWalk() in order to, optionally, return
			
 
				+ * a list of parent nodes to the caller. The nodes do not have a "parent"
			
 
				+ * field for space concerns, so we use the auxiliary stack when needed. */
			
 
				+#define RAX_STACK_STATIC_ITEMS 32
			
 
				+typedef struct raxStack {
			
 
				+    void **stack; /* Points to static_items or an heap allocated array. */
			
 
				+    size_t items, maxitems; /* Number of items contained and total space. */
			
 
				+    /* Up to RAXSTACK_STACK_ITEMS items we avoid to allocate on the heap
			
 
				+     * and use this static array of pointers instead. */
			
 
				+    void *static_items[RAX_STACK_STATIC_ITEMS];
			
 
				+    int oom; /* True if pushing into this stack failed for OOM at some point. */
			
 
				+} raxStack;
			
 
				+
			
 
				+/* Optional callback used for iterators and be notified on each rax node,
			
 
				+ * including nodes not representing keys. If the callback returns true
			
 
				+ * the callback changed the node pointer in the iterator structure, and the
			
 
				+ * iterator implementation will have to replace the pointer in the radix tree
			
 
				+ * internals. This allows the callback to reallocate the node to perform
			
 
				+ * very special operations, normally not needed by normal applications.
			
 
				+ *
			
 
				+ * This callback is used to perform very low level analysis of the radix tree
			
 
				+ * structure, scanning each possible node (but the root node), or in order to
			
 
				+ * reallocate the nodes to reduce the allocation fragmentation (this is the
			
 
				+ * Redis application for this callback).
			
 
				+ *
			
 
				+ * This is currently only supported in forward iterations (raxNext) */
			
 
				+typedef int (*raxNodeCallback)(raxNode **noderef);
			
 
				+
			
 
				+/* Radix tree iterator state is encapsulated into this data structure. */
			
 
				+#define RAX_ITER_STATIC_LEN 128
			
 
				+#define RAX_ITER_JUST_SEEKED (1<<0) /* Iterator was just seeked. Return current
			
 
				+                                       element for the first iteration and
			
 
				+                                       clear the flag. */
			
 
				+#define RAX_ITER_EOF (1<<1)    /* End of iteration reached. */
			
 
				+#define RAX_ITER_SAFE (1<<2)   /* Safe iterator, allows operations while
			
 
				+                                  iterating. But it is slower. */
			
 
				+typedef struct raxIterator {
			
 
				+    int flags;
			
 
				+    rax *rt;                /* Radix tree we are iterating. */
			
 
				+    unsigned char *key;     /* The current string. */
			
 
				+    void *data;             /* Data associated to this key. */
			
 
				+    size_t key_len;         /* Current key length. */
			
 
				+    size_t key_max;         /* Max key len the current key buffer can hold. */
			
 
				+    unsigned char key_static_string[RAX_ITER_STATIC_LEN];
			
 
				+    raxNode *node;          /* Current node. Only for unsafe iteration. */
			
 
				+    raxStack stack;         /* Stack used for unsafe iteration. */
			
 
				+    raxNodeCallback node_cb; /* Optional node callback. Normally set to NULL. */
			
 
				+} raxIterator;
			
 
				+
			
 
				+/* A special pointer returned for not found items. */
			
 
				+extern void *raxNotFound;
			
 
				+
			
 
				+/* Exported API. */
			
 
				+rax *raxNew(void);
			
 
				+int raxInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
			
 
				+int raxTryInsert(rax *rax, unsigned char *s, size_t len, void *data, void **old);
			
 
				+int raxRemove(rax *rax, unsigned char *s, size_t len, void **old);
			
 
				+void *raxFind(rax *rax, unsigned char *s, size_t len);
			
 
				+void raxFree(rax *rax);
			
 
				+void raxFreeWithCallback(rax *rax, void (*free_callback)(void*));
			
 
				+void raxStart(raxIterator *it, rax *rt);
			
 
				+int raxSeek(raxIterator *it, const char *op, unsigned char *ele, size_t len);
			
 
				+int raxNext(raxIterator *it);
			
 
				+int raxPrev(raxIterator *it);
			
 
				+int raxRandomWalk(raxIterator *it, size_t steps);
			
 
				+int raxCompare(raxIterator *iter, const char *op, unsigned char *key, size_t key_len);
			
 
				+void raxStop(raxIterator *it);
			
 
				+int raxEOF(raxIterator *it);
			
 
				+void raxShow(rax *rax);
			
 
				+uint64_t raxSize(rax *rax);
			
 
				+unsigned long raxTouch(raxNode *n);
			
 
				+void raxSetDebugMsg(int onoff);
			
 
				+
			
 
				+/* Internal API. May be used by the node callback in order to access rax nodes
			
 
				+ * in a low level way, so this function is exported as well. */
			
 
				+void raxSetData(raxNode *n, void *data);
			
 
				+
			
 
				+#endif
			
--- a/src/rax_malloc.h
+++ b/src/rax_malloc.h
@@ -0,0 +1,44 @@
 
				+/* Rax -- A radix tree implementation.
			
 
				+ *
			
 
				+ * Copyright (c) 2017, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+/* Allocator selection.
			
 
				+ *
			
 
				+ * This file is used in order to change the Rax allocator at compile time.
			
 
				+ * Just define the following defines to what you want to use. Also add
			
 
				+ * the include of your alternate allocator if needed (not needed in order
			
 
				+ * to use the default libc allocator). */
			
 
				+
			
 
				+#ifndef RAX_ALLOC_H
			
 
				+#define RAX_ALLOC_H
			
 
				+#include "zmalloc.h"
			
 
				+#define rax_malloc zmalloc
			
 
				+#define rax_realloc zrealloc
			
 
				+#define rax_free zfree
			
 
				+#endif
			
--- a/src/redisassert.c
+++ b/src/redisassert.c
@@ -0,0 +1,53 @@
 
				+/* redisassert.c -- Implement the default _serverAssert and _serverPanic which 
			
 
				+ * simply print stack trace to standard error stream.
			
 
				+ * 
			
 
				+ * This file is shared by those modules that try to print some logs about stack trace 
			
 
				+ * but don't have their own implementations of functions in redisassert.h.
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2021, Andy Pan <panjf2000@gmail.com> and Redis Labs
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+#include <stdio.h> 
			
 
				+#include <stdlib.h>
			
 
				+#include <signal.h>
			
 
				+
			
 
				+void _serverAssert(const char *estr, const char *file, int line) {
			
 
				+    fprintf(stderr, "=== ASSERTION FAILED ===");
			
 
				+    fprintf(stderr, "==> %s:%d '%s' is not true",file,line,estr);
			
 
				+    raise(SIGSEGV);
			
 
				+}
			
 
				+
			
 
				+void _serverPanic(const char *file, int line, const char *msg, ...) {
			
 
				+    fprintf(stderr, "------------------------------------------------");
			
 
				+    fprintf(stderr, "!!! Software Failure. Press left mouse button to continue");
			
 
				+    fprintf(stderr, "Guru Meditation: %s #%s:%d",msg,file,line);
			
 
				+    abort();
			
 
				+}
			
--- a/src/redisassert.h
+++ b/src/redisassert.h
@@ -0,0 +1,49 @@
 
				+/* redisassert.h -- Drop in replacements assert.h that prints the stack trace
			
 
				+ *                  in the Redis logs.
			
 
				+ *
			
 
				+ * This file should be included instead of "assert.h" inside libraries used by
			
 
				+ * Redis that are using assertions, so instead of Redis disappearing with
			
 
				+ * SIGABORT, we get the details and stack trace inside the log file.
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __REDIS_ASSERT_H__
			
 
				+#define __REDIS_ASSERT_H__
			
 
				+
			
 
				+#include "config.h"
			
 
				+
			
 
				+#define assert(_e) (likely((_e))?(void)0 : (_serverAssert(#_e,__FILE__,__LINE__),redis_unreachable()))
			
 
				+#define panic(...) _serverPanic(__FILE__,__LINE__,__VA_ARGS__),redis_unreachable()
			
 
				+
			
 
				+void _serverAssert(char *estr, char *file, int line);
			
 
				+void _serverPanic(const char *file, int line, const char *msg, ...);
			
 
				+
			
 
				+#endif
			
--- a/src/sds.c
+++ b/src/sds.c
@@ -0,0 +1,1564 @@
 
				+/* SDSLib 2.0 -- A C dynamic strings library
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
			
 
				+ * Copyright (c) 2015, Oran Agra
			
 
				+ * Copyright (c) 2015, Redis Labs, Inc
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+#include <ctype.h>
			
 
				+#include <assert.h>
			
 
				+#include <limits.h>
			
 
				+#include "sds.h"
			
 
				+#include "sdsalloc.h"
			
 
				+
			
 
				+const char *SDS_NOINIT = "SDS_NOINIT";
			
 
				+
			
 
				+static inline int sdsHdrSize(char type) {
			
 
				+    switch(type&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            return sizeof(struct sdshdr5);
			
 
				+        case SDS_TYPE_8:
			
 
				+            return sizeof(struct sdshdr8);
			
 
				+        case SDS_TYPE_16:
			
 
				+            return sizeof(struct sdshdr16);
			
 
				+        case SDS_TYPE_32:
			
 
				+            return sizeof(struct sdshdr32);
			
 
				+        case SDS_TYPE_64:
			
 
				+            return sizeof(struct sdshdr64);
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+static inline char sdsReqType(size_t string_size) {
			
 
				+    if (string_size < 1<<5)
			
 
				+        return SDS_TYPE_5;
			
 
				+    if (string_size < 1<<8)
			
 
				+        return SDS_TYPE_8;
			
 
				+    if (string_size < 1<<16)
			
 
				+        return SDS_TYPE_16;
			
 
				+#if (LONG_MAX == LLONG_MAX)
			
 
				+    if (string_size < 1ll<<32)
			
 
				+        return SDS_TYPE_32;
			
 
				+    return SDS_TYPE_64;
			
 
				+#else
			
 
				+    return SDS_TYPE_32;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+static inline size_t sdsTypeMaxSize(char type) {
			
 
				+    if (type == SDS_TYPE_5)
			
 
				+        return (1<<5) - 1;
			
 
				+    if (type == SDS_TYPE_8)
			
 
				+        return (1<<8) - 1;
			
 
				+    if (type == SDS_TYPE_16)
			
 
				+        return (1<<16) - 1;
			
 
				+#if (LONG_MAX == LLONG_MAX)
			
 
				+    if (type == SDS_TYPE_32)
			
 
				+        return (1ll<<32) - 1;
			
 
				+#endif
			
 
				+    return -1; /* this is equivalent to the max SDS_TYPE_64 or SDS_TYPE_32 */
			
 
				+}
			
 
				+
			
 
				+/* Create a new sds string with the content specified by the 'init' pointer
			
 
				+ * and 'initlen'.
			
 
				+ * If NULL is used for 'init' the string is initialized with zero bytes.
			
 
				+ * If SDS_NOINIT is used, the buffer is left uninitialized;
			
 
				+ *
			
 
				+ * The string is always null-terminated (all the sds strings are, always) so
			
 
				+ * even if you create an sds string with:
			
 
				+ *
			
 
				+ * mystring = sdsnewlen("abc",3);
			
 
				+ *
			
 
				+ * You can print the string with printf() as there is an implicit \0 at the
			
 
				+ * end of the string. However the string is binary safe and can contain
			
 
				+ * \0 characters in the middle, as the length is stored in the sds header. */
			
 
				+sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
			
 
				+    void *sh;
			
 
				+    sds s;
			
 
				+    char type = sdsReqType(initlen);
			
 
				+    /* Empty strings are usually created in order to append. Use type 8
			
 
				+     * since type 5 is not good at this. */
			
 
				+    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
			
 
				+    int hdrlen = sdsHdrSize(type);
			
 
				+    unsigned char *fp; /* flags pointer. */
			
 
				+    size_t usable;
			
 
				+
			
 
				+    assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
			
 
				+    sh = trymalloc?
			
 
				+        s_trymalloc_usable(hdrlen+initlen+1, &usable) :
			
 
				+        s_malloc_usable(hdrlen+initlen+1, &usable);
			
 
				+    if (sh == NULL) return NULL;
			
 
				+    if (init==SDS_NOINIT)
			
 
				+        init = NULL;
			
 
				+    else if (!init)
			
 
				+        memset(sh, 0, hdrlen+initlen+1);
			
 
				+    s = (char*)sh+hdrlen;
			
 
				+    fp = ((unsigned char*)s)-1;
			
 
				+    usable = usable-hdrlen-1;
			
 
				+    if (usable > sdsTypeMaxSize(type))
			
 
				+        usable = sdsTypeMaxSize(type);
			
 
				+    switch(type) {
			
 
				+        case SDS_TYPE_5: {
			
 
				+            *fp = type | (initlen << SDS_TYPE_BITS);
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_8: {
			
 
				+            SDS_HDR_VAR(8,s);
			
 
				+            sh->len = initlen;
			
 
				+            sh->alloc = usable;
			
 
				+            *fp = type;
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_16: {
			
 
				+            SDS_HDR_VAR(16,s);
			
 
				+            sh->len = initlen;
			
 
				+            sh->alloc = usable;
			
 
				+            *fp = type;
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_32: {
			
 
				+            SDS_HDR_VAR(32,s);
			
 
				+            sh->len = initlen;
			
 
				+            sh->alloc = usable;
			
 
				+            *fp = type;
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_64: {
			
 
				+            SDS_HDR_VAR(64,s);
			
 
				+            sh->len = initlen;
			
 
				+            sh->alloc = usable;
			
 
				+            *fp = type;
			
 
				+            break;
			
 
				+        }
			
 
				+    }
			
 
				+    if (initlen && init)
			
 
				+        memcpy(s, init, initlen);
			
 
				+    s[initlen] = '\0';
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+sds sdsnewlen(const void *init, size_t initlen) {
			
 
				+    return _sdsnewlen(init, initlen, 0);
			
 
				+}
			
 
				+
			
 
				+sds sdstrynewlen(const void *init, size_t initlen) {
			
 
				+    return _sdsnewlen(init, initlen, 1);
			
 
				+}
			
 
				+
			
 
				+/* Create an empty (zero length) sds string. Even in this case the string
			
 
				+ * always has an implicit null term. */
			
 
				+sds sdsempty(void) {
			
 
				+    return sdsnewlen("",0);
			
 
				+}
			
 
				+
			
 
				+/* Create a new sds string starting from a null terminated C string. */
			
 
				+sds sdsnew(const char *init) {
			
 
				+    size_t initlen = (init == NULL) ? 0 : strlen(init);
			
 
				+    return sdsnewlen(init, initlen);
			
 
				+}
			
 
				+
			
 
				+/* Duplicate an sds string. */
			
 
				+sds sdsdup(const sds s) {
			
 
				+    return sdsnewlen(s, sdslen(s));
			
 
				+}
			
 
				+
			
 
				+/* Free an sds string. No operation is performed if 's' is NULL. */
			
 
				+void sdsfree(sds s) {
			
 
				+    if (s == NULL) return;
			
 
				+    s_free((char*)s-sdsHdrSize(s[-1]));
			
 
				+}
			
 
				+
			
 
				+/* Set the sds string length to the length as obtained with strlen(), so
			
 
				+ * considering as content only up to the first null term character.
			
 
				+ *
			
 
				+ * This function is useful when the sds string is hacked manually in some
			
 
				+ * way, like in the following example:
			
 
				+ *
			
 
				+ * s = sdsnew("foobar");
			
 
				+ * s[2] = '\0';
			
 
				+ * sdsupdatelen(s);
			
 
				+ * printf("%d\n", sdslen(s));
			
 
				+ *
			
 
				+ * The output will be "2", but if we comment out the call to sdsupdatelen()
			
 
				+ * the output will be "6" as the string was modified but the logical length
			
 
				+ * remains 6 bytes. */
			
 
				+void sdsupdatelen(sds s) {
			
 
				+    size_t reallen = strlen(s);
			
 
				+    sdssetlen(s, reallen);
			
 
				+}
			
 
				+
			
 
				+/* Modify an sds string in-place to make it empty (zero length).
			
 
				+ * However all the existing buffer is not discarded but set as free space
			
 
				+ * so that next append operations will not require allocations up to the
			
 
				+ * number of bytes previously available. */
			
 
				+void sdsclear(sds s) {
			
 
				+    sdssetlen(s, 0);
			
 
				+    s[0] = '\0';
			
 
				+}
			
 
				+
			
 
				+/* Enlarge the free space at the end of the sds string so that the caller
			
 
				+ * is sure that after calling this function can overwrite up to addlen
			
 
				+ * bytes after the end of the string, plus one more byte for nul term.
			
 
				+ * If there's already sufficient free space, this function returns without any
			
 
				+ * action, if there isn't sufficient free space, it'll allocate what's missing,
			
 
				+ * and possibly more:
			
 
				+ * When greedy is 1, enlarge more than needed, to avoid need for future reallocs
			
 
				+ * on incremental growth.
			
 
				+ * When greedy is 0, enlarge just enough so that there's free space for 'addlen'.
			
 
				+ *
			
 
				+ * Note: this does not change the *length* of the sds string as returned
			
 
				+ * by sdslen(), but only the free buffer space we have. */
			
 
				+sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {
			
 
				+    void *sh, *newsh;
			
 
				+    size_t avail = sdsavail(s);
			
 
				+    size_t len, newlen, reqlen;
			
 
				+    char type, oldtype = s[-1] & SDS_TYPE_MASK;
			
 
				+    int hdrlen;
			
 
				+    size_t usable;
			
 
				+
			
 
				+    /* Return ASAP if there is enough space left. */
			
 
				+    if (avail >= addlen) return s;
			
 
				+
			
 
				+    len = sdslen(s);
			
 
				+    sh = (char*)s-sdsHdrSize(oldtype);
			
 
				+    reqlen = newlen = (len+addlen);
			
 
				+    assert(newlen > len);   /* Catch size_t overflow */
			
 
				+    if (greedy == 1) {
			
 
				+        if (newlen < SDS_MAX_PREALLOC)
			
 
				+            newlen *= 2;
			
 
				+        else
			
 
				+            newlen += SDS_MAX_PREALLOC;
			
 
				+    }
			
 
				+
			
 
				+    type = sdsReqType(newlen);
			
 
				+
			
 
				+    /* Don't use type 5: the user is appending to the string and type 5 is
			
 
				+     * not able to remember empty space, so sdsMakeRoomFor() must be called
			
 
				+     * at every appending operation. */
			
 
				+    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
			
 
				+
			
 
				+    hdrlen = sdsHdrSize(type);
			
 
				+    assert(hdrlen + newlen + 1 > reqlen);  /* Catch size_t overflow */
			
 
				+    if (oldtype==type) {
			
 
				+        newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        s = (char*)newsh+hdrlen;
			
 
				+    } else {
			
 
				+        /* Since the header size changes, need to move the string forward,
			
 
				+         * and can't use realloc */
			
 
				+        newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        memcpy((char*)newsh+hdrlen, s, len+1);
			
 
				+        s_free(sh);
			
 
				+        s = (char*)newsh+hdrlen;
			
 
				+        s[-1] = type;
			
 
				+        sdssetlen(s, len);
			
 
				+    }
			
 
				+    usable = usable-hdrlen-1;
			
 
				+    if (usable > sdsTypeMaxSize(type))
			
 
				+        usable = sdsTypeMaxSize(type);
			
 
				+    sdssetalloc(s, usable);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Enlarge the free space at the end of the sds string more than needed,
			
 
				+ * This is useful to avoid repeated re-allocations when repeatedly appending to the sds. */
			
 
				+sds sdsMakeRoomFor(sds s, size_t addlen) {
			
 
				+    return _sdsMakeRoomFor(s, addlen, 1);
			
 
				+}
			
 
				+
			
 
				+/* Unlike sdsMakeRoomFor(), this one just grows to the necessary size. */
			
 
				+sds sdsMakeRoomForNonGreedy(sds s, size_t addlen) {
			
 
				+    return _sdsMakeRoomFor(s, addlen, 0);
			
 
				+}
			
 
				+
			
 
				+/* Reallocate the sds string so that it has no free space at the end. The
			
 
				+ * contained string remains not altered, but next concatenation operations
			
 
				+ * will require a reallocation.
			
 
				+ *
			
 
				+ * After the call, the passed sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call. */
			
 
				+sds sdsRemoveFreeSpace(sds s) {
			
 
				+    void *sh, *newsh;
			
 
				+    char type, oldtype = s[-1] & SDS_TYPE_MASK;
			
 
				+    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
			
 
				+    size_t len = sdslen(s);
			
 
				+    size_t avail = sdsavail(s);
			
 
				+    sh = (char*)s-oldhdrlen;
			
 
				+
			
 
				+    /* Return ASAP if there is no space left. */
			
 
				+    if (avail == 0) return s;
			
 
				+
			
 
				+    /* Check what would be the minimum SDS header that is just good enough to
			
 
				+     * fit this string. */
			
 
				+    type = sdsReqType(len);
			
 
				+    hdrlen = sdsHdrSize(type);
			
 
				+
			
 
				+    /* If the type is the same, or at least a large enough type is still
			
 
				+     * required, we just realloc(), letting the allocator to do the copy
			
 
				+     * only if really needed. Otherwise if the change is huge, we manually
			
 
				+     * reallocate the string to use the different header type. */
			
 
				+    if (oldtype==type || type > SDS_TYPE_8) {
			
 
				+        newsh = s_realloc(sh, oldhdrlen+len+1);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        s = (char*)newsh+oldhdrlen;
			
 
				+    } else {
			
 
				+        newsh = s_malloc(hdrlen+len+1);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        memcpy((char*)newsh+hdrlen, s, len+1);
			
 
				+        s_free(sh);
			
 
				+        s = (char*)newsh+hdrlen;
			
 
				+        s[-1] = type;
			
 
				+        sdssetlen(s, len);
			
 
				+    }
			
 
				+    sdssetalloc(s, len);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Resize the allocation, this can make the allocation bigger or smaller,
			
 
				+ * if the size is smaller than currently used len, the data will be truncated */
			
 
				+sds sdsResize(sds s, size_t size) {
			
 
				+    void *sh, *newsh;
			
 
				+    char type, oldtype = s[-1] & SDS_TYPE_MASK;
			
 
				+    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
			
 
				+    size_t len = sdslen(s);
			
 
				+    sh = (char*)s-oldhdrlen;
			
 
				+
			
 
				+    /* Return ASAP if the size is already good. */
			
 
				+    if (sdsalloc(s) == size) return s;
			
 
				+
			
 
				+    /* Truncate len if needed. */
			
 
				+    if (size < len) len = size;
			
 
				+
			
 
				+    /* Check what would be the minimum SDS header that is just good enough to
			
 
				+     * fit this string. */
			
 
				+    type = sdsReqType(size);
			
 
				+    /* Don't use type 5, it is not good for strings that are resized. */
			
 
				+    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
			
 
				+    hdrlen = sdsHdrSize(type);
			
 
				+
			
 
				+    /* If the type is the same, or can hold the size in it with low overhead
			
 
				+     * (larger than SDS_TYPE_8), we just realloc(), letting the allocator
			
 
				+     * to do the copy only if really needed. Otherwise if the change is
			
 
				+     * huge, we manually reallocate the string to use the different header
			
 
				+     * type. */
			
 
				+    if (oldtype==type || (type < oldtype && type > SDS_TYPE_8)) {
			
 
				+        newsh = s_realloc(sh, oldhdrlen+size+1);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        s = (char*)newsh+oldhdrlen;
			
 
				+    } else {
			
 
				+        newsh = s_malloc(hdrlen+size+1);
			
 
				+        if (newsh == NULL) return NULL;
			
 
				+        memcpy((char*)newsh+hdrlen, s, len);
			
 
				+        s_free(sh);
			
 
				+        s = (char*)newsh+hdrlen;
			
 
				+        s[-1] = type;
			
 
				+    }
			
 
				+    s[len] = 0;
			
 
				+    sdssetlen(s, len);
			
 
				+    sdssetalloc(s, size);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Return the total size of the allocation of the specified sds string,
			
 
				+ * including:
			
 
				+ * 1) The sds header before the pointer.
			
 
				+ * 2) The string.
			
 
				+ * 3) The free buffer at the end if any.
			
 
				+ * 4) The implicit null term.
			
 
				+ */
			
 
				+size_t sdsAllocSize(sds s) {
			
 
				+    size_t alloc = sdsalloc(s);
			
 
				+    return sdsHdrSize(s[-1])+alloc+1;
			
 
				+}
			
 
				+
			
 
				+/* Return the pointer of the actual SDS allocation (normally SDS strings
			
 
				+ * are referenced by the start of the string buffer). */
			
 
				+void *sdsAllocPtr(sds s) {
			
 
				+    return (void*) (s-sdsHdrSize(s[-1]));
			
 
				+}
			
 
				+
			
 
				+/* Increment the sds length and decrements the left free space at the
			
 
				+ * end of the string according to 'incr'. Also set the null term
			
 
				+ * in the new end of the string.
			
 
				+ *
			
 
				+ * This function is used in order to fix the string length after the
			
 
				+ * user calls sdsMakeRoomFor(), writes something after the end of
			
 
				+ * the current string, and finally needs to set the new length.
			
 
				+ *
			
 
				+ * Note: it is possible to use a negative increment in order to
			
 
				+ * right-trim the string.
			
 
				+ *
			
 
				+ * Usage example:
			
 
				+ *
			
 
				+ * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the
			
 
				+ * following schema, to cat bytes coming from the kernel to the end of an
			
 
				+ * sds string without copying into an intermediate buffer:
			
 
				+ *
			
 
				+ * oldlen = sdslen(s);
			
 
				+ * s = sdsMakeRoomFor(s, BUFFER_SIZE);
			
 
				+ * nread = read(fd, s+oldlen, BUFFER_SIZE);
			
 
				+ * ... check for nread <= 0 and handle it ...
			
 
				+ * sdsIncrLen(s, nread);
			
 
				+ */
			
 
				+void sdsIncrLen(sds s, ssize_t incr) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    size_t len;
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5: {
			
 
				+            unsigned char *fp = ((unsigned char*)s)-1;
			
 
				+            unsigned char oldlen = SDS_TYPE_5_LEN(flags);
			
 
				+            assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
			
 
				+            *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
			
 
				+            len = oldlen+incr;
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_8: {
			
 
				+            SDS_HDR_VAR(8,s);
			
 
				+            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
			
 
				+            len = (sh->len += incr);
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_16: {
			
 
				+            SDS_HDR_VAR(16,s);
			
 
				+            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
			
 
				+            len = (sh->len += incr);
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_32: {
			
 
				+            SDS_HDR_VAR(32,s);
			
 
				+            assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
			
 
				+            len = (sh->len += incr);
			
 
				+            break;
			
 
				+        }
			
 
				+        case SDS_TYPE_64: {
			
 
				+            SDS_HDR_VAR(64,s);
			
 
				+            assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
			
 
				+            len = (sh->len += incr);
			
 
				+            break;
			
 
				+        }
			
 
				+        default: len = 0; /* Just to avoid compilation warnings. */
			
 
				+    }
			
 
				+    s[len] = '\0';
			
 
				+}
			
 
				+
			
 
				+/* Grow the sds to have the specified length. Bytes that were not part of
			
 
				+ * the original length of the sds will be set to zero.
			
 
				+ *
			
 
				+ * if the specified length is smaller than the current length, no operation
			
 
				+ * is performed. */
			
 
				+sds sdsgrowzero(sds s, size_t len) {
			
 
				+    size_t curlen = sdslen(s);
			
 
				+
			
 
				+    if (len <= curlen) return s;
			
 
				+    s = sdsMakeRoomFor(s,len-curlen);
			
 
				+    if (s == NULL) return NULL;
			
 
				+
			
 
				+    /* Make sure added region doesn't contain garbage */
			
 
				+    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
			
 
				+    sdssetlen(s, len);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
			
 
				+ * end of the specified sds string 's'.
			
 
				+ *
			
 
				+ * After the call, the passed sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call. */
			
 
				+sds sdscatlen(sds s, const void *t, size_t len) {
			
 
				+    size_t curlen = sdslen(s);
			
 
				+
			
 
				+    s = sdsMakeRoomFor(s,len);
			
 
				+    if (s == NULL) return NULL;
			
 
				+    memcpy(s+curlen, t, len);
			
 
				+    sdssetlen(s, curlen+len);
			
 
				+    s[curlen+len] = '\0';
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Append the specified null terminated C string to the sds string 's'.
			
 
				+ *
			
 
				+ * After the call, the passed sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call. */
			
 
				+sds sdscat(sds s, const char *t) {
			
 
				+    return sdscatlen(s, t, strlen(t));
			
 
				+}
			
 
				+
			
 
				+/* Append the specified sds 't' to the existing sds 's'.
			
 
				+ *
			
 
				+ * After the call, the modified sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call. */
			
 
				+sds sdscatsds(sds s, const sds t) {
			
 
				+    return sdscatlen(s, t, sdslen(t));
			
 
				+}
			
 
				+
			
 
				+/* Destructively modify the sds string 's' to hold the specified binary
			
 
				+ * safe string pointed by 't' of length 'len' bytes. */
			
 
				+sds sdscpylen(sds s, const char *t, size_t len) {
			
 
				+    if (sdsalloc(s) < len) {
			
 
				+        s = sdsMakeRoomFor(s,len-sdslen(s));
			
 
				+        if (s == NULL) return NULL;
			
 
				+    }
			
 
				+    memcpy(s, t, len);
			
 
				+    s[len] = '\0';
			
 
				+    sdssetlen(s, len);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Like sdscpylen() but 't' must be a null-terminated string so that the length
			
 
				+ * of the string is obtained with strlen(). */
			
 
				+sds sdscpy(sds s, const char *t) {
			
 
				+    return sdscpylen(s, t, strlen(t));
			
 
				+}
			
 
				+
			
 
				+/* Helper for sdscatlonglong() doing the actual number -> string
			
 
				+ * conversion. 's' must point to a string with room for at least
			
 
				+ * SDS_LLSTR_SIZE bytes.
			
 
				+ *
			
 
				+ * The function returns the length of the null-terminated string
			
 
				+ * representation stored at 's'. */
			
 
				+#define SDS_LLSTR_SIZE 21
			
 
				+int sdsll2str(char *s, long long value) {
			
 
				+    char *p, aux;
			
 
				+    unsigned long long v;
			
 
				+    size_t l;
			
 
				+
			
 
				+    /* Generate the string representation, this method produces
			
 
				+     * a reversed string. */
			
 
				+    if (value < 0) {
			
 
				+        /* Since v is unsigned, if value==LLONG_MIN, -LLONG_MIN will overflow. */
			
 
				+        if (value != LLONG_MIN) {
			
 
				+            v = -value;
			
 
				+        } else {
			
 
				+            v = ((unsigned long long)LLONG_MAX) + 1;
			
 
				+        }
			
 
				+    } else {
			
 
				+        v = value;
			
 
				+    }
			
 
				+
			
 
				+    p = s;
			
 
				+    do {
			
 
				+        *p++ = '0'+(v%10);
			
 
				+        v /= 10;
			
 
				+    } while(v);
			
 
				+    if (value < 0) *p++ = '-';
			
 
				+
			
 
				+    /* Compute length and add null term. */
			
 
				+    l = p-s;
			
 
				+    *p = '\0';
			
 
				+
			
 
				+    /* Reverse the string. */
			
 
				+    p--;
			
 
				+    while(s < p) {
			
 
				+        aux = *s;
			
 
				+        *s = *p;
			
 
				+        *p = aux;
			
 
				+        s++;
			
 
				+        p--;
			
 
				+    }
			
 
				+    return l;
			
 
				+}
			
 
				+
			
 
				+/* Identical sdsll2str(), but for unsigned long long type. */
			
 
				+int sdsull2str(char *s, unsigned long long v) {
			
 
				+    char *p, aux;
			
 
				+    size_t l;
			
 
				+
			
 
				+    /* Generate the string representation, this method produces
			
 
				+     * a reversed string. */
			
 
				+    p = s;
			
 
				+    do {
			
 
				+        *p++ = '0'+(v%10);
			
 
				+        v /= 10;
			
 
				+    } while(v);
			
 
				+
			
 
				+    /* Compute length and add null term. */
			
 
				+    l = p-s;
			
 
				+    *p = '\0';
			
 
				+
			
 
				+    /* Reverse the string. */
			
 
				+    p--;
			
 
				+    while(s < p) {
			
 
				+        aux = *s;
			
 
				+        *s = *p;
			
 
				+        *p = aux;
			
 
				+        s++;
			
 
				+        p--;
			
 
				+    }
			
 
				+    return l;
			
 
				+}
			
 
				+
			
 
				+/* Create an sds string from a long long value. It is much faster than:
			
 
				+ *
			
 
				+ * sdscatprintf(sdsempty(),"%lld\n", value);
			
 
				+ */
			
 
				+sds sdsfromlonglong(long long value) {
			
 
				+    char buf[SDS_LLSTR_SIZE];
			
 
				+    int len = sdsll2str(buf,value);
			
 
				+
			
 
				+    return sdsnewlen(buf,len);
			
 
				+}
			
 
				+
			
 
				+/* Like sdscatprintf() but gets va_list instead of being variadic. */
			
 
				+sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
			
 
				+    va_list cpy;
			
 
				+    char staticbuf[1024], *buf = staticbuf, *t;
			
 
				+    size_t buflen = strlen(fmt)*2;
			
 
				+    int bufstrlen;
			
 
				+
			
 
				+    /* We try to start using a static buffer for speed.
			
 
				+     * If not possible we revert to heap allocation. */
			
 
				+    if (buflen > sizeof(staticbuf)) {
			
 
				+        buf = s_malloc(buflen);
			
 
				+        if (buf == NULL) return NULL;
			
 
				+    } else {
			
 
				+        buflen = sizeof(staticbuf);
			
 
				+    }
			
 
				+
			
 
				+    /* Alloc enough space for buffer and \0 after failing to
			
 
				+     * fit the string in the current buffer size. */
			
 
				+    while(1) {
			
 
				+        va_copy(cpy,ap);
			
 
				+        bufstrlen = vsnprintf(buf, buflen, fmt, cpy);
			
 
				+        va_end(cpy);
			
 
				+        if (bufstrlen < 0) {
			
 
				+            if (buf != staticbuf) s_free(buf);
			
 
				+            return NULL;
			
 
				+        }
			
 
				+        if (((size_t)bufstrlen) >= buflen) {
			
 
				+            if (buf != staticbuf) s_free(buf);
			
 
				+            buflen = ((size_t)bufstrlen) + 1;
			
 
				+            buf = s_malloc(buflen);
			
 
				+            if (buf == NULL) return NULL;
			
 
				+            continue;
			
 
				+        }
			
 
				+        break;
			
 
				+    }
			
 
				+
			
 
				+    /* Finally concat the obtained string to the SDS string and return it. */
			
 
				+    t = sdscatlen(s, buf, bufstrlen);
			
 
				+    if (buf != staticbuf) s_free(buf);
			
 
				+    return t;
			
 
				+}
			
 
				+
			
 
				+/* Append to the sds string 's' a string obtained using printf-alike format
			
 
				+ * specifier.
			
 
				+ *
			
 
				+ * After the call, the modified sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call.
			
 
				+ *
			
 
				+ * Example:
			
 
				+ *
			
 
				+ * s = sdsnew("Sum is: ");
			
 
				+ * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
			
 
				+ *
			
 
				+ * Often you need to create a string from scratch with the printf-alike
			
 
				+ * format. When this is the need, just use sdsempty() as the target string:
			
 
				+ *
			
 
				+ * s = sdscatprintf(sdsempty(), "... your format ...", args);
			
 
				+ */
			
 
				+sds sdscatprintf(sds s, const char *fmt, ...) {
			
 
				+    va_list ap;
			
 
				+    char *t;
			
 
				+    va_start(ap, fmt);
			
 
				+    t = sdscatvprintf(s,fmt,ap);
			
 
				+    va_end(ap);
			
 
				+    return t;
			
 
				+}
			
 
				+
			
 
				+/* This function is similar to sdscatprintf, but much faster as it does
			
 
				+ * not rely on sprintf() family functions implemented by the libc that
			
 
				+ * are often very slow. Moreover directly handling the sds string as
			
 
				+ * new data is concatenated provides a performance improvement.
			
 
				+ *
			
 
				+ * However this function only handles an incompatible subset of printf-alike
			
 
				+ * format specifiers:
			
 
				+ *
			
 
				+ * %s - C String
			
 
				+ * %S - SDS string
			
 
				+ * %i - signed int
			
 
				+ * %I - 64 bit signed integer (long long, int64_t)
			
 
				+ * %u - unsigned int
			
 
				+ * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
			
 
				+ * %% - Verbatim "%" character.
			
 
				+ */
			
 
				+sds sdscatfmt(sds s, char const *fmt, ...) {
			
 
				+    size_t initlen = sdslen(s);
			
 
				+    const char *f = fmt;
			
 
				+    long i;
			
 
				+    va_list ap;
			
 
				+
			
 
				+    /* To avoid continuous reallocations, let's start with a buffer that
			
 
				+     * can hold at least two times the format string itself. It's not the
			
 
				+     * best heuristic but seems to work in practice. */
			
 
				+    s = sdsMakeRoomFor(s, strlen(fmt)*2);
			
 
				+    va_start(ap,fmt);
			
 
				+    f = fmt;    /* Next format specifier byte to process. */
			
 
				+    i = initlen; /* Position of the next byte to write to dest str. */
			
 
				+    while(*f) {
			
 
				+        char next, *str;
			
 
				+        size_t l;
			
 
				+        long long num;
			
 
				+        unsigned long long unum;
			
 
				+
			
 
				+        /* Make sure there is always space for at least 1 char. */
			
 
				+        if (sdsavail(s)==0) {
			
 
				+            s = sdsMakeRoomFor(s,1);
			
 
				+        }
			
 
				+
			
 
				+        switch(*f) {
			
 
				+        case '%':
			
 
				+            next = *(f+1);
			
 
				+            if (next == '\0') break;
			
 
				+            f++;
			
 
				+            switch(next) {
			
 
				+            case 's':
			
 
				+            case 'S':
			
 
				+                str = va_arg(ap,char*);
			
 
				+                l = (next == 's') ? strlen(str) : sdslen(str);
			
 
				+                if (sdsavail(s) < l) {
			
 
				+                    s = sdsMakeRoomFor(s,l);
			
 
				+                }
			
 
				+                memcpy(s+i,str,l);
			
 
				+                sdsinclen(s,l);
			
 
				+                i += l;
			
 
				+                break;
			
 
				+            case 'i':
			
 
				+            case 'I':
			
 
				+                if (next == 'i')
			
 
				+                    num = va_arg(ap,int);
			
 
				+                else
			
 
				+                    num = va_arg(ap,long long);
			
 
				+                {
			
 
				+                    char buf[SDS_LLSTR_SIZE];
			
 
				+                    l = sdsll2str(buf,num);
			
 
				+                    if (sdsavail(s) < l) {
			
 
				+                        s = sdsMakeRoomFor(s,l);
			
 
				+                    }
			
 
				+                    memcpy(s+i,buf,l);
			
 
				+                    sdsinclen(s,l);
			
 
				+                    i += l;
			
 
				+                }
			
 
				+                break;
			
 
				+            case 'u':
			
 
				+            case 'U':
			
 
				+                if (next == 'u')
			
 
				+                    unum = va_arg(ap,unsigned int);
			
 
				+                else
			
 
				+                    unum = va_arg(ap,unsigned long long);
			
 
				+                {
			
 
				+                    char buf[SDS_LLSTR_SIZE];
			
 
				+                    l = sdsull2str(buf,unum);
			
 
				+                    if (sdsavail(s) < l) {
			
 
				+                        s = sdsMakeRoomFor(s,l);
			
 
				+                    }
			
 
				+                    memcpy(s+i,buf,l);
			
 
				+                    sdsinclen(s,l);
			
 
				+                    i += l;
			
 
				+                }
			
 
				+                break;
			
 
				+            default: /* Handle %% and generally %<unknown>. */
			
 
				+                s[i++] = next;
			
 
				+                sdsinclen(s,1);
			
 
				+                break;
			
 
				+            }
			
 
				+            break;
			
 
				+        default:
			
 
				+            s[i++] = *f;
			
 
				+            sdsinclen(s,1);
			
 
				+            break;
			
 
				+        }
			
 
				+        f++;
			
 
				+    }
			
 
				+    va_end(ap);
			
 
				+
			
 
				+    /* Add null-term */
			
 
				+    s[i] = '\0';
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Remove the part of the string from left and from right composed just of
			
 
				+ * contiguous characters found in 'cset', that is a null terminated C string.
			
 
				+ *
			
 
				+ * After the call, the modified sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call.
			
 
				+ *
			
 
				+ * Example:
			
 
				+ *
			
 
				+ * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
			
 
				+ * s = sdstrim(s,"Aa. :");
			
 
				+ * printf("%s\n", s);
			
 
				+ *
			
 
				+ * Output will be just "HelloWorld".
			
 
				+ */
			
 
				+sds sdstrim(sds s, const char *cset) {
			
 
				+    char *end, *sp, *ep;
			
 
				+    size_t len;
			
 
				+
			
 
				+    sp = s;
			
 
				+    ep = end = s+sdslen(s)-1;
			
 
				+    while(sp <= end && strchr(cset, *sp)) sp++;
			
 
				+    while(ep > sp && strchr(cset, *ep)) ep--;
			
 
				+    len = (ep-sp)+1;
			
 
				+    if (s != sp) memmove(s, sp, len);
			
 
				+    s[len] = '\0';
			
 
				+    sdssetlen(s,len);
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Changes the input string to be a subset of the original.
			
 
				+ * It does not release the free space in the string, so a call to
			
 
				+ * sdsRemoveFreeSpace may be wise after. */
			
 
				+void sdssubstr(sds s, size_t start, size_t len) {
			
 
				+    /* Clamp out of range input */
			
 
				+    size_t oldlen = sdslen(s);
			
 
				+    if (start >= oldlen) start = len = 0;
			
 
				+    if (len > oldlen-start) len = oldlen-start;
			
 
				+
			
 
				+    /* Move the data */
			
 
				+    if (len) memmove(s, s+start, len);
			
 
				+    s[len] = 0;
			
 
				+    sdssetlen(s,len);
			
 
				+}
			
 
				+
			
 
				+/* Turn the string into a smaller (or equal) string containing only the
			
 
				+ * substring specified by the 'start' and 'end' indexes.
			
 
				+ *
			
 
				+ * start and end can be negative, where -1 means the last character of the
			
 
				+ * string, -2 the penultimate character, and so forth.
			
 
				+ *
			
 
				+ * The interval is inclusive, so the start and end characters will be part
			
 
				+ * of the resulting string.
			
 
				+ *
			
 
				+ * The string is modified in-place.
			
 
				+ *
			
 
				+ * NOTE: this function can be misleading and can have unexpected behaviour,
			
 
				+ * specifically when you want the length of the new string to be 0.
			
 
				+ * Having start==end will result in a string with one character.
			
 
				+ * please consider using sdssubstr instead.
			
 
				+ *
			
 
				+ * Example:
			
 
				+ *
			
 
				+ * s = sdsnew("Hello World");
			
 
				+ * sdsrange(s,1,-1); => "ello World"
			
 
				+ */
			
 
				+void sdsrange(sds s, ssize_t start, ssize_t end) {
			
 
				+    size_t newlen, len = sdslen(s);
			
 
				+    if (len == 0) return;
			
 
				+    if (start < 0)
			
 
				+        start = len + start;
			
 
				+    if (end < 0)
			
 
				+        end = len + end;
			
 
				+    newlen = (start > end) ? 0 : (end-start)+1;
			
 
				+    sdssubstr(s, start, newlen);
			
 
				+}
			
 
				+
			
 
				+/* Apply tolower() to every character of the sds string 's'. */
			
 
				+void sdstolower(sds s) {
			
 
				+    size_t len = sdslen(s), j;
			
 
				+
			
 
				+    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
			
 
				+}
			
 
				+
			
 
				+/* Apply toupper() to every character of the sds string 's'. */
			
 
				+void sdstoupper(sds s) {
			
 
				+    size_t len = sdslen(s), j;
			
 
				+
			
 
				+    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
			
 
				+}
			
 
				+
			
 
				+/* Compare two sds strings s1 and s2 with memcmp().
			
 
				+ *
			
 
				+ * Return value:
			
 
				+ *
			
 
				+ *     positive if s1 > s2.
			
 
				+ *     negative if s1 < s2.
			
 
				+ *     0 if s1 and s2 are exactly the same binary string.
			
 
				+ *
			
 
				+ * If two strings share exactly the same prefix, but one of the two has
			
 
				+ * additional characters, the longer string is considered to be greater than
			
 
				+ * the smaller one. */
			
 
				+int sdscmp(const sds s1, const sds s2) {
			
 
				+    size_t l1, l2, minlen;
			
 
				+    int cmp;
			
 
				+
			
 
				+    l1 = sdslen(s1);
			
 
				+    l2 = sdslen(s2);
			
 
				+    minlen = (l1 < l2) ? l1 : l2;
			
 
				+    cmp = memcmp(s1,s2,minlen);
			
 
				+    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
			
 
				+    return cmp;
			
 
				+}
			
 
				+
			
 
				+/* Split 's' with separator in 'sep'. An array
			
 
				+ * of sds strings is returned. *count will be set
			
 
				+ * by reference to the number of tokens returned.
			
 
				+ *
			
 
				+ * On out of memory, zero length string, zero length
			
 
				+ * separator, NULL is returned.
			
 
				+ *
			
 
				+ * Note that 'sep' is able to split a string using
			
 
				+ * a multi-character separator. For example
			
 
				+ * sdssplit("foo_-_bar","_-_"); will return two
			
 
				+ * elements "foo" and "bar".
			
 
				+ *
			
 
				+ * This version of the function is binary-safe but
			
 
				+ * requires length arguments. sdssplit() is just the
			
 
				+ * same function but for zero-terminated strings.
			
 
				+ */
			
 
				+sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) {
			
 
				+    int elements = 0, slots = 5;
			
 
				+    long start = 0, j;
			
 
				+    sds *tokens;
			
 
				+
			
 
				+    if (seplen < 1 || len < 0) return NULL;
			
 
				+
			
 
				+    tokens = s_malloc(sizeof(sds)*slots);
			
 
				+    if (tokens == NULL) return NULL;
			
 
				+
			
 
				+    if (len == 0) {
			
 
				+        *count = 0;
			
 
				+        return tokens;
			
 
				+    }
			
 
				+    for (j = 0; j < (len-(seplen-1)); j++) {
			
 
				+        /* make sure there is room for the next element and the final one */
			
 
				+        if (slots < elements+2) {
			
 
				+            sds *newtokens;
			
 
				+
			
 
				+            slots *= 2;
			
 
				+            newtokens = s_realloc(tokens,sizeof(sds)*slots);
			
 
				+            if (newtokens == NULL) goto cleanup;
			
 
				+            tokens = newtokens;
			
 
				+        }
			
 
				+        /* search the separator */
			
 
				+        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
			
 
				+            tokens[elements] = sdsnewlen(s+start,j-start);
			
 
				+            if (tokens[elements] == NULL) goto cleanup;
			
 
				+            elements++;
			
 
				+            start = j+seplen;
			
 
				+            j = j+seplen-1; /* skip the separator */
			
 
				+        }
			
 
				+    }
			
 
				+    /* Add the final element. We are sure there is room in the tokens array. */
			
 
				+    tokens[elements] = sdsnewlen(s+start,len-start);
			
 
				+    if (tokens[elements] == NULL) goto cleanup;
			
 
				+    elements++;
			
 
				+    *count = elements;
			
 
				+    return tokens;
			
 
				+
			
 
				+cleanup:
			
 
				+    {
			
 
				+        int i;
			
 
				+        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
			
 
				+        s_free(tokens);
			
 
				+        *count = 0;
			
 
				+        return NULL;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
			
 
				+void sdsfreesplitres(sds *tokens, int count) {
			
 
				+    if (!tokens) return;
			
 
				+    while(count--)
			
 
				+        sdsfree(tokens[count]);
			
 
				+    s_free(tokens);
			
 
				+}
			
 
				+
			
 
				+/* Append to the sds string "s" an escaped string representation where
			
 
				+ * all the non-printable characters (tested with isprint()) are turned into
			
 
				+ * escapes in the form "\n\r\a...." or "\x<hex-number>".
			
 
				+ *
			
 
				+ * After the call, the modified sds string is no longer valid and all the
			
 
				+ * references must be substituted with the new pointer returned by the call. */
			
 
				+sds sdscatrepr(sds s, const char *p, size_t len) {
			
 
				+    s = sdscatlen(s,"\"",1);
			
 
				+    while(len--) {
			
 
				+        switch(*p) {
			
 
				+        case '\\':
			
 
				+        case '"':
			
 
				+            s = sdscatprintf(s,"\\%c",*p);
			
 
				+            break;
			
 
				+        case '\n': s = sdscatlen(s,"\\n",2); break;
			
 
				+        case '\r': s = sdscatlen(s,"\\r",2); break;
			
 
				+        case '\t': s = sdscatlen(s,"\\t",2); break;
			
 
				+        case '\a': s = sdscatlen(s,"\\a",2); break;
			
 
				+        case '\b': s = sdscatlen(s,"\\b",2); break;
			
 
				+        default:
			
 
				+            if (isprint(*p))
			
 
				+                s = sdscatprintf(s,"%c",*p);
			
 
				+            else
			
 
				+                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
			
 
				+            break;
			
 
				+        }
			
 
				+        p++;
			
 
				+    }
			
 
				+    return sdscatlen(s,"\"",1);
			
 
				+}
			
 
				+
			
 
				+/* Helper function for sdssplitargs() that returns non zero if 'c'
			
 
				+ * is a valid hex digit. */
			
 
				+int is_hex_digit(char c) {
			
 
				+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
			
 
				+           (c >= 'A' && c <= 'F');
			
 
				+}
			
 
				+
			
 
				+/* Helper function for sdssplitargs() that converts a hex digit into an
			
 
				+ * integer from 0 to 15 */
			
 
				+int hex_digit_to_int(char c) {
			
 
				+    switch(c) {
			
 
				+    case '0': return 0;
			
 
				+    case '1': return 1;
			
 
				+    case '2': return 2;
			
 
				+    case '3': return 3;
			
 
				+    case '4': return 4;
			
 
				+    case '5': return 5;
			
 
				+    case '6': return 6;
			
 
				+    case '7': return 7;
			
 
				+    case '8': return 8;
			
 
				+    case '9': return 9;
			
 
				+    case 'a': case 'A': return 10;
			
 
				+    case 'b': case 'B': return 11;
			
 
				+    case 'c': case 'C': return 12;
			
 
				+    case 'd': case 'D': return 13;
			
 
				+    case 'e': case 'E': return 14;
			
 
				+    case 'f': case 'F': return 15;
			
 
				+    default: return 0;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Split a line into arguments, where every argument can be in the
			
 
				+ * following programming-language REPL-alike form:
			
 
				+ *
			
 
				+ * foo bar "newline are supported\n" and "\xff\x00otherstuff"
			
 
				+ *
			
 
				+ * The number of arguments is stored into *argc, and an array
			
 
				+ * of sds is returned.
			
 
				+ *
			
 
				+ * The caller should free the resulting array of sds strings with
			
 
				+ * sdsfreesplitres().
			
 
				+ *
			
 
				+ * Note that sdscatrepr() is able to convert back a string into
			
 
				+ * a quoted string in the same format sdssplitargs() is able to parse.
			
 
				+ *
			
 
				+ * The function returns the allocated tokens on success, even when the
			
 
				+ * input string is empty, or NULL if the input contains unbalanced
			
 
				+ * quotes or closed quotes followed by non space characters
			
 
				+ * as in: "foo"bar or "foo'
			
 
				+ */
			
 
				+sds *sdssplitargs(const char *line, int *argc) {
			
 
				+    const char *p = line;
			
 
				+    char *current = NULL;
			
 
				+    char **vector = NULL;
			
 
				+
			
 
				+    *argc = 0;
			
 
				+    while(1) {
			
 
				+        /* skip blanks */
			
 
				+        while(*p && isspace(*p)) p++;
			
 
				+        if (*p) {
			
 
				+            /* get a token */
			
 
				+            int inq=0;  /* set to 1 if we are in "quotes" */
			
 
				+            int insq=0; /* set to 1 if we are in 'single quotes' */
			
 
				+            int done=0;
			
 
				+
			
 
				+            if (current == NULL) current = sdsempty();
			
 
				+            while(!done) {
			
 
				+                if (inq) {
			
 
				+                    if (*p == '\\' && *(p+1) == 'x' &&
			
 
				+                                             is_hex_digit(*(p+2)) &&
			
 
				+                                             is_hex_digit(*(p+3)))
			
 
				+                    {
			
 
				+                        unsigned char byte;
			
 
				+
			
 
				+                        byte = (hex_digit_to_int(*(p+2))*16)+
			
 
				+                                hex_digit_to_int(*(p+3));
			
 
				+                        current = sdscatlen(current,(char*)&byte,1);
			
 
				+                        p += 3;
			
 
				+                    } else if (*p == '\\' && *(p+1)) {
			
 
				+                        char c;
			
 
				+
			
 
				+                        p++;
			
 
				+                        switch(*p) {
			
 
				+                        case 'n': c = '\n'; break;
			
 
				+                        case 'r': c = '\r'; break;
			
 
				+                        case 't': c = '\t'; break;
			
 
				+                        case 'b': c = '\b'; break;
			
 
				+                        case 'a': c = '\a'; break;
			
 
				+                        default: c = *p; break;
			
 
				+                        }
			
 
				+                        current = sdscatlen(current,&c,1);
			
 
				+                    } else if (*p == '"') {
			
 
				+                        /* closing quote must be followed by a space or
			
 
				+                         * nothing at all. */
			
 
				+                        if (*(p+1) && !isspace(*(p+1))) goto err;
			
 
				+                        done=1;
			
 
				+                    } else if (!*p) {
			
 
				+                        /* unterminated quotes */
			
 
				+                        goto err;
			
 
				+                    } else {
			
 
				+                        current = sdscatlen(current,p,1);
			
 
				+                    }
			
 
				+                } else if (insq) {
			
 
				+                    if (*p == '\\' && *(p+1) == '\'') {
			
 
				+                        p++;
			
 
				+                        current = sdscatlen(current,"'",1);
			
 
				+                    } else if (*p == '\'') {
			
 
				+                        /* closing quote must be followed by a space or
			
 
				+                         * nothing at all. */
			
 
				+                        if (*(p+1) && !isspace(*(p+1))) goto err;
			
 
				+                        done=1;
			
 
				+                    } else if (!*p) {
			
 
				+                        /* unterminated quotes */
			
 
				+                        goto err;
			
 
				+                    } else {
			
 
				+                        current = sdscatlen(current,p,1);
			
 
				+                    }
			
 
				+                } else {
			
 
				+                    switch(*p) {
			
 
				+                    case ' ':
			
 
				+                    case '\n':
			
 
				+                    case '\r':
			
 
				+                    case '\t':
			
 
				+                    case '\0':
			
 
				+                        done=1;
			
 
				+                        break;
			
 
				+                    case '"':
			
 
				+                        inq=1;
			
 
				+                        break;
			
 
				+                    case '\'':
			
 
				+                        insq=1;
			
 
				+                        break;
			
 
				+                    default:
			
 
				+                        current = sdscatlen(current,p,1);
			
 
				+                        break;
			
 
				+                    }
			
 
				+                }
			
 
				+                if (*p) p++;
			
 
				+            }
			
 
				+            /* add the token to the vector */
			
 
				+            vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
			
 
				+            vector[*argc] = current;
			
 
				+            (*argc)++;
			
 
				+            current = NULL;
			
 
				+        } else {
			
 
				+            /* Even on empty input string return something not NULL. */
			
 
				+            if (vector == NULL) vector = s_malloc(sizeof(void*));
			
 
				+            return vector;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+err:
			
 
				+    while((*argc)--)
			
 
				+        sdsfree(vector[*argc]);
			
 
				+    s_free(vector);
			
 
				+    if (current) sdsfree(current);
			
 
				+    *argc = 0;
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* Modify the string substituting all the occurrences of the set of
			
 
				+ * characters specified in the 'from' string to the corresponding character
			
 
				+ * in the 'to' array.
			
 
				+ *
			
 
				+ * For instance: sdsmapchars(mystring, "ho", "01", 2)
			
 
				+ * will have the effect of turning the string "hello" into "0ell1".
			
 
				+ *
			
 
				+ * The function returns the sds string pointer, that is always the same
			
 
				+ * as the input pointer since no resize is needed. */
			
 
				+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
			
 
				+    size_t j, i, l = sdslen(s);
			
 
				+
			
 
				+    for (j = 0; j < l; j++) {
			
 
				+        for (i = 0; i < setlen; i++) {
			
 
				+            if (s[j] == from[i]) {
			
 
				+                s[j] = to[i];
			
 
				+                break;
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    return s;
			
 
				+}
			
 
				+
			
 
				+/* Join an array of C strings using the specified separator (also a C string).
			
 
				+ * Returns the result as an sds string. */
			
 
				+sds sdsjoin(char **argv, int argc, char *sep) {
			
 
				+    sds join = sdsempty();
			
 
				+    int j;
			
 
				+
			
 
				+    for (j = 0; j < argc; j++) {
			
 
				+        join = sdscat(join, argv[j]);
			
 
				+        if (j != argc-1) join = sdscat(join,sep);
			
 
				+    }
			
 
				+    return join;
			
 
				+}
			
 
				+
			
 
				+/* Like sdsjoin, but joins an array of SDS strings. */
			
 
				+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
			
 
				+    sds join = sdsempty();
			
 
				+    int j;
			
 
				+
			
 
				+    for (j = 0; j < argc; j++) {
			
 
				+        join = sdscatsds(join, argv[j]);
			
 
				+        if (j != argc-1) join = sdscatlen(join,sep,seplen);
			
 
				+    }
			
 
				+    return join;
			
 
				+}
			
 
				+
			
 
				+/* Wrappers to the allocators used by SDS. Note that SDS will actually
			
 
				+ * just use the macros defined into sdsalloc.h in order to avoid to pay
			
 
				+ * the overhead of function calls. Here we define these wrappers only for
			
 
				+ * the programs SDS is linked to, if they want to touch the SDS internals
			
 
				+ * even if they use a different allocator. */
			
 
				+void *sds_malloc(size_t size) { return s_malloc(size); }
			
 
				+void *sds_realloc(void *ptr, size_t size) { return s_realloc(ptr,size); }
			
 
				+void sds_free(void *ptr) { s_free(ptr); }
			
 
				+
			
 
				+/* Perform expansion of a template string and return the result as a newly
			
 
				+ * allocated sds.
			
 
				+ *
			
 
				+ * Template variables are specified using curly brackets, e.g. {variable}.
			
 
				+ * An opening bracket can be quoted by repeating it twice.
			
 
				+ */
			
 
				+sds sdstemplate(const char *template, sdstemplate_callback_t cb_func, void *cb_arg)
			
 
				+{
			
 
				+    sds res = sdsempty();
			
 
				+    const char *p = template;
			
 
				+
			
 
				+    while (*p) {
			
 
				+        /* Find next variable, copy everything until there */
			
 
				+        const char *sv = strchr(p, '{');
			
 
				+        if (!sv) {
			
 
				+            /* Not found: copy till rest of template and stop */
			
 
				+            res = sdscat(res, p);
			
 
				+            break;
			
 
				+        } else if (sv > p) {
			
 
				+            /* Found: copy anything up to the beginning of the variable */
			
 
				+            res = sdscatlen(res, p, sv - p);
			
 
				+        }
			
 
				+
			
 
				+        /* Skip into variable name, handle premature end or quoting */
			
 
				+        sv++;
			
 
				+        if (!*sv) goto error;       /* Premature end of template */
			
 
				+        if (*sv == '{') {
			
 
				+            /* Quoted '{' */
			
 
				+            p = sv + 1;
			
 
				+            res = sdscat(res, "{");
			
 
				+            continue;
			
 
				+        }
			
 
				+
			
 
				+        /* Find end of variable name, handle premature end of template */
			
 
				+        const char *ev = strchr(sv, '}');
			
 
				+        if (!ev) goto error;
			
 
				+
			
 
				+        /* Pass variable name to callback and obtain value. If callback failed,
			
 
				+         * abort. */
			
 
				+        sds varname = sdsnewlen(sv, ev - sv);
			
 
				+        sds value = cb_func(varname, cb_arg);
			
 
				+        sdsfree(varname);
			
 
				+        if (!value) goto error;
			
 
				+
			
 
				+        /* Append value to result and continue */
			
 
				+        res = sdscat(res, value);
			
 
				+        sdsfree(value);
			
 
				+        p = ev + 1;
			
 
				+    }
			
 
				+
			
 
				+    return res;
			
 
				+
			
 
				+error:
			
 
				+    sdsfree(res);
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#include <stdio.h>
			
 
				+#include <limits.h>
			
 
				+#include "testhelp.h"
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+
			
 
				+static sds sdsTestTemplateCallback(sds varname, void *arg) {
			
 
				+    UNUSED(arg);
			
 
				+    static const char *_var1 = "variable1";
			
 
				+    static const char *_var2 = "variable2";
			
 
				+
			
 
				+    if (!strcmp(varname, _var1)) return sdsnew("value1");
			
 
				+    else if (!strcmp(varname, _var2)) return sdsnew("value2");
			
 
				+    else return NULL;
			
 
				+}
			
 
				+
			
 
				+int sdsTest(int argc, char **argv, int flags) {
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+
			
 
				+    {
			
 
				+        sds x = sdsnew("foo"), y;
			
 
				+
			
 
				+        test_cond("Create a string and obtain the length",
			
 
				+            sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnewlen("foo",2);
			
 
				+        test_cond("Create a string with specified length",
			
 
				+            sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0);
			
 
				+
			
 
				+        x = sdscat(x,"bar");
			
 
				+        test_cond("Strings concatenation",
			
 
				+            sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0);
			
 
				+
			
 
				+        x = sdscpy(x,"a");
			
 
				+        test_cond("sdscpy() against an originally longer string",
			
 
				+            sdslen(x) == 1 && memcmp(x,"a\0",2) == 0);
			
 
				+
			
 
				+        x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk");
			
 
				+        test_cond("sdscpy() against an originally shorter string",
			
 
				+            sdslen(x) == 33 &&
			
 
				+            memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdscatprintf(sdsempty(),"%d",123);
			
 
				+        test_cond("sdscatprintf() seems working in the base case",
			
 
				+            sdslen(x) == 3 && memcmp(x,"123\0",4) == 0);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdscatprintf(sdsempty(),"a%cb",0);
			
 
				+        test_cond("sdscatprintf() seems working with \\0 inside of result",
			
 
				+            sdslen(x) == 3 && memcmp(x,"a\0""b\0",4) == 0);
			
 
				+
			
 
				+        {
			
 
				+            sdsfree(x);
			
 
				+            char etalon[1024*1024];
			
 
				+            for (size_t i = 0; i < sizeof(etalon); i++) {
			
 
				+                etalon[i] = '0';
			
 
				+            }
			
 
				+            x = sdscatprintf(sdsempty(),"%0*d",(int)sizeof(etalon),0);
			
 
				+            test_cond("sdscatprintf() can print 1MB",
			
 
				+                sdslen(x) == sizeof(etalon) && memcmp(x,etalon,sizeof(etalon)) == 0);
			
 
				+        }
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("--");
			
 
				+        x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);
			
 
				+        test_cond("sdscatfmt() seems working in the base case",
			
 
				+            sdslen(x) == 60 &&
			
 
				+            memcmp(x,"--Hello Hi! World -9223372036854775808,"
			
 
				+                     "9223372036854775807--",60) == 0);
			
 
				+        printf("[%s]\n",x);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("--");
			
 
				+        x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX);
			
 
				+        test_cond("sdscatfmt() seems working with unsigned numbers",
			
 
				+            sdslen(x) == 35 &&
			
 
				+            memcmp(x,"--4294967295,18446744073709551615--",35) == 0);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew(" x ");
			
 
				+        sdstrim(x," x");
			
 
				+        test_cond("sdstrim() works when all chars match",
			
 
				+            sdslen(x) == 0);
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew(" x ");
			
 
				+        sdstrim(x," ");
			
 
				+        test_cond("sdstrim() works when a single char remains",
			
 
				+            sdslen(x) == 1 && x[0] == 'x');
			
 
				+
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("xxciaoyyy");
			
 
				+        sdstrim(x,"xy");
			
 
				+        test_cond("sdstrim() correctly trims characters",
			
 
				+            sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0);
			
 
				+
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,1,1);
			
 
				+        test_cond("sdsrange(...,1,1)",
			
 
				+            sdslen(y) == 1 && memcmp(y,"i\0",2) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,1,-1);
			
 
				+        test_cond("sdsrange(...,1,-1)",
			
 
				+            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,-2,-1);
			
 
				+        test_cond("sdsrange(...,-2,-1)",
			
 
				+            sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,2,1);
			
 
				+        test_cond("sdsrange(...,2,1)",
			
 
				+            sdslen(y) == 0 && memcmp(y,"\0",1) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,1,100);
			
 
				+        test_cond("sdsrange(...,1,100)",
			
 
				+            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,100,100);
			
 
				+        test_cond("sdsrange(...,100,100)",
			
 
				+            sdslen(y) == 0 && memcmp(y,"\0",1) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,4,6);
			
 
				+        test_cond("sdsrange(...,4,6)",
			
 
				+            sdslen(y) == 0 && memcmp(y,"\0",1) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        y = sdsdup(x);
			
 
				+        sdsrange(y,3,6);
			
 
				+        test_cond("sdsrange(...,3,6)",
			
 
				+            sdslen(y) == 1 && memcmp(y,"o\0",2) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("foo");
			
 
				+        y = sdsnew("foa");
			
 
				+        test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("bar");
			
 
				+        y = sdsnew("bar");
			
 
				+        test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnew("aar");
			
 
				+        y = sdsnew("bar");
			
 
				+        test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0);
			
 
				+
			
 
				+        sdsfree(y);
			
 
				+        sdsfree(x);
			
 
				+        x = sdsnewlen("\a\n\0foo\r",7);
			
 
				+        y = sdscatrepr(sdsempty(),x,sdslen(x));
			
 
				+        test_cond("sdscatrepr(...data...)",
			
 
				+            memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0);
			
 
				+
			
 
				+        {
			
 
				+            unsigned int oldfree;
			
 
				+            char *p;
			
 
				+            int i;
			
 
				+            size_t step = 10, j;
			
 
				+
			
 
				+            sdsfree(x);
			
 
				+            sdsfree(y);
			
 
				+            x = sdsnew("0");
			
 
				+            test_cond("sdsnew() free/len buffers", sdslen(x) == 1 && sdsavail(x) == 0);
			
 
				+
			
 
				+            /* Run the test a few times in order to hit the first two
			
 
				+             * SDS header types. */
			
 
				+            for (i = 0; i < 10; i++) {
			
 
				+                size_t oldlen = sdslen(x);
			
 
				+                x = sdsMakeRoomFor(x,step);
			
 
				+                int type = x[-1]&SDS_TYPE_MASK;
			
 
				+
			
 
				+                test_cond("sdsMakeRoomFor() len", sdslen(x) == oldlen);
			
 
				+                if (type != SDS_TYPE_5) {
			
 
				+                    test_cond("sdsMakeRoomFor() free", sdsavail(x) >= step);
			
 
				+                    oldfree = sdsavail(x);
			
 
				+                    UNUSED(oldfree);
			
 
				+                }
			
 
				+                p = x+oldlen;
			
 
				+                for (j = 0; j < step; j++) {
			
 
				+                    p[j] = 'A'+j;
			
 
				+                }
			
 
				+                sdsIncrLen(x,step);
			
 
				+            }
			
 
				+            test_cond("sdsMakeRoomFor() content",
			
 
				+                memcmp("0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ",x,101) == 0);
			
 
				+            test_cond("sdsMakeRoomFor() final length",sdslen(x)==101);
			
 
				+
			
 
				+            sdsfree(x);
			
 
				+        }
			
 
				+
			
 
				+        /* Simple template */
			
 
				+        x = sdstemplate("v1={variable1} v2={variable2}", sdsTestTemplateCallback, NULL);
			
 
				+        test_cond("sdstemplate() normal flow",
			
 
				+                  memcmp(x,"v1=value1 v2=value2",19) == 0);
			
 
				+        sdsfree(x);
			
 
				+
			
 
				+        /* Template with callback error */
			
 
				+        x = sdstemplate("v1={variable1} v3={doesnotexist}", sdsTestTemplateCallback, NULL);
			
 
				+        test_cond("sdstemplate() with callback error", x == NULL);
			
 
				+
			
 
				+        /* Template with empty var name */
			
 
				+        x = sdstemplate("v1={", sdsTestTemplateCallback, NULL);
			
 
				+        test_cond("sdstemplate() with empty var name", x == NULL);
			
 
				+
			
 
				+        /* Template with truncated var name */
			
 
				+        x = sdstemplate("v1={start", sdsTestTemplateCallback, NULL);
			
 
				+        test_cond("sdstemplate() with truncated var name", x == NULL);
			
 
				+
			
 
				+        /* Template with quoting */
			
 
				+        x = sdstemplate("v1={{{variable1}} {{} v2={variable2}", sdsTestTemplateCallback, NULL);
			
 
				+        test_cond("sdstemplate() with quoting",
			
 
				+                  memcmp(x,"v1={value1} {} v2=value2",24) == 0);
			
 
				+        sdsfree(x);
			
 
				+
			
 
				+        /* Test sdsresize - extend */
			
 
				+        x = sdsnew("1234567890123456789012345678901234567890");
			
 
				+        x = sdsResize(x, 200);
			
 
				+        test_cond("sdsrezie() expand len", sdslen(x) == 40);
			
 
				+        test_cond("sdsrezie() expand strlen", strlen(x) == 40);
			
 
				+        test_cond("sdsrezie() expand alloc", sdsalloc(x) == 200);
			
 
				+        /* Test sdsresize - trim free space */
			
 
				+        x = sdsResize(x, 80);
			
 
				+        test_cond("sdsrezie() shrink len", sdslen(x) == 40);
			
 
				+        test_cond("sdsrezie() shrink strlen", strlen(x) == 40);
			
 
				+        test_cond("sdsrezie() shrink alloc", sdsalloc(x) == 80);
			
 
				+        /* Test sdsresize - crop used space */
			
 
				+        x = sdsResize(x, 30);
			
 
				+        test_cond("sdsrezie() crop len", sdslen(x) == 30);
			
 
				+        test_cond("sdsrezie() crop strlen", strlen(x) == 30);
			
 
				+        test_cond("sdsrezie() crop alloc", sdsalloc(x) == 30);
			
 
				+        /* Test sdsresize - extend to different class */
			
 
				+        x = sdsResize(x, 400);
			
 
				+        test_cond("sdsrezie() expand len", sdslen(x) == 30);
			
 
				+        test_cond("sdsrezie() expand strlen", strlen(x) == 30);
			
 
				+        test_cond("sdsrezie() expand alloc", sdsalloc(x) == 400);
			
 
				+        /* Test sdsresize - shrink to different class */
			
 
				+        x = sdsResize(x, 4);
			
 
				+        test_cond("sdsrezie() crop len", sdslen(x) == 4);
			
 
				+        test_cond("sdsrezie() crop strlen", strlen(x) == 4);
			
 
				+        test_cond("sdsrezie() crop alloc", sdsalloc(x) == 4);
			
 
				+        sdsfree(x);
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/sds.h
+++ b/src/sds.h
@@ -0,0 +1,286 @@
 
				+/* SDSLib 2.0 -- A C dynamic strings library
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
			
 
				+ * Copyright (c) 2015, Oran Agra
			
 
				+ * Copyright (c) 2015, Redis Labs, Inc
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __SDS_H
			
 
				+#define __SDS_H
			
 
				+
			
 
				+#define SDS_MAX_PREALLOC (1024*1024)
			
 
				+extern const char *SDS_NOINIT;
			
 
				+
			
 
				+#include <sys/types.h>
			
 
				+#include <stdarg.h>
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+typedef char *sds;
			
 
				+
			
 
				+/* Note: sdshdr5 is never used, we just access the flags byte directly.
			
 
				+ * However is here to document the layout of type 5 SDS strings. */
			
 
				+struct __attribute__ ((__packed__)) sdshdr5 {
			
 
				+    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
			
 
				+    char buf[];
			
 
				+};
			
 
				+struct __attribute__ ((__packed__)) sdshdr8 {
			
 
				+    uint8_t len; /* used */
			
 
				+    uint8_t alloc; /* excluding the header and null terminator */
			
 
				+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
			
 
				+    char buf[];
			
 
				+};
			
 
				+struct __attribute__ ((__packed__)) sdshdr16 {
			
 
				+    uint16_t len; /* used */
			
 
				+    uint16_t alloc; /* excluding the header and null terminator */
			
 
				+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
			
 
				+    char buf[];
			
 
				+};
			
 
				+struct __attribute__ ((__packed__)) sdshdr32 {
			
 
				+    uint32_t len; /* used */
			
 
				+    uint32_t alloc; /* excluding the header and null terminator */
			
 
				+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
			
 
				+    char buf[];
			
 
				+};
			
 
				+struct __attribute__ ((__packed__)) sdshdr64 {
			
 
				+    uint64_t len; /* used */
			
 
				+    uint64_t alloc; /* excluding the header and null terminator */
			
 
				+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
			
 
				+    char buf[];
			
 
				+};
			
 
				+
			
 
				+#define SDS_TYPE_5  0
			
 
				+#define SDS_TYPE_8  1
			
 
				+#define SDS_TYPE_16 2
			
 
				+#define SDS_TYPE_32 3
			
 
				+#define SDS_TYPE_64 4
			
 
				+#define SDS_TYPE_MASK 7
			
 
				+#define SDS_TYPE_BITS 3
			
 
				+#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
			
 
				+#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
			
 
				+#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
			
 
				+
			
 
				+static inline size_t sdslen(const sds s) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            return SDS_TYPE_5_LEN(flags);
			
 
				+        case SDS_TYPE_8:
			
 
				+            return SDS_HDR(8,s)->len;
			
 
				+        case SDS_TYPE_16:
			
 
				+            return SDS_HDR(16,s)->len;
			
 
				+        case SDS_TYPE_32:
			
 
				+            return SDS_HDR(32,s)->len;
			
 
				+        case SDS_TYPE_64:
			
 
				+            return SDS_HDR(64,s)->len;
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+static inline size_t sdsavail(const sds s) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5: {
			
 
				+            return 0;
			
 
				+        }
			
 
				+        case SDS_TYPE_8: {
			
 
				+            SDS_HDR_VAR(8,s);
			
 
				+            return sh->alloc - sh->len;
			
 
				+        }
			
 
				+        case SDS_TYPE_16: {
			
 
				+            SDS_HDR_VAR(16,s);
			
 
				+            return sh->alloc - sh->len;
			
 
				+        }
			
 
				+        case SDS_TYPE_32: {
			
 
				+            SDS_HDR_VAR(32,s);
			
 
				+            return sh->alloc - sh->len;
			
 
				+        }
			
 
				+        case SDS_TYPE_64: {
			
 
				+            SDS_HDR_VAR(64,s);
			
 
				+            return sh->alloc - sh->len;
			
 
				+        }
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+static inline void sdssetlen(sds s, size_t newlen) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            {
			
 
				+                unsigned char *fp = ((unsigned char*)s)-1;
			
 
				+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
			
 
				+            }
			
 
				+            break;
			
 
				+        case SDS_TYPE_8:
			
 
				+            SDS_HDR(8,s)->len = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_16:
			
 
				+            SDS_HDR(16,s)->len = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_32:
			
 
				+            SDS_HDR(32,s)->len = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_64:
			
 
				+            SDS_HDR(64,s)->len = newlen;
			
 
				+            break;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+static inline void sdsinclen(sds s, size_t inc) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            {
			
 
				+                unsigned char *fp = ((unsigned char*)s)-1;
			
 
				+                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
			
 
				+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
			
 
				+            }
			
 
				+            break;
			
 
				+        case SDS_TYPE_8:
			
 
				+            SDS_HDR(8,s)->len += inc;
			
 
				+            break;
			
 
				+        case SDS_TYPE_16:
			
 
				+            SDS_HDR(16,s)->len += inc;
			
 
				+            break;
			
 
				+        case SDS_TYPE_32:
			
 
				+            SDS_HDR(32,s)->len += inc;
			
 
				+            break;
			
 
				+        case SDS_TYPE_64:
			
 
				+            SDS_HDR(64,s)->len += inc;
			
 
				+            break;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* sdsalloc() = sdsavail() + sdslen() */
			
 
				+static inline size_t sdsalloc(const sds s) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            return SDS_TYPE_5_LEN(flags);
			
 
				+        case SDS_TYPE_8:
			
 
				+            return SDS_HDR(8,s)->alloc;
			
 
				+        case SDS_TYPE_16:
			
 
				+            return SDS_HDR(16,s)->alloc;
			
 
				+        case SDS_TYPE_32:
			
 
				+            return SDS_HDR(32,s)->alloc;
			
 
				+        case SDS_TYPE_64:
			
 
				+            return SDS_HDR(64,s)->alloc;
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+static inline void sdssetalloc(sds s, size_t newlen) {
			
 
				+    unsigned char flags = s[-1];
			
 
				+    switch(flags&SDS_TYPE_MASK) {
			
 
				+        case SDS_TYPE_5:
			
 
				+            /* Nothing to do, this type has no total allocation info. */
			
 
				+            break;
			
 
				+        case SDS_TYPE_8:
			
 
				+            SDS_HDR(8,s)->alloc = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_16:
			
 
				+            SDS_HDR(16,s)->alloc = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_32:
			
 
				+            SDS_HDR(32,s)->alloc = newlen;
			
 
				+            break;
			
 
				+        case SDS_TYPE_64:
			
 
				+            SDS_HDR(64,s)->alloc = newlen;
			
 
				+            break;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+sds sdsnewlen(const void *init, size_t initlen);
			
 
				+sds sdstrynewlen(const void *init, size_t initlen);
			
 
				+sds sdsnew(const char *init);
			
 
				+sds sdsempty(void);
			
 
				+sds sdsdup(const sds s);
			
 
				+void sdsfree(sds s);
			
 
				+sds sdsgrowzero(sds s, size_t len);
			
 
				+sds sdscatlen(sds s, const void *t, size_t len);
			
 
				+sds sdscat(sds s, const char *t);
			
 
				+sds sdscatsds(sds s, const sds t);
			
 
				+sds sdscpylen(sds s, const char *t, size_t len);
			
 
				+sds sdscpy(sds s, const char *t);
			
 
				+
			
 
				+sds sdscatvprintf(sds s, const char *fmt, va_list ap);
			
 
				+#ifdef __GNUC__
			
 
				+sds sdscatprintf(sds s, const char *fmt, ...)
			
 
				+    __attribute__((format(printf, 2, 3)));
			
 
				+#else
			
 
				+sds sdscatprintf(sds s, const char *fmt, ...);
			
 
				+#endif
			
 
				+
			
 
				+sds sdscatfmt(sds s, char const *fmt, ...);
			
 
				+sds sdstrim(sds s, const char *cset);
			
 
				+void sdssubstr(sds s, size_t start, size_t len);
			
 
				+void sdsrange(sds s, ssize_t start, ssize_t end);
			
 
				+void sdsupdatelen(sds s);
			
 
				+void sdsclear(sds s);
			
 
				+int sdscmp(const sds s1, const sds s2);
			
 
				+sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
			
 
				+void sdsfreesplitres(sds *tokens, int count);
			
 
				+void sdstolower(sds s);
			
 
				+void sdstoupper(sds s);
			
 
				+sds sdsfromlonglong(long long value);
			
 
				+sds sdscatrepr(sds s, const char *p, size_t len);
			
 
				+sds *sdssplitargs(const char *line, int *argc);
			
 
				+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
			
 
				+sds sdsjoin(char **argv, int argc, char *sep);
			
 
				+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
			
 
				+
			
 
				+/* Callback for sdstemplate. The function gets called by sdstemplate
			
 
				+ * every time a variable needs to be expanded. The variable name is
			
 
				+ * provided as variable, and the callback is expected to return a
			
 
				+ * substitution value. Returning a NULL indicates an error.
			
 
				+ */
			
 
				+typedef sds (*sdstemplate_callback_t)(const sds variable, void *arg);
			
 
				+sds sdstemplate(const char *template, sdstemplate_callback_t cb_func, void *cb_arg);
			
 
				+
			
 
				+/* Low level functions exposed to the user API */
			
 
				+sds sdsMakeRoomFor(sds s, size_t addlen);
			
 
				+sds sdsMakeRoomForNonGreedy(sds s, size_t addlen);
			
 
				+void sdsIncrLen(sds s, ssize_t incr);
			
 
				+sds sdsRemoveFreeSpace(sds s);
			
 
				+sds sdsResize(sds s, size_t size);
			
 
				+size_t sdsAllocSize(sds s);
			
 
				+void *sdsAllocPtr(sds s);
			
 
				+
			
 
				+/* Export the allocator used by SDS to the program using SDS.
			
 
				+ * Sometimes the program SDS is linked to, may use a different set of
			
 
				+ * allocators, but may want to allocate or free things that SDS will
			
 
				+ * respectively free or allocate. */
			
 
				+void *sds_malloc(size_t size);
			
 
				+void *sds_realloc(void *ptr, size_t size);
			
 
				+void sds_free(void *ptr);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int sdsTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/sdsalloc.h
+++ b/src/sdsalloc.h
@@ -0,0 +1,54 @@
 
				+/* SDSLib 2.0 -- A C dynamic strings library
			
 
				+ *
			
 
				+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
			
 
				+ * Copyright (c) 2015, Redis Labs, Inc
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+/* SDS allocator selection.
			
 
				+ *
			
 
				+ * This file is used in order to change the SDS allocator at compile time.
			
 
				+ * Just define the following defines to what you want to use. Also add
			
 
				+ * the include of your alternate allocator if needed (not needed in order
			
 
				+ * to use the default libc allocator). */
			
 
				+
			
 
				+#ifndef __SDS_ALLOC_H__
			
 
				+#define __SDS_ALLOC_H__
			
 
				+
			
 
				+#include "zmalloc.h"
			
 
				+#define s_malloc zmalloc
			
 
				+#define s_realloc zrealloc
			
 
				+#define s_trymalloc ztrymalloc
			
 
				+#define s_tryrealloc ztryrealloc
			
 
				+#define s_free zfree
			
 
				+#define s_malloc_usable zmalloc_usable
			
 
				+#define s_realloc_usable zrealloc_usable
			
 
				+#define s_trymalloc_usable ztrymalloc_usable
			
 
				+#define s_tryrealloc_usable ztryrealloc_usable
			
 
				+#define s_free_usable zfree_usable
			
 
				+
			
 
				+#endif
			
--- a/src/session.c
+++ b/src/session.c
@@ -0,0 +1,27 @@
 
				+#include "session.h"
			
 
				+#include "logger.h"
			
 
				+
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+
			
 
				+session_t* new_session(uv_stream_t* server)
			
 
				+{
			
 
				+    session_t * sess = (session_t*)malloc(sizeof(session_t));
			
 
				+    if (!sess) {
			
 
				+        return NULL;
			
 
				+    }
			
 
				+
			
 
				+    memset(sess, 0, sizeof(session_t));
			
 
				+    sess->server = server;
			
 
				+    sess->start_at = time(NULL);
			
 
				+    sess->last_active = sess->start_at;
			
 
				+
			
 
				+    return sess;
			
 
				+}
			
 
				+
			
 
				+void on_session_new(uv_stream_t *server, int status)
			
 
				+{
			
 
				+    if(status != 0) {
			
 
				+        info("new session failed. status=%d\n", status);
			
 
				+    }
			
 
				+}
			
--- a/src/session.h
+++ b/src/session.h
@@ -0,0 +1,23 @@
 
				+#ifndef SESSION_H
			
 
				+#define SESSION_H
			
 
				+
			
 
				+#include <uv.h>
			
 
				+#include <stdbool.h>
			
 
				+
			
 
				+typedef struct _session
			
 
				+{
			
 
				+    uv_stream_t *s;      // transmit with remote
			
 
				+    uv_stream_t *server; // server tcp
			
 
				+    uv_buf_t buf;        // buffer
			
 
				+    time_t start_at;     // born time
			
 
				+    time_t last_active;
			
 
				+    bool alive;       // is alive
			
 
				+    int64_t received; // data recevied
			
 
				+    int64_t sent;     // sent
			
 
				+} session_t;
			
 
				+
			
 
				+// nv_listen callback
			
 
				+void on_session_new(uv_stream_t *server, int status);
			
 
				+void on_session_closed();
			
 
				+
			
 
				+#endif
			
--- a/src/sha1.c
+++ b/src/sha1.c
@@ -0,0 +1,226 @@
 
				+
			
 
				+/* from valgrind tests */
			
 
				+
			
 
				+/* ================ sha1.c ================ */
			
 
				+/*
			
 
				+SHA-1 in C
			
 
				+By Steve Reid <steve@edmweb.com>
			
 
				+100% Public Domain
			
 
				+
			
 
				+Test Vectors (from FIPS PUB 180-1)
			
 
				+"abc"
			
 
				+  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
			
 
				+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
			
 
				+  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
			
 
				+A million repetitions of "a"
			
 
				+  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
			
 
				+*/
			
 
				+
			
 
				+/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
			
 
				+/* #define SHA1HANDSOFF * Copies data before messing with it. */
			
 
				+
			
 
				+#define SHA1HANDSOFF
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <string.h>
			
 
				+#include <stdint.h>
			
 
				+#include "sha1.h"
			
 
				+
			
 
				+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
			
 
				+
			
 
				+/* blk0() and blk() perform the initial expand. */
			
 
				+/* I got the idea of expanding during the round function from SSLeay */
			
 
				+#if BYTE_ORDER == LITTLE_ENDIAN
			
 
				+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
			
 
				+    |(rol(block->l[i],8)&0x00FF00FF))
			
 
				+#elif BYTE_ORDER == BIG_ENDIAN
			
 
				+#define blk0(i) block->l[i]
			
 
				+#else
			
 
				+#error "Endianness not defined!"
			
 
				+#endif
			
 
				+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
			
 
				+    ^block->l[(i+2)&15]^block->l[i&15],1))
			
 
				+
			
 
				+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
			
 
				+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
			
 
				+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
			
 
				+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
			
 
				+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
			
 
				+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
			
 
				+
			
 
				+
			
 
				+/* Hash a single 512-bit block. This is the core of the algorithm. */
			
 
				+
			
 
				+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
			
 
				+{
			
 
				+    uint32_t a, b, c, d, e;
			
 
				+    typedef union {
			
 
				+        unsigned char c[64];
			
 
				+        uint32_t l[16];
			
 
				+    } CHAR64LONG16;
			
 
				+#ifdef SHA1HANDSOFF
			
 
				+    CHAR64LONG16 block[1];  /* use array to appear as a pointer */
			
 
				+    memcpy(block, buffer, 64);
			
 
				+#else
			
 
				+    /* The following had better never be used because it causes the
			
 
				+     * pointer-to-const buffer to be cast into a pointer to non-const.
			
 
				+     * And the result is written through.  I threw a "const" in, hoping
			
 
				+     * this will cause a diagnostic.
			
 
				+     */
			
 
				+    CHAR64LONG16* block = (const CHAR64LONG16*)buffer;
			
 
				+#endif
			
 
				+    /* Copy context->state[] to working vars */
			
 
				+    a = state[0];
			
 
				+    b = state[1];
			
 
				+    c = state[2];
			
 
				+    d = state[3];
			
 
				+    e = state[4];
			
 
				+    /* 4 rounds of 20 operations each. Loop unrolled. */
			
 
				+    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
			
 
				+    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
			
 
				+    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
			
 
				+    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
			
 
				+    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
			
 
				+    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
			
 
				+    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
			
 
				+    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
			
 
				+    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
			
 
				+    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
			
 
				+    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
			
 
				+    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
			
 
				+    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
			
 
				+    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
			
 
				+    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
			
 
				+    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
			
 
				+    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
			
 
				+    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
			
 
				+    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
			
 
				+    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
			
 
				+    /* Add the working vars back into context.state[] */
			
 
				+    state[0] += a;
			
 
				+    state[1] += b;
			
 
				+    state[2] += c;
			
 
				+    state[3] += d;
			
 
				+    state[4] += e;
			
 
				+    /* Wipe variables */
			
 
				+    a = b = c = d = e = 0;
			
 
				+#ifdef SHA1HANDSOFF
			
 
				+    memset(block, '\0', sizeof(block));
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* SHA1Init - Initialize new context */
			
 
				+
			
 
				+void SHA1Init(SHA1_CTX* context)
			
 
				+{
			
 
				+    /* SHA1 initialization constants */
			
 
				+    context->state[0] = 0x67452301;
			
 
				+    context->state[1] = 0xEFCDAB89;
			
 
				+    context->state[2] = 0x98BADCFE;
			
 
				+    context->state[3] = 0x10325476;
			
 
				+    context->state[4] = 0xC3D2E1F0;
			
 
				+    context->count[0] = context->count[1] = 0;
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* Run your data through this. */
			
 
				+
			
 
				+void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)
			
 
				+{
			
 
				+    uint32_t i, j;
			
 
				+
			
 
				+    j = context->count[0];
			
 
				+    if ((context->count[0] += len << 3) < j)
			
 
				+        context->count[1]++;
			
 
				+    context->count[1] += (len>>29);
			
 
				+    j = (j >> 3) & 63;
			
 
				+    if ((j + len) > 63) {
			
 
				+        memcpy(&context->buffer[j], data, (i = 64-j));
			
 
				+        SHA1Transform(context->state, context->buffer);
			
 
				+        for ( ; i + 63 < len; i += 64) {
			
 
				+            SHA1Transform(context->state, &data[i]);
			
 
				+        }
			
 
				+        j = 0;
			
 
				+    }
			
 
				+    else i = 0;
			
 
				+    memcpy(&context->buffer[j], &data[i], len - i);
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* Add padding and return the message digest. */
			
 
				+
			
 
				+void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
			
 
				+{
			
 
				+    unsigned i;
			
 
				+    unsigned char finalcount[8];
			
 
				+    unsigned char c;
			
 
				+
			
 
				+#if 0	/* untested "improvement" by DHR */
			
 
				+    /* Convert context->count to a sequence of bytes
			
 
				+     * in finalcount.  Second element first, but
			
 
				+     * big-endian order within element.
			
 
				+     * But we do it all backwards.
			
 
				+     */
			
 
				+    unsigned char *fcp = &finalcount[8];
			
 
				+
			
 
				+    for (i = 0; i < 2; i++)
			
 
				+       {
			
 
				+        uint32_t t = context->count[i];
			
 
				+        int j;
			
 
				+
			
 
				+        for (j = 0; j < 4; t >>= 8, j++)
			
 
				+	          *--fcp = (unsigned char) t;
			
 
				+    }
			
 
				+#else
			
 
				+    for (i = 0; i < 8; i++) {
			
 
				+        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
			
 
				+         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
			
 
				+    }
			
 
				+#endif
			
 
				+    c = 0200;
			
 
				+    SHA1Update(context, &c, 1);
			
 
				+    while ((context->count[0] & 504) != 448) {
			
 
				+	c = 0000;
			
 
				+        SHA1Update(context, &c, 1);
			
 
				+    }
			
 
				+    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
			
 
				+    for (i = 0; i < 20; i++) {
			
 
				+        digest[i] = (unsigned char)
			
 
				+         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
			
 
				+    }
			
 
				+    /* Wipe variables */
			
 
				+    memset(context, '\0', sizeof(*context));
			
 
				+    memset(&finalcount, '\0', sizeof(finalcount));
			
 
				+}
			
 
				+/* ================ end of sha1.c ================ */
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#define BUFSIZE 4096
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+int sha1Test(int argc, char **argv, int flags)
			
 
				+{
			
 
				+    SHA1_CTX ctx;
			
 
				+    unsigned char hash[20], buf[BUFSIZE];
			
 
				+    int i;
			
 
				+
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+
			
 
				+    for(i=0;i<BUFSIZE;i++)
			
 
				+        buf[i] = i;
			
 
				+
			
 
				+    SHA1Init(&ctx);
			
 
				+    for(i=0;i<1000;i++)
			
 
				+        SHA1Update(&ctx, buf, BUFSIZE);
			
 
				+    SHA1Final(hash, &ctx);
			
 
				+
			
 
				+    printf("SHA1=");
			
 
				+    for(i=0;i<20;i++)
			
 
				+        printf("%02x", hash[i]);
			
 
				+    printf("\n");
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/sha1.h
+++ b/src/sha1.h
@@ -0,0 +1,25 @@
 
				+#ifndef SHA1_H
			
 
				+#define SHA1_H
			
 
				+/* ================ sha1.h ================ */
			
 
				+/*
			
 
				+SHA-1 in C
			
 
				+By Steve Reid <steve@edmweb.com>
			
 
				+100% Public Domain
			
 
				+*/
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+typedef struct {
			
 
				+    uint32_t state[5];
			
 
				+    uint32_t count[2];
			
 
				+    unsigned char buffer[64];
			
 
				+} SHA1_CTX;
			
 
				+
			
 
				+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
			
 
				+void SHA1Init(SHA1_CTX* context);
			
 
				+void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
			
 
				+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int sha1Test(int argc, char **argv, int flags);
			
 
				+#endif
			
 
				+#endif
			
--- a/src/sha256.c
+++ b/src/sha256.c
@@ -0,0 +1,163 @@
 
				+/*********************************************************************
			
 
				+* Filename:   sha256.c
			
 
				+* Author:     Brad Conte (brad AT bradconte.com)
			
 
				+* Copyright:
			
 
				+* Disclaimer: This code is presented "as is" without any guarantees.
			
 
				+* Details:    Implementation of the SHA-256 hashing algorithm.
			
 
				+              SHA-256 is one of the three algorithms in the SHA2
			
 
				+              specification. The others, SHA-384 and SHA-512, are not
			
 
				+              offered in this implementation.
			
 
				+              Algorithm specification can be found here:
			
 
				+               * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
			
 
				+              This implementation uses little endian byte order.
			
 
				+*********************************************************************/
			
 
				+
			
 
				+/*************************** HEADER FILES ***************************/
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+#include "sha256.h"
			
 
				+
			
 
				+/****************************** MACROS ******************************/
			
 
				+#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
			
 
				+#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
			
 
				+
			
 
				+#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
			
 
				+#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
			
 
				+#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
			
 
				+#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
			
 
				+#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
			
 
				+#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
			
 
				+
			
 
				+/**************************** VARIABLES *****************************/
			
 
				+static const WORD k[64] = {
			
 
				+	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
			
 
				+	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
			
 
				+	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
			
 
				+	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
			
 
				+	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
			
 
				+	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
			
 
				+	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
			
 
				+	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
			
 
				+};
			
 
				+
			
 
				+/*********************** FUNCTION DEFINITIONS ***********************/
			
 
				+void sha256_transform(SHA256_CTX *ctx, const BYTE data[])
			
 
				+{
			
 
				+	WORD a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
			
 
				+
			
 
				+    for (i = 0, j = 0; i < 16; ++i, j += 4) {
			
 
				+        m[i] = ((WORD) data[j + 0] << 24) |
			
 
				+               ((WORD) data[j + 1] << 16) |
			
 
				+               ((WORD) data[j + 2] << 8) |
			
 
				+               ((WORD) data[j + 3]);
			
 
				+    }
			
 
				+
			
 
				+	for ( ; i < 64; ++i)
			
 
				+		m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
			
 
				+
			
 
				+	a = ctx->state[0];
			
 
				+	b = ctx->state[1];
			
 
				+	c = ctx->state[2];
			
 
				+	d = ctx->state[3];
			
 
				+	e = ctx->state[4];
			
 
				+	f = ctx->state[5];
			
 
				+	g = ctx->state[6];
			
 
				+	h = ctx->state[7];
			
 
				+
			
 
				+	for (i = 0; i < 64; ++i) {
			
 
				+		t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
			
 
				+		t2 = EP0(a) + MAJ(a,b,c);
			
 
				+		h = g;
			
 
				+		g = f;
			
 
				+		f = e;
			
 
				+		e = d + t1;
			
 
				+		d = c;
			
 
				+		c = b;
			
 
				+		b = a;
			
 
				+		a = t1 + t2;
			
 
				+	}
			
 
				+
			
 
				+	ctx->state[0] += a;
			
 
				+	ctx->state[1] += b;
			
 
				+	ctx->state[2] += c;
			
 
				+	ctx->state[3] += d;
			
 
				+	ctx->state[4] += e;
			
 
				+	ctx->state[5] += f;
			
 
				+	ctx->state[6] += g;
			
 
				+	ctx->state[7] += h;
			
 
				+}
			
 
				+
			
 
				+void sha256_init(SHA256_CTX *ctx)
			
 
				+{
			
 
				+	ctx->datalen = 0;
			
 
				+	ctx->bitlen = 0;
			
 
				+	ctx->state[0] = 0x6a09e667;
			
 
				+	ctx->state[1] = 0xbb67ae85;
			
 
				+	ctx->state[2] = 0x3c6ef372;
			
 
				+	ctx->state[3] = 0xa54ff53a;
			
 
				+	ctx->state[4] = 0x510e527f;
			
 
				+	ctx->state[5] = 0x9b05688c;
			
 
				+	ctx->state[6] = 0x1f83d9ab;
			
 
				+	ctx->state[7] = 0x5be0cd19;
			
 
				+}
			
 
				+
			
 
				+void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len)
			
 
				+{
			
 
				+	WORD i;
			
 
				+
			
 
				+	for (i = 0; i < len; ++i) {
			
 
				+		ctx->data[ctx->datalen] = data[i];
			
 
				+		ctx->datalen++;
			
 
				+		if (ctx->datalen == 64) {
			
 
				+			sha256_transform(ctx, ctx->data);
			
 
				+			ctx->bitlen += 512;
			
 
				+			ctx->datalen = 0;
			
 
				+		}
			
 
				+	}
			
 
				+}
			
 
				+
			
 
				+void sha256_final(SHA256_CTX *ctx, BYTE hash[])
			
 
				+{
			
 
				+	WORD i;
			
 
				+
			
 
				+	i = ctx->datalen;
			
 
				+
			
 
				+	// Pad whatever data is left in the buffer.
			
 
				+	if (ctx->datalen < 56) {
			
 
				+		ctx->data[i++] = 0x80;
			
 
				+		while (i < 56)
			
 
				+			ctx->data[i++] = 0x00;
			
 
				+	}
			
 
				+	else {
			
 
				+		ctx->data[i++] = 0x80;
			
 
				+		while (i < 64)
			
 
				+			ctx->data[i++] = 0x00;
			
 
				+		sha256_transform(ctx, ctx->data);
			
 
				+		memset(ctx->data, 0, 56);
			
 
				+	}
			
 
				+
			
 
				+	// Append to the padding the total message's length in bits and transform.
			
 
				+	ctx->bitlen += ctx->datalen * 8;
			
 
				+	ctx->data[63] = ctx->bitlen;
			
 
				+	ctx->data[62] = ctx->bitlen >> 8;
			
 
				+	ctx->data[61] = ctx->bitlen >> 16;
			
 
				+	ctx->data[60] = ctx->bitlen >> 24;
			
 
				+	ctx->data[59] = ctx->bitlen >> 32;
			
 
				+	ctx->data[58] = ctx->bitlen >> 40;
			
 
				+	ctx->data[57] = ctx->bitlen >> 48;
			
 
				+	ctx->data[56] = ctx->bitlen >> 56;
			
 
				+	sha256_transform(ctx, ctx->data);
			
 
				+
			
 
				+	// Since this implementation uses little endian byte ordering and SHA uses big endian,
			
 
				+	// reverse all the bytes when copying the final state to the output hash.
			
 
				+	for (i = 0; i < 4; ++i) {
			
 
				+		hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
			
 
				+		hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
			
 
				+	}
			
 
				+}
			
--- a/src/sha256.h
+++ b/src/sha256.h
@@ -0,0 +1,35 @@
 
				+/*********************************************************************
			
 
				+* Filename:   sha256.h
			
 
				+* Author:     Brad Conte (brad AT bradconte.com)
			
 
				+* Copyright:
			
 
				+* Disclaimer: This code is presented "as is" without any guarantees.
			
 
				+* Details:    Defines the API for the corresponding SHA256 implementation.
			
 
				+*********************************************************************/
			
 
				+
			
 
				+#ifndef SHA256_H
			
 
				+#define SHA256_H
			
 
				+
			
 
				+/*************************** HEADER FILES ***************************/
			
 
				+#include <stddef.h>
			
 
				+#include <stdint.h>
			
 
				+
			
 
				+/****************************** MACROS ******************************/
			
 
				+#define SHA256_BLOCK_SIZE 32            // SHA256 outputs a 32 byte digest
			
 
				+
			
 
				+/**************************** DATA TYPES ****************************/
			
 
				+typedef uint8_t BYTE;   // 8-bit byte
			
 
				+typedef uint32_t WORD;  // 32-bit word
			
 
				+
			
 
				+typedef struct {
			
 
				+	BYTE data[64];
			
 
				+	WORD datalen;
			
 
				+	unsigned long long bitlen;
			
 
				+	WORD state[8];
			
 
				+} SHA256_CTX;
			
 
				+
			
 
				+/*********************** FUNCTION DECLARATIONS **********************/
			
 
				+void sha256_init(SHA256_CTX *ctx);
			
 
				+void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len);
			
 
				+void sha256_final(SHA256_CTX *ctx, BYTE hash[]);
			
 
				+
			
 
				+#endif   // SHA256_H
			
--- a/src/siphash.c
+++ b/src/siphash.c
@@ -0,0 +1,373 @@
 
				+/*
			
 
				+   SipHash reference C implementation
			
 
				+
			
 
				+   Copyright (c) 2012-2016 Jean-Philippe Aumasson
			
 
				+   <jeanphilippe.aumasson@gmail.com>
			
 
				+   Copyright (c) 2012-2014 Daniel J. Bernstein <djb@cr.yp.to>
			
 
				+   Copyright (c) 2017 Salvatore Sanfilippo <antirez@gmail.com>
			
 
				+
			
 
				+   To the extent possible under law, the author(s) have dedicated all copyright
			
 
				+   and related and neighboring rights to this software to the public domain
			
 
				+   worldwide. This software is distributed without any warranty.
			
 
				+
			
 
				+   You should have received a copy of the CC0 Public Domain Dedication along
			
 
				+   with this software. If not, see
			
 
				+   <http://creativecommons.org/publicdomain/zero/1.0/>.
			
 
				+
			
 
				+   ----------------------------------------------------------------------------
			
 
				+
			
 
				+   This version was modified by Salvatore Sanfilippo <antirez@gmail.com>
			
 
				+   in the following ways:
			
 
				+
			
 
				+   1. We use SipHash 1-2. This is not believed to be as strong as the
			
 
				+      suggested 2-4 variant, but AFAIK there are not trivial attacks
			
 
				+      against this reduced-rounds version, and it runs at the same speed
			
 
				+      as Murmurhash2 that we used previously, while the 2-4 variant slowed
			
 
				+      down Redis by a 4% figure more or less.
			
 
				+   2. Hard-code rounds in the hope the compiler can optimize it more
			
 
				+      in this raw from. Anyway we always want the standard 2-4 variant.
			
 
				+   3. Modify the prototype and implementation so that the function directly
			
 
				+      returns an uint64_t value, the hash itself, instead of receiving an
			
 
				+      output buffer. This also means that the output size is set to 8 bytes
			
 
				+      and the 16 bytes output code handling was removed.
			
 
				+   4. Provide a case insensitive variant to be used when hashing strings that
			
 
				+      must be considered identical by the hash table regardless of the case.
			
 
				+      If we don't have directly a case insensitive hash function, we need to
			
 
				+      perform a text transformation in some temporary buffer, which is costly.
			
 
				+   5. Remove debugging code.
			
 
				+   6. Modified the original test.c file to be a stand-alone function testing
			
 
				+      the function in the new form (returning an uint64_t) using just the
			
 
				+      relevant test vector.
			
 
				+ */
			
 
				+#include <assert.h>
			
 
				+#include <stdint.h>
			
 
				+#include <stdio.h>
			
 
				+#include <string.h>
			
 
				+#include <ctype.h>
			
 
				+
			
 
				+/* Fast tolower() alike function that does not care about locale
			
 
				+ * but just returns a-z instead of A-Z. */
			
 
				+int siptlw(int c) {
			
 
				+    if (c >= 'A' && c <= 'Z') {
			
 
				+        return c+('a'-'A');
			
 
				+    } else {
			
 
				+        return c;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+#if defined(__has_attribute)
			
 
				+#if __has_attribute(no_sanitize)
			
 
				+#define NO_SANITIZE(sanitizer) __attribute__((no_sanitize(sanitizer)))
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+#if !defined(NO_SANITIZE)
			
 
				+#define NO_SANITIZE(sanitizer)
			
 
				+#endif
			
 
				+
			
 
				+/* Test of the CPU is Little Endian and supports not aligned accesses.
			
 
				+ * Two interesting conditions to speedup the function that happen to be
			
 
				+ * in most of x86 servers. */
			
 
				+#if defined(__X86_64__) || defined(__x86_64__) || defined (__i386__) \
			
 
				+	|| defined (__aarch64__) || defined (__arm64__)
			
 
				+#define UNALIGNED_LE_CPU
			
 
				+#endif
			
 
				+
			
 
				+#define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
			
 
				+
			
 
				+#define U32TO8_LE(p, v)                                                        \
			
 
				+    (p)[0] = (uint8_t)((v));                                                   \
			
 
				+    (p)[1] = (uint8_t)((v) >> 8);                                              \
			
 
				+    (p)[2] = (uint8_t)((v) >> 16);                                             \
			
 
				+    (p)[3] = (uint8_t)((v) >> 24);
			
 
				+
			
 
				+#define U64TO8_LE(p, v)                                                        \
			
 
				+    U32TO8_LE((p), (uint32_t)((v)));                                           \
			
 
				+    U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
			
 
				+
			
 
				+#ifdef UNALIGNED_LE_CPU
			
 
				+#define U8TO64_LE(p) (*((uint64_t*)(p)))
			
 
				+#else
			
 
				+#define U8TO64_LE(p)                                                           \
			
 
				+    (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                        \
			
 
				+     ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                 \
			
 
				+     ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) |                 \
			
 
				+     ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
			
 
				+#endif
			
 
				+
			
 
				+#define U8TO64_LE_NOCASE(p)                                                    \
			
 
				+    (((uint64_t)(siptlw((p)[0]))) |                                           \
			
 
				+     ((uint64_t)(siptlw((p)[1])) << 8) |                                      \
			
 
				+     ((uint64_t)(siptlw((p)[2])) << 16) |                                     \
			
 
				+     ((uint64_t)(siptlw((p)[3])) << 24) |                                     \
			
 
				+     ((uint64_t)(siptlw((p)[4])) << 32) |                                              \
			
 
				+     ((uint64_t)(siptlw((p)[5])) << 40) |                                              \
			
 
				+     ((uint64_t)(siptlw((p)[6])) << 48) |                                              \
			
 
				+     ((uint64_t)(siptlw((p)[7])) << 56))
			
 
				+
			
 
				+#define SIPROUND                                                               \
			
 
				+    do {                                                                       \
			
 
				+        v0 += v1;                                                              \
			
 
				+        v1 = ROTL(v1, 13);                                                     \
			
 
				+        v1 ^= v0;                                                              \
			
 
				+        v0 = ROTL(v0, 32);                                                     \
			
 
				+        v2 += v3;                                                              \
			
 
				+        v3 = ROTL(v3, 16);                                                     \
			
 
				+        v3 ^= v2;                                                              \
			
 
				+        v0 += v3;                                                              \
			
 
				+        v3 = ROTL(v3, 21);                                                     \
			
 
				+        v3 ^= v0;                                                              \
			
 
				+        v2 += v1;                                                              \
			
 
				+        v1 = ROTL(v1, 17);                                                     \
			
 
				+        v1 ^= v2;                                                              \
			
 
				+        v2 = ROTL(v2, 32);                                                     \
			
 
				+    } while (0)
			
 
				+
			
 
				+NO_SANITIZE("alignment")
			
 
				+uint64_t siphash(const uint8_t *in, const size_t inlen, const uint8_t *k) {
			
 
				+#ifndef UNALIGNED_LE_CPU
			
 
				+    uint64_t hash;
			
 
				+    uint8_t *out = (uint8_t*) &hash;
			
 
				+#endif
			
 
				+    uint64_t v0 = 0x736f6d6570736575ULL;
			
 
				+    uint64_t v1 = 0x646f72616e646f6dULL;
			
 
				+    uint64_t v2 = 0x6c7967656e657261ULL;
			
 
				+    uint64_t v3 = 0x7465646279746573ULL;
			
 
				+    uint64_t k0 = U8TO64_LE(k);
			
 
				+    uint64_t k1 = U8TO64_LE(k + 8);
			
 
				+    uint64_t m;
			
 
				+    const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
			
 
				+    const int left = inlen & 7;
			
 
				+    uint64_t b = ((uint64_t)inlen) << 56;
			
 
				+    v3 ^= k1;
			
 
				+    v2 ^= k0;
			
 
				+    v1 ^= k1;
			
 
				+    v0 ^= k0;
			
 
				+
			
 
				+    for (; in != end; in += 8) {
			
 
				+        m = U8TO64_LE(in);
			
 
				+        v3 ^= m;
			
 
				+
			
 
				+        SIPROUND;
			
 
				+
			
 
				+        v0 ^= m;
			
 
				+    }
			
 
				+
			
 
				+    switch (left) {
			
 
				+    case 7: b |= ((uint64_t)in[6]) << 48; /* fall-thru */
			
 
				+    case 6: b |= ((uint64_t)in[5]) << 40; /* fall-thru */
			
 
				+    case 5: b |= ((uint64_t)in[4]) << 32; /* fall-thru */
			
 
				+    case 4: b |= ((uint64_t)in[3]) << 24; /* fall-thru */
			
 
				+    case 3: b |= ((uint64_t)in[2]) << 16; /* fall-thru */
			
 
				+    case 2: b |= ((uint64_t)in[1]) << 8; /* fall-thru */
			
 
				+    case 1: b |= ((uint64_t)in[0]); break;
			
 
				+    case 0: break;
			
 
				+    }
			
 
				+
			
 
				+    v3 ^= b;
			
 
				+
			
 
				+    SIPROUND;
			
 
				+
			
 
				+    v0 ^= b;
			
 
				+    v2 ^= 0xff;
			
 
				+
			
 
				+    SIPROUND;
			
 
				+    SIPROUND;
			
 
				+
			
 
				+    b = v0 ^ v1 ^ v2 ^ v3;
			
 
				+#ifndef UNALIGNED_LE_CPU
			
 
				+    U64TO8_LE(out, b);
			
 
				+    return hash;
			
 
				+#else
			
 
				+    return b;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+NO_SANITIZE("alignment")
			
 
				+uint64_t siphash_nocase(const uint8_t *in, const size_t inlen, const uint8_t *k)
			
 
				+{
			
 
				+#ifndef UNALIGNED_LE_CPU
			
 
				+    uint64_t hash;
			
 
				+    uint8_t *out = (uint8_t*) &hash;
			
 
				+#endif
			
 
				+    uint64_t v0 = 0x736f6d6570736575ULL;
			
 
				+    uint64_t v1 = 0x646f72616e646f6dULL;
			
 
				+    uint64_t v2 = 0x6c7967656e657261ULL;
			
 
				+    uint64_t v3 = 0x7465646279746573ULL;
			
 
				+    uint64_t k0 = U8TO64_LE(k);
			
 
				+    uint64_t k1 = U8TO64_LE(k + 8);
			
 
				+    uint64_t m;
			
 
				+    const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
			
 
				+    const int left = inlen & 7;
			
 
				+    uint64_t b = ((uint64_t)inlen) << 56;
			
 
				+    v3 ^= k1;
			
 
				+    v2 ^= k0;
			
 
				+    v1 ^= k1;
			
 
				+    v0 ^= k0;
			
 
				+
			
 
				+    for (; in != end; in += 8) {
			
 
				+        m = U8TO64_LE_NOCASE(in);
			
 
				+        v3 ^= m;
			
 
				+
			
 
				+        SIPROUND;
			
 
				+
			
 
				+        v0 ^= m;
			
 
				+    }
			
 
				+
			
 
				+    switch (left) {
			
 
				+    case 7: b |= ((uint64_t)siptlw(in[6])) << 48; /* fall-thru */
			
 
				+    case 6: b |= ((uint64_t)siptlw(in[5])) << 40; /* fall-thru */
			
 
				+    case 5: b |= ((uint64_t)siptlw(in[4])) << 32; /* fall-thru */
			
 
				+    case 4: b |= ((uint64_t)siptlw(in[3])) << 24; /* fall-thru */
			
 
				+    case 3: b |= ((uint64_t)siptlw(in[2])) << 16; /* fall-thru */
			
 
				+    case 2: b |= ((uint64_t)siptlw(in[1])) << 8; /* fall-thru */
			
 
				+    case 1: b |= ((uint64_t)siptlw(in[0])); break;
			
 
				+    case 0: break;
			
 
				+    }
			
 
				+
			
 
				+    v3 ^= b;
			
 
				+
			
 
				+    SIPROUND;
			
 
				+
			
 
				+    v0 ^= b;
			
 
				+    v2 ^= 0xff;
			
 
				+
			
 
				+    SIPROUND;
			
 
				+    SIPROUND;
			
 
				+
			
 
				+    b = v0 ^ v1 ^ v2 ^ v3;
			
 
				+#ifndef UNALIGNED_LE_CPU
			
 
				+    U64TO8_LE(out, b);
			
 
				+    return hash;
			
 
				+#else
			
 
				+    return b;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* --------------------------------- TEST ------------------------------------ */
			
 
				+
			
 
				+#ifdef SIPHASH_TEST
			
 
				+
			
 
				+const uint8_t vectors_sip64[64][8] = {
			
 
				+    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
			
 
				+    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
			
 
				+    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
			
 
				+    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
			
 
				+    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
			
 
				+    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
			
 
				+    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
			
 
				+    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
			
 
				+    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
			
 
				+    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
			
 
				+    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
			
 
				+    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
			
 
				+    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
			
 
				+    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
			
 
				+    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
			
 
				+    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
			
 
				+    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
			
 
				+    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
			
 
				+    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
			
 
				+    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
			
 
				+    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
			
 
				+    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
			
 
				+    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
			
 
				+    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
			
 
				+    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
			
 
				+    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
			
 
				+    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
			
 
				+    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
			
 
				+    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
			
 
				+    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
			
 
				+    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
			
 
				+    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
			
 
				+    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
			
 
				+    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
			
 
				+    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
			
 
				+    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
			
 
				+    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
			
 
				+    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
			
 
				+    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
			
 
				+    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
			
 
				+    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
			
 
				+    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
			
 
				+    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
			
 
				+    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
			
 
				+    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
			
 
				+    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
			
 
				+    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
			
 
				+    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
			
 
				+    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
			
 
				+    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
			
 
				+    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
			
 
				+    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
			
 
				+    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
			
 
				+    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
			
 
				+    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
			
 
				+    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
			
 
				+    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
			
 
				+    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
			
 
				+    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
			
 
				+    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
			
 
				+    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
			
 
				+    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
			
 
				+    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
			
 
				+    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, },
			
 
				+};
			
 
				+
			
 
				+
			
 
				+/* Test siphash using a test vector. Returns 0 if the function passed
			
 
				+ * all the tests, otherwise 1 is returned.
			
 
				+ *
			
 
				+ * IMPORTANT: The test vector is for SipHash 2-4. Before running
			
 
				+ * the test revert back the siphash() function to 2-4 rounds since
			
 
				+ * now it uses 1-2 rounds. */
			
 
				+int siphash_test(void) {
			
 
				+    uint8_t in[64], k[16];
			
 
				+    int i;
			
 
				+    int fails = 0;
			
 
				+
			
 
				+    for (i = 0; i < 16; ++i)
			
 
				+        k[i] = i;
			
 
				+
			
 
				+    for (i = 0; i < 64; ++i) {
			
 
				+        in[i] = i;
			
 
				+        uint64_t hash = siphash(in, i, k);
			
 
				+        const uint8_t *v = NULL;
			
 
				+        v = (uint8_t *)vectors_sip64;
			
 
				+        if (memcmp(&hash, v + (i * 8), 8)) {
			
 
				+            /* printf("fail for %d bytes\n", i); */
			
 
				+            fails++;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    /* Run a few basic tests with the case insensitive version. */
			
 
				+    uint64_t h1, h2;
			
 
				+    h1 = siphash((uint8_t*)"hello world",11,(uint8_t*)"1234567812345678");
			
 
				+    h2 = siphash_nocase((uint8_t*)"hello world",11,(uint8_t*)"1234567812345678");
			
 
				+    if (h1 != h2) fails++;
			
 
				+
			
 
				+    h1 = siphash((uint8_t*)"hello world",11,(uint8_t*)"1234567812345678");
			
 
				+    h2 = siphash_nocase((uint8_t*)"HELLO world",11,(uint8_t*)"1234567812345678");
			
 
				+    if (h1 != h2) fails++;
			
 
				+
			
 
				+    h1 = siphash((uint8_t*)"HELLO world",11,(uint8_t*)"1234567812345678");
			
 
				+    h2 = siphash_nocase((uint8_t*)"HELLO world",11,(uint8_t*)"1234567812345678");
			
 
				+    if (h1 == h2) fails++;
			
 
				+
			
 
				+    if (!fails) return 0;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+int main(void) {
			
 
				+    if (siphash_test() == 0) {
			
 
				+        printf("SipHash test: OK\n");
			
 
				+        return 0;
			
 
				+    } else {
			
 
				+        printf("SipHash test: FAILED\n");
			
 
				+        return 1;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+#endif
			
--- a/src/ziplist.c
+++ b/src/ziplist.c
@@ -0,0 +1,2666 @@
 
				+/* The ziplist is a specially encoded dually linked list that is designed
			
 
				+ * to be very memory efficient. It stores both strings and integer values,
			
 
				+ * where integers are encoded as actual integers instead of a series of
			
 
				+ * characters. It allows push and pop operations on either side of the list
			
 
				+ * in O(1) time. However, because every operation requires a reallocation of
			
 
				+ * the memory used by the ziplist, the actual complexity is related to the
			
 
				+ * amount of memory used by the ziplist.
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * ZIPLIST OVERALL LAYOUT
			
 
				+ * ======================
			
 
				+ *
			
 
				+ * The general layout of the ziplist is as follows:
			
 
				+ *
			
 
				+ * <zlbytes> <zltail> <zllen> <entry> <entry> ... <entry> <zlend>
			
 
				+ *
			
 
				+ * NOTE: all fields are stored in little endian, if not specified otherwise.
			
 
				+ *
			
 
				+ * <uint32_t zlbytes> is an unsigned integer to hold the number of bytes that
			
 
				+ * the ziplist occupies, including the four bytes of the zlbytes field itself.
			
 
				+ * This value needs to be stored to be able to resize the entire structure
			
 
				+ * without the need to traverse it first.
			
 
				+ *
			
 
				+ * <uint32_t zltail> is the offset to the last entry in the list. This allows
			
 
				+ * a pop operation on the far side of the list without the need for full
			
 
				+ * traversal.
			
 
				+ *
			
 
				+ * <uint16_t zllen> is the number of entries. When there are more than
			
 
				+ * 2^16-2 entries, this value is set to 2^16-1 and we need to traverse the
			
 
				+ * entire list to know how many items it holds.
			
 
				+ *
			
 
				+ * <uint8_t zlend> is a special entry representing the end of the ziplist.
			
 
				+ * Is encoded as a single byte equal to 255. No other normal entry starts
			
 
				+ * with a byte set to the value of 255.
			
 
				+ *
			
 
				+ * ZIPLIST ENTRIES
			
 
				+ * ===============
			
 
				+ *
			
 
				+ * Every entry in the ziplist is prefixed by metadata that contains two pieces
			
 
				+ * of information. First, the length of the previous entry is stored to be
			
 
				+ * able to traverse the list from back to front. Second, the entry encoding is
			
 
				+ * provided. It represents the entry type, integer or string, and in the case
			
 
				+ * of strings it also represents the length of the string payload.
			
 
				+ * So a complete entry is stored like this:
			
 
				+ *
			
 
				+ * <prevlen> <encoding> <entry-data>
			
 
				+ *
			
 
				+ * Sometimes the encoding represents the entry itself, like for small integers
			
 
				+ * as we'll see later. In such a case the <entry-data> part is missing, and we
			
 
				+ * could have just:
			
 
				+ *
			
 
				+ * <prevlen> <encoding>
			
 
				+ *
			
 
				+ * The length of the previous entry, <prevlen>, is encoded in the following way:
			
 
				+ * If this length is smaller than 254 bytes, it will only consume a single
			
 
				+ * byte representing the length as an unsigned 8 bit integer. When the length
			
 
				+ * is greater than or equal to 254, it will consume 5 bytes. The first byte is
			
 
				+ * set to 254 (FE) to indicate a larger value is following. The remaining 4
			
 
				+ * bytes take the length of the previous entry as value.
			
 
				+ *
			
 
				+ * So practically an entry is encoded in the following way:
			
 
				+ *
			
 
				+ * <prevlen from 0 to 253> <encoding> <entry>
			
 
				+ *
			
 
				+ * Or alternatively if the previous entry length is greater than 253 bytes
			
 
				+ * the following encoding is used:
			
 
				+ *
			
 
				+ * 0xFE <4 bytes unsigned little endian prevlen> <encoding> <entry>
			
 
				+ *
			
 
				+ * The encoding field of the entry depends on the content of the
			
 
				+ * entry. When the entry is a string, the first 2 bits of the encoding first
			
 
				+ * byte will hold the type of encoding used to store the length of the string,
			
 
				+ * followed by the actual length of the string. When the entry is an integer
			
 
				+ * the first 2 bits are both set to 1. The following 2 bits are used to specify
			
 
				+ * what kind of integer will be stored after this header. An overview of the
			
 
				+ * different types and encodings is as follows. The first byte is always enough
			
 
				+ * to determine the kind of entry.
			
 
				+ *
			
 
				+ * |00pppppp| - 1 byte
			
 
				+ *      String value with length less than or equal to 63 bytes (6 bits).
			
 
				+ *      "pppppp" represents the unsigned 6 bit length.
			
 
				+ * |01pppppp|qqqqqqqq| - 2 bytes
			
 
				+ *      String value with length less than or equal to 16383 bytes (14 bits).
			
 
				+ *      IMPORTANT: The 14 bit number is stored in big endian.
			
 
				+ * |10000000|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt| - 5 bytes
			
 
				+ *      String value with length greater than or equal to 16384 bytes.
			
 
				+ *      Only the 4 bytes following the first byte represents the length
			
 
				+ *      up to 2^32-1. The 6 lower bits of the first byte are not used and
			
 
				+ *      are set to zero.
			
 
				+ *      IMPORTANT: The 32 bit number is stored in big endian.
			
 
				+ * |11000000| - 3 bytes
			
 
				+ *      Integer encoded as int16_t (2 bytes).
			
 
				+ * |11010000| - 5 bytes
			
 
				+ *      Integer encoded as int32_t (4 bytes).
			
 
				+ * |11100000| - 9 bytes
			
 
				+ *      Integer encoded as int64_t (8 bytes).
			
 
				+ * |11110000| - 4 bytes
			
 
				+ *      Integer encoded as 24 bit signed (3 bytes).
			
 
				+ * |11111110| - 2 bytes
			
 
				+ *      Integer encoded as 8 bit signed (1 byte).
			
 
				+ * |1111xxxx| - (with xxxx between 0001 and 1101) immediate 4 bit integer.
			
 
				+ *      Unsigned integer from 0 to 12. The encoded value is actually from
			
 
				+ *      1 to 13 because 0000 and 1111 can not be used, so 1 should be
			
 
				+ *      subtracted from the encoded 4 bit value to obtain the right value.
			
 
				+ * |11111111| - End of ziplist special entry.
			
 
				+ *
			
 
				+ * Like for the ziplist header, all the integers are represented in little
			
 
				+ * endian byte order, even when this code is compiled in big endian systems.
			
 
				+ *
			
 
				+ * EXAMPLES OF ACTUAL ZIPLISTS
			
 
				+ * ===========================
			
 
				+ *
			
 
				+ * The following is a ziplist containing the two elements representing
			
 
				+ * the strings "2" and "5". It is composed of 15 bytes, that we visually
			
 
				+ * split into sections:
			
 
				+ *
			
 
				+ *  [0f 00 00 00] [0c 00 00 00] [02 00] [00 f3] [02 f6] [ff]
			
 
				+ *        |             |          |       |       |     |
			
 
				+ *     zlbytes        zltail    entries   "2"     "5"   end
			
 
				+ *
			
 
				+ * The first 4 bytes represent the number 15, that is the number of bytes
			
 
				+ * the whole ziplist is composed of. The second 4 bytes are the offset
			
 
				+ * at which the last ziplist entry is found, that is 12, in fact the
			
 
				+ * last entry, that is "5", is at offset 12 inside the ziplist.
			
 
				+ * The next 16 bit integer represents the number of elements inside the
			
 
				+ * ziplist, its value is 2 since there are just two elements inside.
			
 
				+ * Finally "00 f3" is the first entry representing the number 2. It is
			
 
				+ * composed of the previous entry length, which is zero because this is
			
 
				+ * our first entry, and the byte F3 which corresponds to the encoding
			
 
				+ * |1111xxxx| with xxxx between 0001 and 1101. We need to remove the "F"
			
 
				+ * higher order bits 1111, and subtract 1 from the "3", so the entry value
			
 
				+ * is "2". The next entry has a prevlen of 02, since the first entry is
			
 
				+ * composed of exactly two bytes. The entry itself, F6, is encoded exactly
			
 
				+ * like the first entry, and 6-1 = 5, so the value of the entry is 5.
			
 
				+ * Finally the special entry FF signals the end of the ziplist.
			
 
				+ *
			
 
				+ * Adding another element to the above string with the value "Hello World"
			
 
				+ * allows us to show how the ziplist encodes small strings. We'll just show
			
 
				+ * the hex dump of the entry itself. Imagine the bytes as following the
			
 
				+ * entry that stores "5" in the ziplist above:
			
 
				+ *
			
 
				+ * [02] [0b] [48 65 6c 6c 6f 20 57 6f 72 6c 64]
			
 
				+ *
			
 
				+ * The first byte, 02, is the length of the previous entry. The next
			
 
				+ * byte represents the encoding in the pattern |00pppppp| that means
			
 
				+ * that the entry is a string of length <pppppp>, so 0B means that
			
 
				+ * an 11 bytes string follows. From the third byte (48) to the last (64)
			
 
				+ * there are just the ASCII characters for "Hello World".
			
 
				+ *
			
 
				+ * ----------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2012, Pieter Noordhuis <pcnoordhuis at gmail dot com>
			
 
				+ * Copyright (c) 2009-2017, Salvatore Sanfilippo <antirez at gmail dot com>
			
 
				+ * Copyright (c) 2020, Redis Labs, Inc
			
 
				+ * 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.
			
 
				+ */
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <string.h>
			
 
				+#include <stdint.h>
			
 
				+#include <limits.h>
			
 
				+#include "zmalloc.h"
			
 
				+#include "util.h"
			
 
				+#include "ziplist.h"
			
 
				+#include "config.h"
			
 
				+#include "endianconv.h"
			
 
				+#include "redisassert.h"
			
 
				+
			
 
				+#define ZIP_END 255         /* Special "end of ziplist" entry. */
			
 
				+#define ZIP_BIG_PREVLEN 254 /* ZIP_BIG_PREVLEN - 1 is the max number of bytes of
			
 
				+                               the previous entry, for the "prevlen" field prefixing
			
 
				+                               each entry, to be represented with just a single byte.
			
 
				+                               Otherwise it is represented as FE AA BB CC DD, where
			
 
				+                               AA BB CC DD are a 4 bytes unsigned integer
			
 
				+                               representing the previous entry len. */
			
 
				+
			
 
				+/* Different encoding/length possibilities */
			
 
				+#define ZIP_STR_MASK 0xc0
			
 
				+#define ZIP_INT_MASK 0x30
			
 
				+#define ZIP_STR_06B (0 << 6)
			
 
				+#define ZIP_STR_14B (1 << 6)
			
 
				+#define ZIP_STR_32B (2 << 6)
			
 
				+#define ZIP_INT_16B (0xc0 | 0<<4)
			
 
				+#define ZIP_INT_32B (0xc0 | 1<<4)
			
 
				+#define ZIP_INT_64B (0xc0 | 2<<4)
			
 
				+#define ZIP_INT_24B (0xc0 | 3<<4)
			
 
				+#define ZIP_INT_8B 0xfe
			
 
				+
			
 
				+/* 4 bit integer immediate encoding |1111xxxx| with xxxx between
			
 
				+ * 0001 and 1101. */
			
 
				+#define ZIP_INT_IMM_MASK 0x0f   /* Mask to extract the 4 bits value. To add
			
 
				+                                   one is needed to reconstruct the value. */
			
 
				+#define ZIP_INT_IMM_MIN 0xf1    /* 11110001 */
			
 
				+#define ZIP_INT_IMM_MAX 0xfd    /* 11111101 */
			
 
				+
			
 
				+#define INT24_MAX 0x7fffff
			
 
				+#define INT24_MIN (-INT24_MAX - 1)
			
 
				+
			
 
				+/* Macro to determine if the entry is a string. String entries never start
			
 
				+ * with "11" as most significant bits of the first byte. */
			
 
				+#define ZIP_IS_STR(enc) (((enc) & ZIP_STR_MASK) < ZIP_STR_MASK)
			
 
				+
			
 
				+/* Utility macros.*/
			
 
				+
			
 
				+/* Return total bytes a ziplist is composed of. */
			
 
				+#define ZIPLIST_BYTES(zl)       (*((uint32_t*)(zl)))
			
 
				+
			
 
				+/* Return the offset of the last item inside the ziplist. */
			
 
				+#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
			
 
				+
			
 
				+/* Return the length of a ziplist, or UINT16_MAX if the length cannot be
			
 
				+ * determined without scanning the whole ziplist. */
			
 
				+#define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
			
 
				+
			
 
				+/* The size of a ziplist header: two 32 bit integers for the total
			
 
				+ * bytes count and last item offset. One 16 bit integer for the number
			
 
				+ * of items field. */
			
 
				+#define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t))
			
 
				+
			
 
				+/* Size of the "end of ziplist" entry. Just one byte. */
			
 
				+#define ZIPLIST_END_SIZE        (sizeof(uint8_t))
			
 
				+
			
 
				+/* Return the pointer to the first entry of a ziplist. */
			
 
				+#define ZIPLIST_ENTRY_HEAD(zl)  ((zl)+ZIPLIST_HEADER_SIZE)
			
 
				+
			
 
				+/* Return the pointer to the last entry of a ziplist, using the
			
 
				+ * last entry offset inside the ziplist header. */
			
 
				+#define ZIPLIST_ENTRY_TAIL(zl)  ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)))
			
 
				+
			
 
				+/* Return the pointer to the last byte of a ziplist, which is, the
			
 
				+ * end of ziplist FF entry. */
			
 
				+#define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)
			
 
				+
			
 
				+/* Increment the number of items field in the ziplist header. Note that this
			
 
				+ * macro should never overflow the unsigned 16 bit integer, since entries are
			
 
				+ * always pushed one at a time. When UINT16_MAX is reached we want the count
			
 
				+ * to stay there to signal that a full scan is needed to get the number of
			
 
				+ * items inside the ziplist. */
			
 
				+#define ZIPLIST_INCR_LENGTH(zl,incr) { \
			
 
				+    if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) \
			
 
				+        ZIPLIST_LENGTH(zl) = intrev16ifbe(intrev16ifbe(ZIPLIST_LENGTH(zl))+incr); \
			
 
				+}
			
 
				+
			
 
				+/* Don't let ziplists grow over 1GB in any case, don't wanna risk overflow in
			
 
				+ * zlbytes */
			
 
				+#define ZIPLIST_MAX_SAFETY_SIZE (1<<30)
			
 
				+int ziplistSafeToAdd(unsigned char* zl, size_t add) {
			
 
				+    size_t len = zl? ziplistBlobLen(zl): 0;
			
 
				+    if (len + add > ZIPLIST_MAX_SAFETY_SIZE)
			
 
				+        return 0;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* We use this function to receive information about a ziplist entry.
			
 
				+ * Note that this is not how the data is actually encoded, is just what we
			
 
				+ * get filled by a function in order to operate more easily. */
			
 
				+typedef struct zlentry {
			
 
				+    unsigned int prevrawlensize; /* Bytes used to encode the previous entry len*/
			
 
				+    unsigned int prevrawlen;     /* Previous entry len. */
			
 
				+    unsigned int lensize;        /* Bytes used to encode this entry type/len.
			
 
				+                                    For example strings have a 1, 2 or 5 bytes
			
 
				+                                    header. Integers always use a single byte.*/
			
 
				+    unsigned int len;            /* Bytes used to represent the actual entry.
			
 
				+                                    For strings this is just the string length
			
 
				+                                    while for integers it is 1, 2, 3, 4, 8 or
			
 
				+                                    0 (for 4 bit immediate) depending on the
			
 
				+                                    number range. */
			
 
				+    unsigned int headersize;     /* prevrawlensize + lensize. */
			
 
				+    unsigned char encoding;      /* Set to ZIP_STR_* or ZIP_INT_* depending on
			
 
				+                                    the entry encoding. However for 4 bits
			
 
				+                                    immediate integers this can assume a range
			
 
				+                                    of values and must be range-checked. */
			
 
				+    unsigned char *p;            /* Pointer to the very start of the entry, that
			
 
				+                                    is, this points to prev-entry-len field. */
			
 
				+} zlentry;
			
 
				+
			
 
				+#define ZIPLIST_ENTRY_ZERO(zle) { \
			
 
				+    (zle)->prevrawlensize = (zle)->prevrawlen = 0; \
			
 
				+    (zle)->lensize = (zle)->len = (zle)->headersize = 0; \
			
 
				+    (zle)->encoding = 0; \
			
 
				+    (zle)->p = NULL; \
			
 
				+}
			
 
				+
			
 
				+/* Extract the encoding from the byte pointed by 'ptr' and set it into
			
 
				+ * 'encoding' field of the zlentry structure. */
			
 
				+#define ZIP_ENTRY_ENCODING(ptr, encoding) do {  \
			
 
				+    (encoding) = ((ptr)[0]); \
			
 
				+    if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \
			
 
				+} while(0)
			
 
				+
			
 
				+#define ZIP_ENCODING_SIZE_INVALID 0xff
			
 
				+/* Return the number of bytes required to encode the entry type + length.
			
 
				+ * On error, return ZIP_ENCODING_SIZE_INVALID */
			
 
				+static inline unsigned int zipEncodingLenSize(unsigned char encoding) {
			
 
				+    if (encoding == ZIP_INT_16B || encoding == ZIP_INT_32B ||
			
 
				+        encoding == ZIP_INT_24B || encoding == ZIP_INT_64B ||
			
 
				+        encoding == ZIP_INT_8B)
			
 
				+        return 1;
			
 
				+    if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)
			
 
				+        return 1;
			
 
				+    if (encoding == ZIP_STR_06B)
			
 
				+        return 1;
			
 
				+    if (encoding == ZIP_STR_14B)
			
 
				+        return 2;
			
 
				+    if (encoding == ZIP_STR_32B)
			
 
				+        return 5;
			
 
				+    return ZIP_ENCODING_SIZE_INVALID;
			
 
				+}
			
 
				+
			
 
				+#define ZIP_ASSERT_ENCODING(encoding) do {                                     \
			
 
				+    assert(zipEncodingLenSize(encoding) != ZIP_ENCODING_SIZE_INVALID);         \
			
 
				+} while (0)
			
 
				+
			
 
				+/* Return bytes needed to store integer encoded by 'encoding' */
			
 
				+static inline unsigned int zipIntSize(unsigned char encoding) {
			
 
				+    switch(encoding) {
			
 
				+    case ZIP_INT_8B:  return 1;
			
 
				+    case ZIP_INT_16B: return 2;
			
 
				+    case ZIP_INT_24B: return 3;
			
 
				+    case ZIP_INT_32B: return 4;
			
 
				+    case ZIP_INT_64B: return 8;
			
 
				+    }
			
 
				+    if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)
			
 
				+        return 0; /* 4 bit immediate */
			
 
				+    /* bad encoding, covered by a previous call to ZIP_ASSERT_ENCODING */
			
 
				+    redis_unreachable();
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Write the encoding header of the entry in 'p'. If p is NULL it just returns
			
 
				+ * the amount of bytes required to encode such a length. Arguments:
			
 
				+ *
			
 
				+ * 'encoding' is the encoding we are using for the entry. It could be
			
 
				+ * ZIP_INT_* or ZIP_STR_* or between ZIP_INT_IMM_MIN and ZIP_INT_IMM_MAX
			
 
				+ * for single-byte small immediate integers.
			
 
				+ *
			
 
				+ * 'rawlen' is only used for ZIP_STR_* encodings and is the length of the
			
 
				+ * string that this entry represents.
			
 
				+ *
			
 
				+ * The function returns the number of bytes used by the encoding/length
			
 
				+ * header stored in 'p'. */
			
 
				+unsigned int zipStoreEntryEncoding(unsigned char *p, unsigned char encoding, unsigned int rawlen) {
			
 
				+    unsigned char len = 1, buf[5];
			
 
				+
			
 
				+    if (ZIP_IS_STR(encoding)) {
			
 
				+        /* Although encoding is given it may not be set for strings,
			
 
				+         * so we determine it here using the raw length. */
			
 
				+        if (rawlen <= 0x3f) {
			
 
				+            if (!p) return len;
			
 
				+            buf[0] = ZIP_STR_06B | rawlen;
			
 
				+        } else if (rawlen <= 0x3fff) {
			
 
				+            len += 1;
			
 
				+            if (!p) return len;
			
 
				+            buf[0] = ZIP_STR_14B | ((rawlen >> 8) & 0x3f);
			
 
				+            buf[1] = rawlen & 0xff;
			
 
				+        } else {
			
 
				+            len += 4;
			
 
				+            if (!p) return len;
			
 
				+            buf[0] = ZIP_STR_32B;
			
 
				+            buf[1] = (rawlen >> 24) & 0xff;
			
 
				+            buf[2] = (rawlen >> 16) & 0xff;
			
 
				+            buf[3] = (rawlen >> 8) & 0xff;
			
 
				+            buf[4] = rawlen & 0xff;
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* Implies integer encoding, so length is always 1. */
			
 
				+        if (!p) return len;
			
 
				+        buf[0] = encoding;
			
 
				+    }
			
 
				+
			
 
				+    /* Store this length at p. */
			
 
				+    memcpy(p,buf,len);
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+/* Decode the entry encoding type and data length (string length for strings,
			
 
				+ * number of bytes used for the integer for integer entries) encoded in 'ptr'.
			
 
				+ * The 'encoding' variable is input, extracted by the caller, the 'lensize'
			
 
				+ * variable will hold the number of bytes required to encode the entry
			
 
				+ * length, and the 'len' variable will hold the entry length.
			
 
				+ * On invalid encoding error, lensize is set to 0. */
			
 
				+#define ZIP_DECODE_LENGTH(ptr, encoding, lensize, len) do {                    \
			
 
				+    if ((encoding) < ZIP_STR_MASK) {                                           \
			
 
				+        if ((encoding) == ZIP_STR_06B) {                                       \
			
 
				+            (lensize) = 1;                                                     \
			
 
				+            (len) = (ptr)[0] & 0x3f;                                           \
			
 
				+        } else if ((encoding) == ZIP_STR_14B) {                                \
			
 
				+            (lensize) = 2;                                                     \
			
 
				+            (len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1];                       \
			
 
				+        } else if ((encoding) == ZIP_STR_32B) {                                \
			
 
				+            (lensize) = 5;                                                     \
			
 
				+            (len) = ((uint32_t)(ptr)[1] << 24) |                               \
			
 
				+                    ((uint32_t)(ptr)[2] << 16) |                               \
			
 
				+                    ((uint32_t)(ptr)[3] <<  8) |                               \
			
 
				+                    ((uint32_t)(ptr)[4]);                                      \
			
 
				+        } else {                                                               \
			
 
				+            (lensize) = 0; /* bad encoding, should be covered by a previous */ \
			
 
				+            (len) = 0;     /* ZIP_ASSERT_ENCODING / zipEncodingLenSize, or  */ \
			
 
				+                           /* match the lensize after this macro with 0.    */ \
			
 
				+        }                                                                      \
			
 
				+    } else {                                                                   \
			
 
				+        (lensize) = 1;                                                         \
			
 
				+        if ((encoding) == ZIP_INT_8B)  (len) = 1;                              \
			
 
				+        else if ((encoding) == ZIP_INT_16B) (len) = 2;                         \
			
 
				+        else if ((encoding) == ZIP_INT_24B) (len) = 3;                         \
			
 
				+        else if ((encoding) == ZIP_INT_32B) (len) = 4;                         \
			
 
				+        else if ((encoding) == ZIP_INT_64B) (len) = 8;                         \
			
 
				+        else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)   \
			
 
				+            (len) = 0; /* 4 bit immediate */                                   \
			
 
				+        else                                                                   \
			
 
				+            (lensize) = (len) = 0; /* bad encoding */                          \
			
 
				+    }                                                                          \
			
 
				+} while(0)
			
 
				+
			
 
				+/* Encode the length of the previous entry and write it to "p". This only
			
 
				+ * uses the larger encoding (required in __ziplistCascadeUpdate). */
			
 
				+int zipStorePrevEntryLengthLarge(unsigned char *p, unsigned int len) {
			
 
				+    uint32_t u32;
			
 
				+    if (p != NULL) {
			
 
				+        p[0] = ZIP_BIG_PREVLEN;
			
 
				+        u32 = len;
			
 
				+        memcpy(p+1,&u32,sizeof(u32));
			
 
				+        memrev32ifbe(p+1);
			
 
				+    }
			
 
				+    return 1 + sizeof(uint32_t);
			
 
				+}
			
 
				+
			
 
				+/* Encode the length of the previous entry and write it to "p". Return the
			
 
				+ * number of bytes needed to encode this length if "p" is NULL. */
			
 
				+unsigned int zipStorePrevEntryLength(unsigned char *p, unsigned int len) {
			
 
				+    if (p == NULL) {
			
 
				+        return (len < ZIP_BIG_PREVLEN) ? 1 : sizeof(uint32_t) + 1;
			
 
				+    } else {
			
 
				+        if (len < ZIP_BIG_PREVLEN) {
			
 
				+            p[0] = len;
			
 
				+            return 1;
			
 
				+        } else {
			
 
				+            return zipStorePrevEntryLengthLarge(p,len);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Return the number of bytes used to encode the length of the previous
			
 
				+ * entry. The length is returned by setting the var 'prevlensize'. */
			
 
				+#define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) do {                          \
			
 
				+    if ((ptr)[0] < ZIP_BIG_PREVLEN) {                                          \
			
 
				+        (prevlensize) = 1;                                                     \
			
 
				+    } else {                                                                   \
			
 
				+        (prevlensize) = 5;                                                     \
			
 
				+    }                                                                          \
			
 
				+} while(0)
			
 
				+
			
 
				+/* Return the length of the previous element, and the number of bytes that
			
 
				+ * are used in order to encode the previous element length.
			
 
				+ * 'ptr' must point to the prevlen prefix of an entry (that encodes the
			
 
				+ * length of the previous entry in order to navigate the elements backward).
			
 
				+ * The length of the previous entry is stored in 'prevlen', the number of
			
 
				+ * bytes needed to encode the previous entry length are stored in
			
 
				+ * 'prevlensize'. */
			
 
				+#define ZIP_DECODE_PREVLEN(ptr, prevlensize, prevlen) do {                     \
			
 
				+    ZIP_DECODE_PREVLENSIZE(ptr, prevlensize);                                  \
			
 
				+    if ((prevlensize) == 1) {                                                  \
			
 
				+        (prevlen) = (ptr)[0];                                                  \
			
 
				+    } else { /* prevlensize == 5 */                                            \
			
 
				+        (prevlen) = ((ptr)[4] << 24) |                                         \
			
 
				+                    ((ptr)[3] << 16) |                                         \
			
 
				+                    ((ptr)[2] <<  8) |                                         \
			
 
				+                    ((ptr)[1]);                                                \
			
 
				+    }                                                                          \
			
 
				+} while(0)
			
 
				+
			
 
				+/* Given a pointer 'p' to the prevlen info that prefixes an entry, this
			
 
				+ * function returns the difference in number of bytes needed to encode
			
 
				+ * the prevlen if the previous entry changes of size.
			
 
				+ *
			
 
				+ * So if A is the number of bytes used right now to encode the 'prevlen'
			
 
				+ * field.
			
 
				+ *
			
 
				+ * And B is the number of bytes that are needed in order to encode the
			
 
				+ * 'prevlen' if the previous element will be updated to one of size 'len'.
			
 
				+ *
			
 
				+ * Then the function returns B - A
			
 
				+ *
			
 
				+ * So the function returns a positive number if more space is needed,
			
 
				+ * a negative number if less space is needed, or zero if the same space
			
 
				+ * is needed. */
			
 
				+int zipPrevLenByteDiff(unsigned char *p, unsigned int len) {
			
 
				+    unsigned int prevlensize;
			
 
				+    ZIP_DECODE_PREVLENSIZE(p, prevlensize);
			
 
				+    return zipStorePrevEntryLength(NULL, len) - prevlensize;
			
 
				+}
			
 
				+
			
 
				+/* Check if string pointed to by 'entry' can be encoded as an integer.
			
 
				+ * Stores the integer value in 'v' and its encoding in 'encoding'. */
			
 
				+int zipTryEncoding(unsigned char *entry, unsigned int entrylen, long long *v, unsigned char *encoding) {
			
 
				+    long long value;
			
 
				+
			
 
				+    if (entrylen >= 32 || entrylen == 0) return 0;
			
 
				+    if (string2ll((char*)entry,entrylen,&value)) {
			
 
				+        /* Great, the string can be encoded. Check what's the smallest
			
 
				+         * of our encoding types that can hold this value. */
			
 
				+        if (value >= 0 && value <= 12) {
			
 
				+            *encoding = ZIP_INT_IMM_MIN+value;
			
 
				+        } else if (value >= INT8_MIN && value <= INT8_MAX) {
			
 
				+            *encoding = ZIP_INT_8B;
			
 
				+        } else if (value >= INT16_MIN && value <= INT16_MAX) {
			
 
				+            *encoding = ZIP_INT_16B;
			
 
				+        } else if (value >= INT24_MIN && value <= INT24_MAX) {
			
 
				+            *encoding = ZIP_INT_24B;
			
 
				+        } else if (value >= INT32_MIN && value <= INT32_MAX) {
			
 
				+            *encoding = ZIP_INT_32B;
			
 
				+        } else {
			
 
				+            *encoding = ZIP_INT_64B;
			
 
				+        }
			
 
				+        *v = value;
			
 
				+        return 1;
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Store integer 'value' at 'p', encoded as 'encoding' */
			
 
				+void zipSaveInteger(unsigned char *p, int64_t value, unsigned char encoding) {
			
 
				+    int16_t i16;
			
 
				+    int32_t i32;
			
 
				+    int64_t i64;
			
 
				+    if (encoding == ZIP_INT_8B) {
			
 
				+        ((int8_t*)p)[0] = (int8_t)value;
			
 
				+    } else if (encoding == ZIP_INT_16B) {
			
 
				+        i16 = value;
			
 
				+        memcpy(p,&i16,sizeof(i16));
			
 
				+        memrev16ifbe(p);
			
 
				+    } else if (encoding == ZIP_INT_24B) {
			
 
				+        i32 = ((uint64_t)value)<<8;
			
 
				+        memrev32ifbe(&i32);
			
 
				+        memcpy(p,((uint8_t*)&i32)+1,sizeof(i32)-sizeof(uint8_t));
			
 
				+    } else if (encoding == ZIP_INT_32B) {
			
 
				+        i32 = value;
			
 
				+        memcpy(p,&i32,sizeof(i32));
			
 
				+        memrev32ifbe(p);
			
 
				+    } else if (encoding == ZIP_INT_64B) {
			
 
				+        i64 = value;
			
 
				+        memcpy(p,&i64,sizeof(i64));
			
 
				+        memrev64ifbe(p);
			
 
				+    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
			
 
				+        /* Nothing to do, the value is stored in the encoding itself. */
			
 
				+    } else {
			
 
				+        assert(NULL);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Read integer encoded as 'encoding' from 'p' */
			
 
				+int64_t zipLoadInteger(unsigned char *p, unsigned char encoding) {
			
 
				+    int16_t i16;
			
 
				+    int32_t i32;
			
 
				+    int64_t i64, ret = 0;
			
 
				+    if (encoding == ZIP_INT_8B) {
			
 
				+        ret = ((int8_t*)p)[0];
			
 
				+    } else if (encoding == ZIP_INT_16B) {
			
 
				+        memcpy(&i16,p,sizeof(i16));
			
 
				+        memrev16ifbe(&i16);
			
 
				+        ret = i16;
			
 
				+    } else if (encoding == ZIP_INT_32B) {
			
 
				+        memcpy(&i32,p,sizeof(i32));
			
 
				+        memrev32ifbe(&i32);
			
 
				+        ret = i32;
			
 
				+    } else if (encoding == ZIP_INT_24B) {
			
 
				+        i32 = 0;
			
 
				+        memcpy(((uint8_t*)&i32)+1,p,sizeof(i32)-sizeof(uint8_t));
			
 
				+        memrev32ifbe(&i32);
			
 
				+        ret = i32>>8;
			
 
				+    } else if (encoding == ZIP_INT_64B) {
			
 
				+        memcpy(&i64,p,sizeof(i64));
			
 
				+        memrev64ifbe(&i64);
			
 
				+        ret = i64;
			
 
				+    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
			
 
				+        ret = (encoding & ZIP_INT_IMM_MASK)-1;
			
 
				+    } else {
			
 
				+        assert(NULL);
			
 
				+    }
			
 
				+    return ret;
			
 
				+}
			
 
				+
			
 
				+/* Fills a struct with all information about an entry.
			
 
				+ * This function is the "unsafe" alternative to the one blow.
			
 
				+ * Generally, all function that return a pointer to an element in the ziplist
			
 
				+ * will assert that this element is valid, so it can be freely used.
			
 
				+ * Generally functions such ziplistGet assume the input pointer is already
			
 
				+ * validated (since it's the return value of another function). */
			
 
				+static inline void zipEntry(unsigned char *p, zlentry *e) {
			
 
				+    ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
			
 
				+    ZIP_ENTRY_ENCODING(p + e->prevrawlensize, e->encoding);
			
 
				+    ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
			
 
				+    assert(e->lensize != 0); /* check that encoding was valid. */
			
 
				+    e->headersize = e->prevrawlensize + e->lensize;
			
 
				+    e->p = p;
			
 
				+}
			
 
				+
			
 
				+/* Fills a struct with all information about an entry.
			
 
				+ * This function is safe to use on untrusted pointers, it'll make sure not to
			
 
				+ * try to access memory outside the ziplist payload.
			
 
				+ * Returns 1 if the entry is valid, and 0 otherwise. */
			
 
				+static inline int zipEntrySafe(unsigned char* zl, size_t zlbytes, unsigned char *p, zlentry *e, int validate_prevlen) {
			
 
				+    unsigned char *zlfirst = zl + ZIPLIST_HEADER_SIZE;
			
 
				+    unsigned char *zllast = zl + zlbytes - ZIPLIST_END_SIZE;
			
 
				+#define OUT_OF_RANGE(p) (unlikely((p) < zlfirst || (p) > zllast))
			
 
				+
			
 
				+    /* If there's no possibility for the header to reach outside the ziplist,
			
 
				+     * take the fast path. (max lensize and prevrawlensize are both 5 bytes) */
			
 
				+    if (p >= zlfirst && p + 10 < zllast) {
			
 
				+        ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
			
 
				+        ZIP_ENTRY_ENCODING(p + e->prevrawlensize, e->encoding);
			
 
				+        ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
			
 
				+        e->headersize = e->prevrawlensize + e->lensize;
			
 
				+        e->p = p;
			
 
				+        /* We didn't call ZIP_ASSERT_ENCODING, so we check lensize was set to 0. */
			
 
				+        if (unlikely(e->lensize == 0))
			
 
				+            return 0;
			
 
				+        /* Make sure the entry doesn't reach outside the edge of the ziplist */
			
 
				+        if (OUT_OF_RANGE(p + e->headersize + e->len))
			
 
				+            return 0;
			
 
				+        /* Make sure prevlen doesn't reach outside the edge of the ziplist */
			
 
				+        if (validate_prevlen && OUT_OF_RANGE(p - e->prevrawlen))
			
 
				+            return 0;
			
 
				+        return 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Make sure the pointer doesn't reach outside the edge of the ziplist */
			
 
				+    if (OUT_OF_RANGE(p))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Make sure the encoded prevlen header doesn't reach outside the allocation */
			
 
				+    ZIP_DECODE_PREVLENSIZE(p, e->prevrawlensize);
			
 
				+    if (OUT_OF_RANGE(p + e->prevrawlensize))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Make sure encoded entry header is valid. */
			
 
				+    ZIP_ENTRY_ENCODING(p + e->prevrawlensize, e->encoding);
			
 
				+    e->lensize = zipEncodingLenSize(e->encoding);
			
 
				+    if (unlikely(e->lensize == ZIP_ENCODING_SIZE_INVALID))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Make sure the encoded entry header doesn't reach outside the allocation */
			
 
				+    if (OUT_OF_RANGE(p + e->prevrawlensize + e->lensize))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Decode the prevlen and entry len headers. */
			
 
				+    ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
			
 
				+    ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
			
 
				+    e->headersize = e->prevrawlensize + e->lensize;
			
 
				+
			
 
				+    /* Make sure the entry doesn't reach outside the edge of the ziplist */
			
 
				+    if (OUT_OF_RANGE(p + e->headersize + e->len))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Make sure prevlen doesn't reach outside the edge of the ziplist */
			
 
				+    if (validate_prevlen && OUT_OF_RANGE(p - e->prevrawlen))
			
 
				+        return 0;
			
 
				+
			
 
				+    e->p = p;
			
 
				+    return 1;
			
 
				+#undef OUT_OF_RANGE
			
 
				+}
			
 
				+
			
 
				+/* Return the total number of bytes used by the entry pointed to by 'p'. */
			
 
				+static inline unsigned int zipRawEntryLengthSafe(unsigned char* zl, size_t zlbytes, unsigned char *p) {
			
 
				+    zlentry e;
			
 
				+    assert(zipEntrySafe(zl, zlbytes, p, &e, 0));
			
 
				+    return e.headersize + e.len;
			
 
				+}
			
 
				+
			
 
				+/* Return the total number of bytes used by the entry pointed to by 'p'. */
			
 
				+static inline unsigned int zipRawEntryLength(unsigned char *p) {
			
 
				+    zlentry e;
			
 
				+    zipEntry(p, &e);
			
 
				+    return e.headersize + e.len;
			
 
				+}
			
 
				+
			
 
				+/* Validate that the entry doesn't reach outside the ziplist allocation. */
			
 
				+static inline void zipAssertValidEntry(unsigned char* zl, size_t zlbytes, unsigned char *p) {
			
 
				+    zlentry e;
			
 
				+    assert(zipEntrySafe(zl, zlbytes, p, &e, 1));
			
 
				+}
			
 
				+
			
 
				+/* Create a new empty ziplist. */
			
 
				+unsigned char *ziplistNew(void) {
			
 
				+    unsigned int bytes = ZIPLIST_HEADER_SIZE+ZIPLIST_END_SIZE;
			
 
				+    unsigned char *zl = zmalloc(bytes);
			
 
				+    ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
			
 
				+    ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
			
 
				+    ZIPLIST_LENGTH(zl) = 0;
			
 
				+    zl[bytes-1] = ZIP_END;
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Resize the ziplist. */
			
 
				+unsigned char *ziplistResize(unsigned char *zl, size_t len) {
			
 
				+    assert(len < UINT32_MAX);
			
 
				+    zl = zrealloc(zl,len);
			
 
				+    ZIPLIST_BYTES(zl) = intrev32ifbe(len);
			
 
				+    zl[len-1] = ZIP_END;
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* When an entry is inserted, we need to set the prevlen field of the next
			
 
				+ * entry to equal the length of the inserted entry. It can occur that this
			
 
				+ * length cannot be encoded in 1 byte and the next entry needs to be grow
			
 
				+ * a bit larger to hold the 5-byte encoded prevlen. This can be done for free,
			
 
				+ * because this only happens when an entry is already being inserted (which
			
 
				+ * causes a realloc and memmove). However, encoding the prevlen may require
			
 
				+ * that this entry is grown as well. This effect may cascade throughout
			
 
				+ * the ziplist when there are consecutive entries with a size close to
			
 
				+ * ZIP_BIG_PREVLEN, so we need to check that the prevlen can be encoded in
			
 
				+ * every consecutive entry.
			
 
				+ *
			
 
				+ * Note that this effect can also happen in reverse, where the bytes required
			
 
				+ * to encode the prevlen field can shrink. This effect is deliberately ignored,
			
 
				+ * because it can cause a "flapping" effect where a chain prevlen fields is
			
 
				+ * first grown and then shrunk again after consecutive inserts. Rather, the
			
 
				+ * field is allowed to stay larger than necessary, because a large prevlen
			
 
				+ * field implies the ziplist is holding large entries anyway.
			
 
				+ *
			
 
				+ * The pointer "p" points to the first entry that does NOT need to be
			
 
				+ * updated, i.e. consecutive fields MAY need an update. */
			
 
				+unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p) {
			
 
				+    zlentry cur;
			
 
				+    size_t prevlen, prevlensize, prevoffset; /* Informat of the last changed entry. */
			
 
				+    size_t firstentrylen; /* Used to handle insert at head. */
			
 
				+    size_t rawlen, curlen = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+    size_t extra = 0, cnt = 0, offset;
			
 
				+    size_t delta = 4; /* Extra bytes needed to update a entry's prevlen (5-1). */
			
 
				+    unsigned char *tail = zl + intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl));
			
 
				+
			
 
				+    /* Empty ziplist */
			
 
				+    if (p[0] == ZIP_END) return zl;
			
 
				+
			
 
				+    zipEntry(p, &cur); /* no need for "safe" variant since the input pointer was validated by the function that returned it. */
			
 
				+    firstentrylen = prevlen = cur.headersize + cur.len;
			
 
				+    prevlensize = zipStorePrevEntryLength(NULL, prevlen);
			
 
				+    prevoffset = p - zl;
			
 
				+    p += prevlen;
			
 
				+
			
 
				+    /* Iterate ziplist to find out how many extra bytes do we need to update it. */
			
 
				+    while (p[0] != ZIP_END) {
			
 
				+        assert(zipEntrySafe(zl, curlen, p, &cur, 0));
			
 
				+
			
 
				+        /* Abort when "prevlen" has not changed. */
			
 
				+        if (cur.prevrawlen == prevlen) break;
			
 
				+
			
 
				+        /* Abort when entry's "prevlensize" is big enough. */
			
 
				+        if (cur.prevrawlensize >= prevlensize) {
			
 
				+            if (cur.prevrawlensize == prevlensize) {
			
 
				+                zipStorePrevEntryLength(p, prevlen);
			
 
				+            } else {
			
 
				+                /* This would result in shrinking, which we want to avoid.
			
 
				+                 * So, set "prevlen" in the available bytes. */
			
 
				+                zipStorePrevEntryLengthLarge(p, prevlen);
			
 
				+            }
			
 
				+            break;
			
 
				+        }
			
 
				+
			
 
				+        /* cur.prevrawlen means cur is the former head entry. */
			
 
				+        assert(cur.prevrawlen == 0 || cur.prevrawlen + delta == prevlen);
			
 
				+
			
 
				+        /* Update prev entry's info and advance the cursor. */
			
 
				+        rawlen = cur.headersize + cur.len;
			
 
				+        prevlen = rawlen + delta; 
			
 
				+        prevlensize = zipStorePrevEntryLength(NULL, prevlen);
			
 
				+        prevoffset = p - zl;
			
 
				+        p += rawlen;
			
 
				+        extra += delta;
			
 
				+        cnt++;
			
 
				+    }
			
 
				+
			
 
				+    /* Extra bytes is zero all update has been done(or no need to update). */
			
 
				+    if (extra == 0) return zl;
			
 
				+
			
 
				+    /* Update tail offset after loop. */
			
 
				+    if (tail == zl + prevoffset) {
			
 
				+        /* When the the last entry we need to update is also the tail, update tail offset
			
 
				+         * unless this is the only entry that was updated (so the tail offset didn't change). */
			
 
				+        if (extra - delta != 0) {
			
 
				+            ZIPLIST_TAIL_OFFSET(zl) =
			
 
				+                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra-delta);
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* Update the tail offset in cases where the last entry we updated is not the tail. */
			
 
				+        ZIPLIST_TAIL_OFFSET(zl) =
			
 
				+            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
			
 
				+    }
			
 
				+
			
 
				+    /* Now "p" points at the first unchanged byte in original ziplist,
			
 
				+     * move data after that to new ziplist. */
			
 
				+    offset = p - zl;
			
 
				+    zl = ziplistResize(zl, curlen + extra);
			
 
				+    p = zl + offset;
			
 
				+    memmove(p + extra, p, curlen - offset - 1);
			
 
				+    p += extra;
			
 
				+
			
 
				+    /* Iterate all entries that need to be updated tail to head. */
			
 
				+    while (cnt) {
			
 
				+        zipEntry(zl + prevoffset, &cur); /* no need for "safe" variant since we already iterated on all these entries above. */
			
 
				+        rawlen = cur.headersize + cur.len;
			
 
				+        /* Move entry to tail and reset prevlen. */
			
 
				+        memmove(p - (rawlen - cur.prevrawlensize), 
			
 
				+                zl + prevoffset + cur.prevrawlensize, 
			
 
				+                rawlen - cur.prevrawlensize);
			
 
				+        p -= (rawlen + delta);
			
 
				+        if (cur.prevrawlen == 0) {
			
 
				+            /* "cur" is the previous head entry, update its prevlen with firstentrylen. */
			
 
				+            zipStorePrevEntryLength(p, firstentrylen);
			
 
				+        } else {
			
 
				+            /* An entry's prevlen can only increment 4 bytes. */
			
 
				+            zipStorePrevEntryLength(p, cur.prevrawlen+delta);
			
 
				+        }
			
 
				+        /* Forward to previous entry. */
			
 
				+        prevoffset -= cur.prevrawlen;
			
 
				+        cnt--;
			
 
				+    }
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Delete "num" entries, starting at "p". Returns pointer to the ziplist. */
			
 
				+unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) {
			
 
				+    unsigned int i, totlen, deleted = 0;
			
 
				+    size_t offset;
			
 
				+    int nextdiff = 0;
			
 
				+    zlentry first, tail;
			
 
				+    size_t zlbytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+
			
 
				+    zipEntry(p, &first); /* no need for "safe" variant since the input pointer was validated by the function that returned it. */
			
 
				+    for (i = 0; p[0] != ZIP_END && i < num; i++) {
			
 
				+        p += zipRawEntryLengthSafe(zl, zlbytes, p);
			
 
				+        deleted++;
			
 
				+    }
			
 
				+
			
 
				+    assert(p >= first.p);
			
 
				+    totlen = p-first.p; /* Bytes taken by the element(s) to delete. */
			
 
				+    if (totlen > 0) {
			
 
				+        uint32_t set_tail;
			
 
				+        if (p[0] != ZIP_END) {
			
 
				+            /* Storing `prevrawlen` in this entry may increase or decrease the
			
 
				+             * number of bytes required compare to the current `prevrawlen`.
			
 
				+             * There always is room to store this, because it was previously
			
 
				+             * stored by an entry that is now being deleted. */
			
 
				+            nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
			
 
				+
			
 
				+            /* Note that there is always space when p jumps backward: if
			
 
				+             * the new previous entry is large, one of the deleted elements
			
 
				+             * had a 5 bytes prevlen header, so there is for sure at least
			
 
				+             * 5 bytes free and we need just 4. */
			
 
				+            p -= nextdiff;
			
 
				+            assert(p >= first.p && p<zl+zlbytes-1);
			
 
				+            zipStorePrevEntryLength(p,first.prevrawlen);
			
 
				+
			
 
				+            /* Update offset for tail */
			
 
				+            set_tail = intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))-totlen;
			
 
				+
			
 
				+            /* When the tail contains more than one entry, we need to take
			
 
				+             * "nextdiff" in account as well. Otherwise, a change in the
			
 
				+             * size of prevlen doesn't have an effect on the *tail* offset. */
			
 
				+            assert(zipEntrySafe(zl, zlbytes, p, &tail, 1));
			
 
				+            if (p[tail.headersize+tail.len] != ZIP_END) {
			
 
				+                set_tail = set_tail + nextdiff;
			
 
				+            }
			
 
				+
			
 
				+            /* Move tail to the front of the ziplist */
			
 
				+            /* since we asserted that p >= first.p. we know totlen >= 0,
			
 
				+             * so we know that p > first.p and this is guaranteed not to reach
			
 
				+             * beyond the allocation, even if the entries lens are corrupted. */
			
 
				+            size_t bytes_to_move = zlbytes-(p-zl)-1;
			
 
				+            memmove(first.p,p,bytes_to_move);
			
 
				+        } else {
			
 
				+            /* The entire tail was deleted. No need to move memory. */
			
 
				+            set_tail = (first.p-zl)-first.prevrawlen;
			
 
				+        }
			
 
				+
			
 
				+        /* Resize the ziplist */
			
 
				+        offset = first.p-zl;
			
 
				+        zlbytes -= totlen - nextdiff;
			
 
				+        zl = ziplistResize(zl, zlbytes);
			
 
				+        p = zl+offset;
			
 
				+
			
 
				+        /* Update record count */
			
 
				+        ZIPLIST_INCR_LENGTH(zl,-deleted);
			
 
				+
			
 
				+        /* Set the tail offset computed above */
			
 
				+        assert(set_tail <= zlbytes - ZIPLIST_END_SIZE);
			
 
				+        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(set_tail);
			
 
				+
			
 
				+        /* When nextdiff != 0, the raw length of the next entry has changed, so
			
 
				+         * we need to cascade the update throughout the ziplist */
			
 
				+        if (nextdiff != 0)
			
 
				+            zl = __ziplistCascadeUpdate(zl,p);
			
 
				+    }
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Insert item at "p". */
			
 
				+unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
			
 
				+    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen, newlen;
			
 
				+    unsigned int prevlensize, prevlen = 0;
			
 
				+    size_t offset;
			
 
				+    int nextdiff = 0;
			
 
				+    unsigned char encoding = 0;
			
 
				+    long long value = 123456789; /* initialized to avoid warning. Using a value
			
 
				+                                    that is easy to see if for some reason
			
 
				+                                    we use it uninitialized. */
			
 
				+    zlentry tail;
			
 
				+
			
 
				+    /* Find out prevlen for the entry that is inserted. */
			
 
				+    if (p[0] != ZIP_END) {
			
 
				+        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
			
 
				+    } else {
			
 
				+        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
			
 
				+        if (ptail[0] != ZIP_END) {
			
 
				+            prevlen = zipRawEntryLengthSafe(zl, curlen, ptail);
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    /* See if the entry can be encoded */
			
 
				+    if (zipTryEncoding(s,slen,&value,&encoding)) {
			
 
				+        /* 'encoding' is set to the appropriate integer encoding */
			
 
				+        reqlen = zipIntSize(encoding);
			
 
				+    } else {
			
 
				+        /* 'encoding' is untouched, however zipStoreEntryEncoding will use the
			
 
				+         * string length to figure out how to encode it. */
			
 
				+        reqlen = slen;
			
 
				+    }
			
 
				+    /* We need space for both the length of the previous entry and
			
 
				+     * the length of the payload. */
			
 
				+    reqlen += zipStorePrevEntryLength(NULL,prevlen);
			
 
				+    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
			
 
				+
			
 
				+    /* When the insert position is not equal to the tail, we need to
			
 
				+     * make sure that the next entry can hold this entry's length in
			
 
				+     * its prevlen field. */
			
 
				+    int forcelarge = 0;
			
 
				+    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
			
 
				+    if (nextdiff == -4 && reqlen < 4) {
			
 
				+        nextdiff = 0;
			
 
				+        forcelarge = 1;
			
 
				+    }
			
 
				+
			
 
				+    /* Store offset because a realloc may change the address of zl. */
			
 
				+    offset = p-zl;
			
 
				+    newlen = curlen+reqlen+nextdiff;
			
 
				+    zl = ziplistResize(zl,newlen);
			
 
				+    p = zl+offset;
			
 
				+
			
 
				+    /* Apply memory move when necessary and update tail offset. */
			
 
				+    if (p[0] != ZIP_END) {
			
 
				+        /* Subtract one because of the ZIP_END bytes */
			
 
				+        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
			
 
				+
			
 
				+        /* Encode this entry's raw length in the next entry. */
			
 
				+        if (forcelarge)
			
 
				+            zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
			
 
				+        else
			
 
				+            zipStorePrevEntryLength(p+reqlen,reqlen);
			
 
				+
			
 
				+        /* Update offset for tail */
			
 
				+        ZIPLIST_TAIL_OFFSET(zl) =
			
 
				+            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
			
 
				+
			
 
				+        /* When the tail contains more than one entry, we need to take
			
 
				+         * "nextdiff" in account as well. Otherwise, a change in the
			
 
				+         * size of prevlen doesn't have an effect on the *tail* offset. */
			
 
				+        assert(zipEntrySafe(zl, newlen, p+reqlen, &tail, 1));
			
 
				+        if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
			
 
				+            ZIPLIST_TAIL_OFFSET(zl) =
			
 
				+                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* This element will be the new tail. */
			
 
				+        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
			
 
				+    }
			
 
				+
			
 
				+    /* When nextdiff != 0, the raw length of the next entry has changed, so
			
 
				+     * we need to cascade the update throughout the ziplist */
			
 
				+    if (nextdiff != 0) {
			
 
				+        offset = p-zl;
			
 
				+        zl = __ziplistCascadeUpdate(zl,p+reqlen);
			
 
				+        p = zl+offset;
			
 
				+    }
			
 
				+
			
 
				+    /* Write the entry */
			
 
				+    p += zipStorePrevEntryLength(p,prevlen);
			
 
				+    p += zipStoreEntryEncoding(p,encoding,slen);
			
 
				+    if (ZIP_IS_STR(encoding)) {
			
 
				+        memcpy(p,s,slen);
			
 
				+    } else {
			
 
				+        zipSaveInteger(p,value,encoding);
			
 
				+    }
			
 
				+    ZIPLIST_INCR_LENGTH(zl,1);
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Merge ziplists 'first' and 'second' by appending 'second' to 'first'.
			
 
				+ *
			
 
				+ * NOTE: The larger ziplist is reallocated to contain the new merged ziplist.
			
 
				+ * Either 'first' or 'second' can be used for the result.  The parameter not
			
 
				+ * used will be free'd and set to NULL.
			
 
				+ *
			
 
				+ * After calling this function, the input parameters are no longer valid since
			
 
				+ * they are changed and free'd in-place.
			
 
				+ *
			
 
				+ * The result ziplist is the contents of 'first' followed by 'second'.
			
 
				+ *
			
 
				+ * On failure: returns NULL if the merge is impossible.
			
 
				+ * On success: returns the merged ziplist (which is expanded version of either
			
 
				+ * 'first' or 'second', also frees the other unused input ziplist, and sets the
			
 
				+ * input ziplist argument equal to newly reallocated ziplist return value. */
			
 
				+unsigned char *ziplistMerge(unsigned char **first, unsigned char **second) {
			
 
				+    /* If any params are null, we can't merge, so NULL. */
			
 
				+    if (first == NULL || *first == NULL || second == NULL || *second == NULL)
			
 
				+        return NULL;
			
 
				+
			
 
				+    /* Can't merge same list into itself. */
			
 
				+    if (*first == *second)
			
 
				+        return NULL;
			
 
				+
			
 
				+    size_t first_bytes = intrev32ifbe(ZIPLIST_BYTES(*first));
			
 
				+    size_t first_len = intrev16ifbe(ZIPLIST_LENGTH(*first));
			
 
				+
			
 
				+    size_t second_bytes = intrev32ifbe(ZIPLIST_BYTES(*second));
			
 
				+    size_t second_len = intrev16ifbe(ZIPLIST_LENGTH(*second));
			
 
				+
			
 
				+    int append;
			
 
				+    unsigned char *source, *target;
			
 
				+    size_t target_bytes, source_bytes;
			
 
				+    /* Pick the largest ziplist so we can resize easily in-place.
			
 
				+     * We must also track if we are now appending or prepending to
			
 
				+     * the target ziplist. */
			
 
				+    if (first_len >= second_len) {
			
 
				+        /* retain first, append second to first. */
			
 
				+        target = *first;
			
 
				+        target_bytes = first_bytes;
			
 
				+        source = *second;
			
 
				+        source_bytes = second_bytes;
			
 
				+        append = 1;
			
 
				+    } else {
			
 
				+        /* else, retain second, prepend first to second. */
			
 
				+        target = *second;
			
 
				+        target_bytes = second_bytes;
			
 
				+        source = *first;
			
 
				+        source_bytes = first_bytes;
			
 
				+        append = 0;
			
 
				+    }
			
 
				+
			
 
				+    /* Calculate final bytes (subtract one pair of metadata) */
			
 
				+    size_t zlbytes = first_bytes + second_bytes -
			
 
				+                     ZIPLIST_HEADER_SIZE - ZIPLIST_END_SIZE;
			
 
				+    size_t zllength = first_len + second_len;
			
 
				+
			
 
				+    /* Combined zl length should be limited within UINT16_MAX */
			
 
				+    zllength = zllength < UINT16_MAX ? zllength : UINT16_MAX;
			
 
				+
			
 
				+    /* larger values can't be stored into ZIPLIST_BYTES */
			
 
				+    assert(zlbytes < UINT32_MAX);
			
 
				+
			
 
				+    /* Save offset positions before we start ripping memory apart. */
			
 
				+    size_t first_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*first));
			
 
				+    size_t second_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*second));
			
 
				+
			
 
				+    /* Extend target to new zlbytes then append or prepend source. */
			
 
				+    target = zrealloc(target, zlbytes);
			
 
				+    if (append) {
			
 
				+        /* append == appending to target */
			
 
				+        /* Copy source after target (copying over original [END]):
			
 
				+         *   [TARGET - END, SOURCE - HEADER] */
			
 
				+        memcpy(target + target_bytes - ZIPLIST_END_SIZE,
			
 
				+               source + ZIPLIST_HEADER_SIZE,
			
 
				+               source_bytes - ZIPLIST_HEADER_SIZE);
			
 
				+    } else {
			
 
				+        /* !append == prepending to target */
			
 
				+        /* Move target *contents* exactly size of (source - [END]),
			
 
				+         * then copy source into vacated space (source - [END]):
			
 
				+         *   [SOURCE - END, TARGET - HEADER] */
			
 
				+        memmove(target + source_bytes - ZIPLIST_END_SIZE,
			
 
				+                target + ZIPLIST_HEADER_SIZE,
			
 
				+                target_bytes - ZIPLIST_HEADER_SIZE);
			
 
				+        memcpy(target, source, source_bytes - ZIPLIST_END_SIZE);
			
 
				+    }
			
 
				+
			
 
				+    /* Update header metadata. */
			
 
				+    ZIPLIST_BYTES(target) = intrev32ifbe(zlbytes);
			
 
				+    ZIPLIST_LENGTH(target) = intrev16ifbe(zllength);
			
 
				+    /* New tail offset is:
			
 
				+     *   + N bytes of first ziplist
			
 
				+     *   - 1 byte for [END] of first ziplist
			
 
				+     *   + M bytes for the offset of the original tail of the second ziplist
			
 
				+     *   - J bytes for HEADER because second_offset keeps no header. */
			
 
				+    ZIPLIST_TAIL_OFFSET(target) = intrev32ifbe(
			
 
				+                                   (first_bytes - ZIPLIST_END_SIZE) +
			
 
				+                                   (second_offset - ZIPLIST_HEADER_SIZE));
			
 
				+
			
 
				+    /* __ziplistCascadeUpdate just fixes the prev length values until it finds a
			
 
				+     * correct prev length value (then it assumes the rest of the list is okay).
			
 
				+     * We tell CascadeUpdate to start at the first ziplist's tail element to fix
			
 
				+     * the merge seam. */
			
 
				+    target = __ziplistCascadeUpdate(target, target+first_offset);
			
 
				+
			
 
				+    /* Now free and NULL out what we didn't realloc */
			
 
				+    if (append) {
			
 
				+        zfree(*second);
			
 
				+        *second = NULL;
			
 
				+        *first = target;
			
 
				+    } else {
			
 
				+        zfree(*first);
			
 
				+        *first = NULL;
			
 
				+        *second = target;
			
 
				+    }
			
 
				+    return target;
			
 
				+}
			
 
				+
			
 
				+unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
			
 
				+    unsigned char *p;
			
 
				+    p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
			
 
				+    return __ziplistInsert(zl,p,s,slen);
			
 
				+}
			
 
				+
			
 
				+/* Returns an offset to use for iterating with ziplistNext. When the given
			
 
				+ * index is negative, the list is traversed back to front. When the list
			
 
				+ * doesn't contain an element at the provided index, NULL is returned. */
			
 
				+unsigned char *ziplistIndex(unsigned char *zl, int index) {
			
 
				+    unsigned char *p;
			
 
				+    unsigned int prevlensize, prevlen = 0;
			
 
				+    size_t zlbytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+    if (index < 0) {
			
 
				+        index = (-index)-1;
			
 
				+        p = ZIPLIST_ENTRY_TAIL(zl);
			
 
				+        if (p[0] != ZIP_END) {
			
 
				+            /* No need for "safe" check: when going backwards, we know the header
			
 
				+             * we're parsing is in the range, we just need to assert (below) that
			
 
				+             * the size we take doesn't cause p to go outside the allocation. */
			
 
				+            ZIP_DECODE_PREVLENSIZE(p, prevlensize);
			
 
				+            assert(p + prevlensize < zl + zlbytes - ZIPLIST_END_SIZE);
			
 
				+            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
			
 
				+            while (prevlen > 0 && index--) {
			
 
				+                p -= prevlen;
			
 
				+                assert(p >= zl + ZIPLIST_HEADER_SIZE && p < zl + zlbytes - ZIPLIST_END_SIZE);
			
 
				+                ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
			
 
				+            }
			
 
				+        }
			
 
				+    } else {
			
 
				+        p = ZIPLIST_ENTRY_HEAD(zl);
			
 
				+        while (index--) {
			
 
				+            /* Use the "safe" length: When we go forward, we need to be careful
			
 
				+             * not to decode an entry header if it's past the ziplist allocation. */
			
 
				+            p += zipRawEntryLengthSafe(zl, zlbytes, p);
			
 
				+            if (p[0] == ZIP_END)
			
 
				+                break;
			
 
				+        }
			
 
				+    }
			
 
				+    if (p[0] == ZIP_END || index > 0)
			
 
				+        return NULL;
			
 
				+    zipAssertValidEntry(zl, zlbytes, p);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* Return pointer to next entry in ziplist.
			
 
				+ *
			
 
				+ * zl is the pointer to the ziplist
			
 
				+ * p is the pointer to the current element
			
 
				+ *
			
 
				+ * The element after 'p' is returned, otherwise NULL if we are at the end. */
			
 
				+unsigned char *ziplistNext(unsigned char *zl, unsigned char *p) {
			
 
				+    ((void) zl);
			
 
				+    size_t zlbytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+
			
 
				+    /* "p" could be equal to ZIP_END, caused by ziplistDelete,
			
 
				+     * and we should return NULL. Otherwise, we should return NULL
			
 
				+     * when the *next* element is ZIP_END (there is no next entry). */
			
 
				+    if (p[0] == ZIP_END) {
			
 
				+        return NULL;
			
 
				+    }
			
 
				+
			
 
				+    p += zipRawEntryLength(p);
			
 
				+    if (p[0] == ZIP_END) {
			
 
				+        return NULL;
			
 
				+    }
			
 
				+
			
 
				+    zipAssertValidEntry(zl, zlbytes, p);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+/* Return pointer to previous entry in ziplist. */
			
 
				+unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
			
 
				+    unsigned int prevlensize, prevlen = 0;
			
 
				+
			
 
				+    /* Iterating backwards from ZIP_END should return the tail. When "p" is
			
 
				+     * equal to the first element of the list, we're already at the head,
			
 
				+     * and should return NULL. */
			
 
				+    if (p[0] == ZIP_END) {
			
 
				+        p = ZIPLIST_ENTRY_TAIL(zl);
			
 
				+        return (p[0] == ZIP_END) ? NULL : p;
			
 
				+    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
			
 
				+        return NULL;
			
 
				+    } else {
			
 
				+        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
			
 
				+        assert(prevlen > 0);
			
 
				+        p-=prevlen;
			
 
				+        size_t zlbytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+        zipAssertValidEntry(zl, zlbytes, p);
			
 
				+        return p;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Get entry pointed to by 'p' and store in either '*sstr' or 'sval' depending
			
 
				+ * on the encoding of the entry. '*sstr' is always set to NULL to be able
			
 
				+ * to find out whether the string pointer or the integer value was set.
			
 
				+ * Return 0 if 'p' points to the end of the ziplist, 1 otherwise. */
			
 
				+unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
			
 
				+    zlentry entry;
			
 
				+    if (p == NULL || p[0] == ZIP_END) return 0;
			
 
				+    if (sstr) *sstr = NULL;
			
 
				+
			
 
				+    zipEntry(p, &entry); /* no need for "safe" variant since the input pointer was validated by the function that returned it. */
			
 
				+    if (ZIP_IS_STR(entry.encoding)) {
			
 
				+        if (sstr) {
			
 
				+            *slen = entry.len;
			
 
				+            *sstr = p+entry.headersize;
			
 
				+        }
			
 
				+    } else {
			
 
				+        if (sval) {
			
 
				+            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
			
 
				+        }
			
 
				+    }
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Insert an entry at "p". */
			
 
				+unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
			
 
				+    return __ziplistInsert(zl,p,s,slen);
			
 
				+}
			
 
				+
			
 
				+/* Delete a single entry from the ziplist, pointed to by *p.
			
 
				+ * Also update *p in place, to be able to iterate over the
			
 
				+ * ziplist, while deleting entries. */
			
 
				+unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
			
 
				+    size_t offset = *p-zl;
			
 
				+    zl = __ziplistDelete(zl,*p,1);
			
 
				+
			
 
				+    /* Store pointer to current element in p, because ziplistDelete will
			
 
				+     * do a realloc which might result in a different "zl"-pointer.
			
 
				+     * When the delete direction is back to front, we might delete the last
			
 
				+     * entry and end up with "p" pointing to ZIP_END, so check this. */
			
 
				+    *p = zl+offset;
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Delete a range of entries from the ziplist. */
			
 
				+unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num) {
			
 
				+    unsigned char *p = ziplistIndex(zl,index);
			
 
				+    return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
			
 
				+}
			
 
				+
			
 
				+/* Replaces the entry at p. This is equivalent to a delete and an insert,
			
 
				+ * but avoids some overhead when replacing a value of the same size. */
			
 
				+unsigned char *ziplistReplace(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
			
 
				+
			
 
				+    /* get metadata of the current entry */
			
 
				+    zlentry entry;
			
 
				+    zipEntry(p, &entry);
			
 
				+
			
 
				+    /* compute length of entry to store, excluding prevlen */
			
 
				+    unsigned int reqlen;
			
 
				+    unsigned char encoding = 0;
			
 
				+    long long value = 123456789; /* initialized to avoid warning. */
			
 
				+    if (zipTryEncoding(s,slen,&value,&encoding)) {
			
 
				+        reqlen = zipIntSize(encoding); /* encoding is set */
			
 
				+    } else {
			
 
				+        reqlen = slen; /* encoding == 0 */
			
 
				+    }
			
 
				+    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
			
 
				+
			
 
				+    if (reqlen == entry.lensize + entry.len) {
			
 
				+        /* Simply overwrite the element. */
			
 
				+        p += entry.prevrawlensize;
			
 
				+        p += zipStoreEntryEncoding(p,encoding,slen);
			
 
				+        if (ZIP_IS_STR(encoding)) {
			
 
				+            memcpy(p,s,slen);
			
 
				+        } else {
			
 
				+            zipSaveInteger(p,value,encoding);
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* Fallback. */
			
 
				+        zl = ziplistDelete(zl,&p);
			
 
				+        zl = ziplistInsert(zl,p,s,slen);
			
 
				+    }
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+/* Compare entry pointer to by 'p' with 'sstr' of length 'slen'. */
			
 
				+/* Return 1 if equal. */
			
 
				+unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) {
			
 
				+    zlentry entry;
			
 
				+    unsigned char sencoding;
			
 
				+    long long zval, sval;
			
 
				+    if (p[0] == ZIP_END) return 0;
			
 
				+
			
 
				+    zipEntry(p, &entry); /* no need for "safe" variant since the input pointer was validated by the function that returned it. */
			
 
				+    if (ZIP_IS_STR(entry.encoding)) {
			
 
				+        /* Raw compare */
			
 
				+        if (entry.len == slen) {
			
 
				+            return memcmp(p+entry.headersize,sstr,slen) == 0;
			
 
				+        } else {
			
 
				+            return 0;
			
 
				+        }
			
 
				+    } else {
			
 
				+        /* Try to compare encoded values. Don't compare encoding because
			
 
				+         * different implementations may encoded integers differently. */
			
 
				+        if (zipTryEncoding(sstr,slen,&sval,&sencoding)) {
			
 
				+          zval = zipLoadInteger(p+entry.headersize,entry.encoding);
			
 
				+          return zval == sval;
			
 
				+        }
			
 
				+    }
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+/* Find pointer to the entry equal to the specified entry. Skip 'skip' entries
			
 
				+ * between every comparison. Returns NULL when the field could not be found. */
			
 
				+unsigned char *ziplistFind(unsigned char *zl, unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip) {
			
 
				+    int skipcnt = 0;
			
 
				+    unsigned char vencoding = 0;
			
 
				+    long long vll = 0;
			
 
				+    size_t zlbytes = ziplistBlobLen(zl);
			
 
				+
			
 
				+    while (p[0] != ZIP_END) {
			
 
				+        struct zlentry e;
			
 
				+        unsigned char *q;
			
 
				+
			
 
				+        assert(zipEntrySafe(zl, zlbytes, p, &e, 1));
			
 
				+        q = p + e.prevrawlensize + e.lensize;
			
 
				+
			
 
				+        if (skipcnt == 0) {
			
 
				+            /* Compare current entry with specified entry */
			
 
				+            if (ZIP_IS_STR(e.encoding)) {
			
 
				+                if (e.len == vlen && memcmp(q, vstr, vlen) == 0) {
			
 
				+                    return p;
			
 
				+                }
			
 
				+            } else {
			
 
				+                /* Find out if the searched field can be encoded. Note that
			
 
				+                 * we do it only the first time, once done vencoding is set
			
 
				+                 * to non-zero and vll is set to the integer value. */
			
 
				+                if (vencoding == 0) {
			
 
				+                    if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
			
 
				+                        /* If the entry can't be encoded we set it to
			
 
				+                         * UCHAR_MAX so that we don't retry again the next
			
 
				+                         * time. */
			
 
				+                        vencoding = UCHAR_MAX;
			
 
				+                    }
			
 
				+                    /* Must be non-zero by now */
			
 
				+                    assert(vencoding);
			
 
				+                }
			
 
				+
			
 
				+                /* Compare current entry with specified entry, do it only
			
 
				+                 * if vencoding != UCHAR_MAX because if there is no encoding
			
 
				+                 * possible for the field it can't be a valid integer. */
			
 
				+                if (vencoding != UCHAR_MAX) {
			
 
				+                    long long ll = zipLoadInteger(q, e.encoding);
			
 
				+                    if (ll == vll) {
			
 
				+                        return p;
			
 
				+                    }
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            /* Reset skip count */
			
 
				+            skipcnt = skip;
			
 
				+        } else {
			
 
				+            /* Skip entry */
			
 
				+            skipcnt--;
			
 
				+        }
			
 
				+
			
 
				+        /* Move to next entry */
			
 
				+        p = q + e.len;
			
 
				+    }
			
 
				+
			
 
				+    return NULL;
			
 
				+}
			
 
				+
			
 
				+/* Return length of ziplist. */
			
 
				+unsigned int ziplistLen(unsigned char *zl) {
			
 
				+    unsigned int len = 0;
			
 
				+    if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) {
			
 
				+        len = intrev16ifbe(ZIPLIST_LENGTH(zl));
			
 
				+    } else {
			
 
				+        unsigned char *p = zl+ZIPLIST_HEADER_SIZE;
			
 
				+        size_t zlbytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+        while (*p != ZIP_END) {
			
 
				+            p += zipRawEntryLengthSafe(zl, zlbytes, p);
			
 
				+            len++;
			
 
				+        }
			
 
				+
			
 
				+        /* Re-store length if small enough */
			
 
				+        if (len < UINT16_MAX) ZIPLIST_LENGTH(zl) = intrev16ifbe(len);
			
 
				+    }
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+/* Return ziplist blob size in bytes. */
			
 
				+size_t ziplistBlobLen(unsigned char *zl) {
			
 
				+    return intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+}
			
 
				+
			
 
				+void ziplistRepr(unsigned char *zl) {
			
 
				+    unsigned char *p;
			
 
				+    int index = 0;
			
 
				+    zlentry entry;
			
 
				+    size_t zlbytes = ziplistBlobLen(zl);
			
 
				+
			
 
				+    printf(
			
 
				+        "{total bytes %u} "
			
 
				+        "{num entries %u}\n"
			
 
				+        "{tail offset %u}\n",
			
 
				+        intrev32ifbe(ZIPLIST_BYTES(zl)),
			
 
				+        intrev16ifbe(ZIPLIST_LENGTH(zl)),
			
 
				+        intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)));
			
 
				+    p = ZIPLIST_ENTRY_HEAD(zl);
			
 
				+    while(*p != ZIP_END) {
			
 
				+        assert(zipEntrySafe(zl, zlbytes, p, &entry, 1));
			
 
				+        printf(
			
 
				+            "{\n"
			
 
				+                "\taddr 0x%08lx,\n"
			
 
				+                "\tindex %2d,\n"
			
 
				+                "\toffset %5lu,\n"
			
 
				+                "\thdr+entry len: %5u,\n"
			
 
				+                "\thdr len%2u,\n"
			
 
				+                "\tprevrawlen: %5u,\n"
			
 
				+                "\tprevrawlensize: %2u,\n"
			
 
				+                "\tpayload %5u\n",
			
 
				+            (long unsigned)p,
			
 
				+            index,
			
 
				+            (unsigned long) (p-zl),
			
 
				+            entry.headersize+entry.len,
			
 
				+            entry.headersize,
			
 
				+            entry.prevrawlen,
			
 
				+            entry.prevrawlensize,
			
 
				+            entry.len);
			
 
				+        printf("\tbytes: ");
			
 
				+        for (unsigned int i = 0; i < entry.headersize+entry.len; i++) {
			
 
				+            printf("%02x|",p[i]);
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        p += entry.headersize;
			
 
				+        if (ZIP_IS_STR(entry.encoding)) {
			
 
				+            printf("\t[str]");
			
 
				+            if (entry.len > 40) {
			
 
				+                if (fwrite(p,40,1,stdout) == 0) perror("fwrite");
			
 
				+                printf("...");
			
 
				+            } else {
			
 
				+                if (entry.len &&
			
 
				+                    fwrite(p,entry.len,1,stdout) == 0) perror("fwrite");
			
 
				+            }
			
 
				+        } else {
			
 
				+            printf("\t[int]%lld", (long long) zipLoadInteger(p,entry.encoding));
			
 
				+        }
			
 
				+        printf("\n}\n");
			
 
				+        p += entry.len;
			
 
				+        index++;
			
 
				+    }
			
 
				+    printf("{end}\n\n");
			
 
				+}
			
 
				+
			
 
				+/* Validate the integrity of the data structure.
			
 
				+ * when `deep` is 0, only the integrity of the header is validated.
			
 
				+ * when `deep` is 1, we scan all the entries one by one. */
			
 
				+int ziplistValidateIntegrity(unsigned char *zl, size_t size, int deep,
			
 
				+    ziplistValidateEntryCB entry_cb, void *cb_userdata) {
			
 
				+    /* check that we can actually read the header. (and ZIP_END) */
			
 
				+    if (size < ZIPLIST_HEADER_SIZE + ZIPLIST_END_SIZE)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* check that the encoded size in the header must match the allocated size. */
			
 
				+    size_t bytes = intrev32ifbe(ZIPLIST_BYTES(zl));
			
 
				+    if (bytes != size)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* the last byte must be the terminator. */
			
 
				+    if (zl[size - ZIPLIST_END_SIZE] != ZIP_END)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* make sure the tail offset isn't reaching outside the allocation. */
			
 
				+    if (intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)) > size - ZIPLIST_END_SIZE)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (!deep)
			
 
				+        return 1;
			
 
				+
			
 
				+    unsigned int count = 0;
			
 
				+    unsigned int header_count = intrev16ifbe(ZIPLIST_LENGTH(zl));
			
 
				+    unsigned char *p = ZIPLIST_ENTRY_HEAD(zl);
			
 
				+    unsigned char *prev = NULL;
			
 
				+    size_t prev_raw_size = 0;
			
 
				+    while(*p != ZIP_END) {
			
 
				+        struct zlentry e;
			
 
				+        /* Decode the entry headers and fail if invalid or reaches outside the allocation */
			
 
				+        if (!zipEntrySafe(zl, size, p, &e, 1))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* Make sure the record stating the prev entry size is correct. */
			
 
				+        if (e.prevrawlen != prev_raw_size)
			
 
				+            return 0;
			
 
				+
			
 
				+        /* Optionally let the caller validate the entry too. */
			
 
				+        if (entry_cb && !entry_cb(p, header_count, cb_userdata))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* Move to the next entry */
			
 
				+        prev_raw_size = e.headersize + e.len;
			
 
				+        prev = p;
			
 
				+        p += e.headersize + e.len;
			
 
				+        count++;
			
 
				+    }
			
 
				+
			
 
				+    /* Make sure 'p' really does point to the end of the ziplist. */
			
 
				+    if (p != zl + bytes - ZIPLIST_END_SIZE)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Make sure the <zltail> entry really do point to the start of the last entry. */
			
 
				+    if (prev != NULL && prev != ZIPLIST_ENTRY_TAIL(zl))
			
 
				+        return 0;
			
 
				+
			
 
				+    /* Check that the count in the header is correct */
			
 
				+    if (header_count != UINT16_MAX && count != header_count)
			
 
				+        return 0;
			
 
				+
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Randomly select a pair of key and value.
			
 
				+ * total_count is a pre-computed length/2 of the ziplist (to avoid calls to ziplistLen)
			
 
				+ * 'key' and 'val' are used to store the result key value pair.
			
 
				+ * 'val' can be NULL if the value is not needed. */
			
 
				+void ziplistRandomPair(unsigned char *zl, unsigned long total_count, ziplistEntry *key, ziplistEntry *val) {
			
 
				+    int ret;
			
 
				+    unsigned char *p;
			
 
				+
			
 
				+    /* Avoid div by zero on corrupt ziplist */
			
 
				+    assert(total_count);
			
 
				+
			
 
				+    /* Generate even numbers, because ziplist saved K-V pair */
			
 
				+    int r = (rand() % total_count) * 2;
			
 
				+    p = ziplistIndex(zl, r);
			
 
				+    ret = ziplistGet(p, &key->sval, &key->slen, &key->lval);
			
 
				+    assert(ret != 0);
			
 
				+
			
 
				+    if (!val)
			
 
				+        return;
			
 
				+    p = ziplistNext(zl, p);
			
 
				+    ret = ziplistGet(p, &val->sval, &val->slen, &val->lval);
			
 
				+    assert(ret != 0);
			
 
				+}
			
 
				+
			
 
				+/* int compare for qsort */
			
 
				+int uintCompare(const void *a, const void *b) {
			
 
				+    return (*(unsigned int *) a - *(unsigned int *) b);
			
 
				+}
			
 
				+
			
 
				+/* Helper method to store a string into from val or lval into dest */
			
 
				+static inline void ziplistSaveValue(unsigned char *val, unsigned int len, long long lval, ziplistEntry *dest) {
			
 
				+    dest->sval = val;
			
 
				+    dest->slen = len;
			
 
				+    dest->lval = lval;
			
 
				+}
			
 
				+
			
 
				+/* Randomly select count of key value pairs and store into 'keys' and
			
 
				+ * 'vals' args. The order of the picked entries is random, and the selections
			
 
				+ * are non-unique (repetitions are possible).
			
 
				+ * The 'vals' arg can be NULL in which case we skip these. */
			
 
				+void ziplistRandomPairs(unsigned char *zl, unsigned int count, ziplistEntry *keys, ziplistEntry *vals) {
			
 
				+    unsigned char *p, *key, *value;
			
 
				+    unsigned int klen = 0, vlen = 0;
			
 
				+    long long klval = 0, vlval = 0;
			
 
				+
			
 
				+    /* Notice: the index member must be first due to the use in uintCompare */
			
 
				+    typedef struct {
			
 
				+        unsigned int index;
			
 
				+        unsigned int order;
			
 
				+    } rand_pick;
			
 
				+    rand_pick *picks = zmalloc(sizeof(rand_pick)*count);
			
 
				+    unsigned int total_size = ziplistLen(zl)/2;
			
 
				+
			
 
				+    /* Avoid div by zero on corrupt ziplist */
			
 
				+    assert(total_size);
			
 
				+
			
 
				+    /* create a pool of random indexes (some may be duplicate). */
			
 
				+    for (unsigned int i = 0; i < count; i++) {
			
 
				+        picks[i].index = (rand() % total_size) * 2; /* Generate even indexes */
			
 
				+        /* keep track of the order we picked them */
			
 
				+        picks[i].order = i;
			
 
				+    }
			
 
				+
			
 
				+    /* sort by indexes. */
			
 
				+    qsort(picks, count, sizeof(rand_pick), uintCompare);
			
 
				+
			
 
				+    /* fetch the elements form the ziplist into a output array respecting the original order. */
			
 
				+    unsigned int zipindex = picks[0].index, pickindex = 0;
			
 
				+    p = ziplistIndex(zl, zipindex);
			
 
				+    while (ziplistGet(p, &key, &klen, &klval) && pickindex < count) {
			
 
				+        p = ziplistNext(zl, p);
			
 
				+        assert(ziplistGet(p, &value, &vlen, &vlval));
			
 
				+        while (pickindex < count && zipindex == picks[pickindex].index) {
			
 
				+            int storeorder = picks[pickindex].order;
			
 
				+            ziplistSaveValue(key, klen, klval, &keys[storeorder]);
			
 
				+            if (vals)
			
 
				+                ziplistSaveValue(value, vlen, vlval, &vals[storeorder]);
			
 
				+             pickindex++;
			
 
				+        }
			
 
				+        zipindex += 2;
			
 
				+        p = ziplistNext(zl, p);
			
 
				+    }
			
 
				+
			
 
				+    zfree(picks);
			
 
				+}
			
 
				+
			
 
				+/* Randomly select count of key value pairs and store into 'keys' and
			
 
				+ * 'vals' args. The selections are unique (no repetitions), and the order of
			
 
				+ * the picked entries is NOT-random.
			
 
				+ * The 'vals' arg can be NULL in which case we skip these.
			
 
				+ * The return value is the number of items picked which can be lower than the
			
 
				+ * requested count if the ziplist doesn't hold enough pairs. */
			
 
				+unsigned int ziplistRandomPairsUnique(unsigned char *zl, unsigned int count, ziplistEntry *keys, ziplistEntry *vals) {
			
 
				+    unsigned char *p, *key;
			
 
				+    unsigned int klen = 0;
			
 
				+    long long klval = 0;
			
 
				+    unsigned int total_size = ziplistLen(zl)/2;
			
 
				+    unsigned int index = 0;
			
 
				+    if (count > total_size)
			
 
				+        count = total_size;
			
 
				+
			
 
				+    /* To only iterate once, every time we try to pick a member, the probability
			
 
				+     * we pick it is the quotient of the count left we want to pick and the
			
 
				+     * count still we haven't visited in the dict, this way, we could make every
			
 
				+     * member be equally picked.*/
			
 
				+    p = ziplistIndex(zl, 0);
			
 
				+    unsigned int picked = 0, remaining = count;
			
 
				+    while (picked < count && p) {
			
 
				+        double randomDouble = ((double)rand()) / RAND_MAX;
			
 
				+        double threshold = ((double)remaining) / (total_size - index);
			
 
				+        if (randomDouble <= threshold) {
			
 
				+            assert(ziplistGet(p, &key, &klen, &klval));
			
 
				+            ziplistSaveValue(key, klen, klval, &keys[picked]);
			
 
				+            p = ziplistNext(zl, p);
			
 
				+            assert(p);
			
 
				+            if (vals) {
			
 
				+                assert(ziplistGet(p, &key, &klen, &klval));
			
 
				+                ziplistSaveValue(key, klen, klval, &vals[picked]);
			
 
				+            }
			
 
				+            remaining--;
			
 
				+            picked++;
			
 
				+        } else {
			
 
				+            p = ziplistNext(zl, p);
			
 
				+            assert(p);
			
 
				+        }
			
 
				+        p = ziplistNext(zl, p);
			
 
				+        index++;
			
 
				+    }
			
 
				+    return picked;
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#include <sys/time.h>
			
 
				+#include "adlist.h"
			
 
				+#include "sds.h"
			
 
				+#include "testhelp.h"
			
 
				+
			
 
				+#define debug(f, ...) { if (DEBUG) printf(f, __VA_ARGS__); }
			
 
				+
			
 
				+static unsigned char *createList() {
			
 
				+    unsigned char *zl = ziplistNew();
			
 
				+    zl = ziplistPush(zl, (unsigned char*)"foo", 3, ZIPLIST_TAIL);
			
 
				+    zl = ziplistPush(zl, (unsigned char*)"quux", 4, ZIPLIST_TAIL);
			
 
				+    zl = ziplistPush(zl, (unsigned char*)"hello", 5, ZIPLIST_HEAD);
			
 
				+    zl = ziplistPush(zl, (unsigned char*)"1024", 4, ZIPLIST_TAIL);
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+static unsigned char *createIntList() {
			
 
				+    unsigned char *zl = ziplistNew();
			
 
				+    char buf[32];
			
 
				+
			
 
				+    sprintf(buf, "100");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);
			
 
				+    sprintf(buf, "128000");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);
			
 
				+    sprintf(buf, "-100");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_HEAD);
			
 
				+    sprintf(buf, "4294967296");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_HEAD);
			
 
				+    sprintf(buf, "non integer");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);
			
 
				+    sprintf(buf, "much much longer non integer");
			
 
				+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);
			
 
				+    return zl;
			
 
				+}
			
 
				+
			
 
				+static long long usec(void) {
			
 
				+    struct timeval tv;
			
 
				+    gettimeofday(&tv,NULL);
			
 
				+    return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;
			
 
				+}
			
 
				+
			
 
				+static void stress(int pos, int num, int maxsize, int dnum) {
			
 
				+    int i,j,k;
			
 
				+    unsigned char *zl;
			
 
				+    char posstr[2][5] = { "HEAD", "TAIL" };
			
 
				+    long long start;
			
 
				+    for (i = 0; i < maxsize; i+=dnum) {
			
 
				+        zl = ziplistNew();
			
 
				+        for (j = 0; j < i; j++) {
			
 
				+            zl = ziplistPush(zl,(unsigned char*)"quux",4,ZIPLIST_TAIL);
			
 
				+        }
			
 
				+
			
 
				+        /* Do num times a push+pop from pos */
			
 
				+        start = usec();
			
 
				+        for (k = 0; k < num; k++) {
			
 
				+            zl = ziplistPush(zl,(unsigned char*)"quux",4,pos);
			
 
				+            zl = ziplistDeleteRange(zl,0,1);
			
 
				+        }
			
 
				+        printf("List size: %8d, bytes: %8d, %dx push+pop (%s): %6lld usec\n",
			
 
				+            i,intrev32ifbe(ZIPLIST_BYTES(zl)),num,posstr[pos],usec()-start);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+static unsigned char *pop(unsigned char *zl, int where) {
			
 
				+    unsigned char *p, *vstr;
			
 
				+    unsigned int vlen;
			
 
				+    long long vlong;
			
 
				+
			
 
				+    p = ziplistIndex(zl,where == ZIPLIST_HEAD ? 0 : -1);
			
 
				+    if (ziplistGet(p,&vstr,&vlen,&vlong)) {
			
 
				+        if (where == ZIPLIST_HEAD)
			
 
				+            printf("Pop head: ");
			
 
				+        else
			
 
				+            printf("Pop tail: ");
			
 
				+
			
 
				+        if (vstr) {
			
 
				+            if (vlen && fwrite(vstr,vlen,1,stdout) == 0) perror("fwrite");
			
 
				+        }
			
 
				+        else {
			
 
				+            printf("%lld", vlong);
			
 
				+        }
			
 
				+
			
 
				+        printf("\n");
			
 
				+        return ziplistDelete(zl,&p);
			
 
				+    } else {
			
 
				+        printf("ERROR: Could not pop\n");
			
 
				+        exit(1);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+static int randstring(char *target, unsigned int min, unsigned int max) {
			
 
				+    int p = 0;
			
 
				+    int len = min+rand()%(max-min+1);
			
 
				+    int minval, maxval;
			
 
				+    switch(rand() % 3) {
			
 
				+    case 0:
			
 
				+        minval = 0;
			
 
				+        maxval = 255;
			
 
				+    break;
			
 
				+    case 1:
			
 
				+        minval = 48;
			
 
				+        maxval = 122;
			
 
				+    break;
			
 
				+    case 2:
			
 
				+        minval = 48;
			
 
				+        maxval = 52;
			
 
				+    break;
			
 
				+    default:
			
 
				+        assert(NULL);
			
 
				+    }
			
 
				+
			
 
				+    while(p < len)
			
 
				+        target[p++] = minval+rand()%(maxval-minval+1);
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+static void verify(unsigned char *zl, zlentry *e) {
			
 
				+    int len = ziplistLen(zl);
			
 
				+    zlentry _e;
			
 
				+
			
 
				+    ZIPLIST_ENTRY_ZERO(&_e);
			
 
				+
			
 
				+    for (int i = 0; i < len; i++) {
			
 
				+        memset(&e[i], 0, sizeof(zlentry));
			
 
				+        zipEntry(ziplistIndex(zl, i), &e[i]);
			
 
				+
			
 
				+        memset(&_e, 0, sizeof(zlentry));
			
 
				+        zipEntry(ziplistIndex(zl, -len+i), &_e);
			
 
				+
			
 
				+        assert(memcmp(&e[i], &_e, sizeof(zlentry)) == 0);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+static unsigned char *insertHelper(unsigned char *zl, char ch, size_t len, unsigned char *pos) {
			
 
				+    assert(len <= ZIP_BIG_PREVLEN);
			
 
				+    unsigned char data[ZIP_BIG_PREVLEN] = {0};
			
 
				+    memset(data, ch, len);
			
 
				+    return ziplistInsert(zl, pos, data, len);
			
 
				+}
			
 
				+
			
 
				+static int compareHelper(unsigned char *zl, char ch, size_t len, int index) {
			
 
				+    assert(len <= ZIP_BIG_PREVLEN);
			
 
				+    unsigned char data[ZIP_BIG_PREVLEN] = {0};
			
 
				+    memset(data, ch, len);
			
 
				+    unsigned char *p = ziplistIndex(zl, index);
			
 
				+    assert(p != NULL);
			
 
				+    return ziplistCompare(p, data, len);
			
 
				+}
			
 
				+
			
 
				+static size_t strEntryBytesSmall(size_t slen) {
			
 
				+    return slen + zipStorePrevEntryLength(NULL, 0) + zipStoreEntryEncoding(NULL, 0, slen);
			
 
				+}
			
 
				+
			
 
				+static size_t strEntryBytesLarge(size_t slen) {
			
 
				+    return slen + zipStorePrevEntryLength(NULL, ZIP_BIG_PREVLEN) + zipStoreEntryEncoding(NULL, 0, slen);
			
 
				+}
			
 
				+
			
 
				+/* ./redis-server test ziplist <randomseed> */
			
 
				+int ziplistTest(int argc, char **argv, int flags) {
			
 
				+    int accurate = (flags & REDIS_TEST_ACCURATE);
			
 
				+    unsigned char *zl, *p;
			
 
				+    unsigned char *entry;
			
 
				+    unsigned int elen;
			
 
				+    long long value;
			
 
				+    int iteration;
			
 
				+
			
 
				+    /* If an argument is given, use it as the random seed. */
			
 
				+    if (argc >= 4)
			
 
				+        srand(atoi(argv[3]));
			
 
				+
			
 
				+    zl = createIntList();
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zfree(zl);
			
 
				+
			
 
				+    zl = createList();
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zl = pop(zl,ZIPLIST_TAIL);
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zl = pop(zl,ZIPLIST_HEAD);
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zl = pop(zl,ZIPLIST_TAIL);
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zl = pop(zl,ZIPLIST_TAIL);
			
 
				+    ziplistRepr(zl);
			
 
				+
			
 
				+    zfree(zl);
			
 
				+
			
 
				+    printf("Get element at index 3:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 3);
			
 
				+        if (!ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("ERROR: Could not access index 3\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (entry) {
			
 
				+            if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            printf("\n");
			
 
				+        } else {
			
 
				+            printf("%lld\n", value);
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Get element at index 4 (out of range):\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 4);
			
 
				+        if (p == NULL) {
			
 
				+            printf("No entry\n");
			
 
				+        } else {
			
 
				+            printf("ERROR: Out of range index should return NULL, returned offset: %ld\n", (long)(p-zl));
			
 
				+            return 1;
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Get element at index -1 (last element):\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, -1);
			
 
				+        if (!ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("ERROR: Could not access index -1\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (entry) {
			
 
				+            if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            printf("\n");
			
 
				+        } else {
			
 
				+            printf("%lld\n", value);
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Get element at index -4 (first element):\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, -4);
			
 
				+        if (!ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("ERROR: Could not access index -4\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (entry) {
			
 
				+            if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            printf("\n");
			
 
				+        } else {
			
 
				+            printf("%lld\n", value);
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Get element at index -5 (reverse out of range):\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, -5);
			
 
				+        if (p == NULL) {
			
 
				+            printf("No entry\n");
			
 
				+        } else {
			
 
				+            printf("ERROR: Out of range index should return NULL, returned offset: %ld\n", (long)(p-zl));
			
 
				+            return 1;
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate list from 0 to end:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 0);
			
 
				+        while (ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("Entry: ");
			
 
				+            if (entry) {
			
 
				+                if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            } else {
			
 
				+                printf("%lld", value);
			
 
				+            }
			
 
				+            p = ziplistNext(zl,p);
			
 
				+            printf("\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate list from 1 to end:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 1);
			
 
				+        while (ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("Entry: ");
			
 
				+            if (entry) {
			
 
				+                if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            } else {
			
 
				+                printf("%lld", value);
			
 
				+            }
			
 
				+            p = ziplistNext(zl,p);
			
 
				+            printf("\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate list from 2 to end:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 2);
			
 
				+        while (ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("Entry: ");
			
 
				+            if (entry) {
			
 
				+                if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            } else {
			
 
				+                printf("%lld", value);
			
 
				+            }
			
 
				+            p = ziplistNext(zl,p);
			
 
				+            printf("\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate starting out of range:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, 4);
			
 
				+        if (!ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("No entry\n");
			
 
				+        } else {
			
 
				+            printf("ERROR\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate from back to front:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, -1);
			
 
				+        while (ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("Entry: ");
			
 
				+            if (entry) {
			
 
				+                if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            } else {
			
 
				+                printf("%lld", value);
			
 
				+            }
			
 
				+            p = ziplistPrev(zl,p);
			
 
				+            printf("\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Iterate from back to front, deleting all items:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl, -1);
			
 
				+        while (ziplistGet(p, &entry, &elen, &value)) {
			
 
				+            printf("Entry: ");
			
 
				+            if (entry) {
			
 
				+                if (elen && fwrite(entry,elen,1,stdout) == 0) perror("fwrite");
			
 
				+            } else {
			
 
				+                printf("%lld", value);
			
 
				+            }
			
 
				+            zl = ziplistDelete(zl,&p);
			
 
				+            p = ziplistPrev(zl,p);
			
 
				+            printf("\n");
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete inclusive range 0,0:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        zl = ziplistDeleteRange(zl, 0, 1);
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete inclusive range 0,1:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        zl = ziplistDeleteRange(zl, 0, 2);
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete inclusive range 1,2:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        zl = ziplistDeleteRange(zl, 1, 2);
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete with start index out of range:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        zl = ziplistDeleteRange(zl, 5, 1);
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete with num overflow:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        zl = ziplistDeleteRange(zl, 1, 5);
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Delete foo while iterating:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl,0);
			
 
				+        while (ziplistGet(p,&entry,&elen,&value)) {
			
 
				+            if (entry && strncmp("foo",(char*)entry,elen) == 0) {
			
 
				+                printf("Delete foo\n");
			
 
				+                zl = ziplistDelete(zl,&p);
			
 
				+            } else {
			
 
				+                printf("Entry: ");
			
 
				+                if (entry) {
			
 
				+                    if (elen && fwrite(entry,elen,1,stdout) == 0)
			
 
				+                        perror("fwrite");
			
 
				+                } else {
			
 
				+                    printf("%lld",value);
			
 
				+                }
			
 
				+                p = ziplistNext(zl,p);
			
 
				+                printf("\n");
			
 
				+            }
			
 
				+        }
			
 
				+        printf("\n");
			
 
				+        ziplistRepr(zl);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Replace with same size:\n");
			
 
				+    {
			
 
				+        zl = createList(); /* "hello", "foo", "quux", "1024" */
			
 
				+        unsigned char *orig_zl = zl;
			
 
				+        p = ziplistIndex(zl, 0);
			
 
				+        zl = ziplistReplace(zl, p, (unsigned char*)"zoink", 5);
			
 
				+        p = ziplistIndex(zl, 3);
			
 
				+        zl = ziplistReplace(zl, p, (unsigned char*)"yy", 2);
			
 
				+        p = ziplistIndex(zl, 1);
			
 
				+        zl = ziplistReplace(zl, p, (unsigned char*)"65536", 5);
			
 
				+        p = ziplistIndex(zl, 0);
			
 
				+        assert(!memcmp((char*)p,
			
 
				+                       "\x00\x05zoink"
			
 
				+                       "\x07\xf0\x00\x00\x01" /* 65536 as int24 */
			
 
				+                       "\x05\x04quux" "\x06\x02yy" "\xff",
			
 
				+                       23));
			
 
				+        assert(zl == orig_zl); /* no reallocations have happened */
			
 
				+        zfree(zl);
			
 
				+        printf("SUCCESS\n\n");
			
 
				+    }
			
 
				+
			
 
				+    printf("Replace with different size:\n");
			
 
				+    {
			
 
				+        zl = createList(); /* "hello", "foo", "quux", "1024" */
			
 
				+        p = ziplistIndex(zl, 1);
			
 
				+        zl = ziplistReplace(zl, p, (unsigned char*)"squirrel", 8);
			
 
				+        p = ziplistIndex(zl, 0);
			
 
				+        assert(!strncmp((char*)p,
			
 
				+                        "\x00\x05hello" "\x07\x08squirrel" "\x0a\x04quux"
			
 
				+                        "\x06\xc0\x00\x04" "\xff",
			
 
				+                        28));
			
 
				+        zfree(zl);
			
 
				+        printf("SUCCESS\n\n");
			
 
				+    }
			
 
				+
			
 
				+    printf("Regression test for >255 byte strings:\n");
			
 
				+    {
			
 
				+        char v1[257] = {0}, v2[257] = {0};
			
 
				+        memset(v1,'x',256);
			
 
				+        memset(v2,'y',256);
			
 
				+        zl = ziplistNew();
			
 
				+        zl = ziplistPush(zl,(unsigned char*)v1,strlen(v1),ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl,(unsigned char*)v2,strlen(v2),ZIPLIST_TAIL);
			
 
				+
			
 
				+        /* Pop values again and compare their value. */
			
 
				+        p = ziplistIndex(zl,0);
			
 
				+        assert(ziplistGet(p,&entry,&elen,&value));
			
 
				+        assert(strncmp(v1,(char*)entry,elen) == 0);
			
 
				+        p = ziplistIndex(zl,1);
			
 
				+        assert(ziplistGet(p,&entry,&elen,&value));
			
 
				+        assert(strncmp(v2,(char*)entry,elen) == 0);
			
 
				+        printf("SUCCESS\n\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Regression test deleting next to last entries:\n");
			
 
				+    {
			
 
				+        char v[3][257] = {{0}};
			
 
				+        zlentry e[3] = {{.prevrawlensize = 0, .prevrawlen = 0, .lensize = 0,
			
 
				+                         .len = 0, .headersize = 0, .encoding = 0, .p = NULL}};
			
 
				+        size_t i;
			
 
				+
			
 
				+        for (i = 0; i < (sizeof(v)/sizeof(v[0])); i++) {
			
 
				+            memset(v[i], 'a' + i, sizeof(v[0]));
			
 
				+        }
			
 
				+
			
 
				+        v[0][256] = '\0';
			
 
				+        v[1][  1] = '\0';
			
 
				+        v[2][256] = '\0';
			
 
				+
			
 
				+        zl = ziplistNew();
			
 
				+        for (i = 0; i < (sizeof(v)/sizeof(v[0])); i++) {
			
 
				+            zl = ziplistPush(zl, (unsigned char *) v[i], strlen(v[i]), ZIPLIST_TAIL);
			
 
				+        }
			
 
				+
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1);
			
 
				+        assert(e[1].prevrawlensize == 5);
			
 
				+        assert(e[2].prevrawlensize == 1);
			
 
				+
			
 
				+        /* Deleting entry 1 will increase `prevrawlensize` for entry 2 */
			
 
				+        unsigned char *p = e[1].p;
			
 
				+        zl = ziplistDelete(zl, &p);
			
 
				+
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1);
			
 
				+        assert(e[1].prevrawlensize == 5);
			
 
				+
			
 
				+        printf("SUCCESS\n\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Create long list and check indices:\n");
			
 
				+    {
			
 
				+        unsigned long long start = usec();
			
 
				+        zl = ziplistNew();
			
 
				+        char buf[32];
			
 
				+        int i,len;
			
 
				+        for (i = 0; i < 1000; i++) {
			
 
				+            len = sprintf(buf,"%d",i);
			
 
				+            zl = ziplistPush(zl,(unsigned char*)buf,len,ZIPLIST_TAIL);
			
 
				+        }
			
 
				+        for (i = 0; i < 1000; i++) {
			
 
				+            p = ziplistIndex(zl,i);
			
 
				+            assert(ziplistGet(p,NULL,NULL,&value));
			
 
				+            assert(i == value);
			
 
				+
			
 
				+            p = ziplistIndex(zl,-i-1);
			
 
				+            assert(ziplistGet(p,NULL,NULL,&value));
			
 
				+            assert(999-i == value);
			
 
				+        }
			
 
				+        printf("SUCCESS. usec=%lld\n\n", usec()-start);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Compare strings with ziplist entries:\n");
			
 
				+    {
			
 
				+        zl = createList();
			
 
				+        p = ziplistIndex(zl,0);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {
			
 
				+            printf("ERROR: not \"hello\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"hella",5)) {
			
 
				+            printf("ERROR: \"hella\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        p = ziplistIndex(zl,3);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {
			
 
				+            printf("ERROR: not \"1024\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"1025",4)) {
			
 
				+            printf("ERROR: \"1025\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        printf("SUCCESS\n\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Merge test:\n");
			
 
				+    {
			
 
				+        /* create list gives us: [hello, foo, quux, 1024] */
			
 
				+        zl = createList();
			
 
				+        unsigned char *zl2 = createList();
			
 
				+
			
 
				+        unsigned char *zl3 = ziplistNew();
			
 
				+        unsigned char *zl4 = ziplistNew();
			
 
				+
			
 
				+        if (ziplistMerge(&zl4, &zl4)) {
			
 
				+            printf("ERROR: Allowed merging of one ziplist into itself.\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        /* Merge two empty ziplists, get empty result back. */
			
 
				+        zl4 = ziplistMerge(&zl3, &zl4);
			
 
				+        ziplistRepr(zl4);
			
 
				+        if (ziplistLen(zl4)) {
			
 
				+            printf("ERROR: Merging two empty ziplists created entries.\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        zfree(zl4);
			
 
				+
			
 
				+        zl2 = ziplistMerge(&zl, &zl2);
			
 
				+        /* merge gives us: [hello, foo, quux, 1024, hello, foo, quux, 1024] */
			
 
				+        ziplistRepr(zl2);
			
 
				+
			
 
				+        if (ziplistLen(zl2) != 8) {
			
 
				+            printf("ERROR: Merged length not 8, but: %u\n", ziplistLen(zl2));
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        p = ziplistIndex(zl2,0);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {
			
 
				+            printf("ERROR: not \"hello\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"hella",5)) {
			
 
				+            printf("ERROR: \"hella\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        p = ziplistIndex(zl2,3);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {
			
 
				+            printf("ERROR: not \"1024\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"1025",4)) {
			
 
				+            printf("ERROR: \"1025\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        p = ziplistIndex(zl2,4);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {
			
 
				+            printf("ERROR: not \"hello\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"hella",5)) {
			
 
				+            printf("ERROR: \"hella\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        p = ziplistIndex(zl2,7);
			
 
				+        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {
			
 
				+            printf("ERROR: not \"1024\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        if (ziplistCompare(p,(unsigned char*)"1025",4)) {
			
 
				+            printf("ERROR: \"1025\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+        printf("SUCCESS\n\n");
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Stress with random payloads of different encoding:\n");
			
 
				+    {
			
 
				+        unsigned long long start = usec();
			
 
				+        int i,j,len,where;
			
 
				+        unsigned char *p;
			
 
				+        char buf[1024];
			
 
				+        int buflen;
			
 
				+        list *ref;
			
 
				+        listNode *refnode;
			
 
				+
			
 
				+        /* Hold temp vars from ziplist */
			
 
				+        unsigned char *sstr;
			
 
				+        unsigned int slen;
			
 
				+        long long sval;
			
 
				+
			
 
				+        iteration = accurate ? 20000 : 20;
			
 
				+        for (i = 0; i < iteration; i++) {
			
 
				+            zl = ziplistNew();
			
 
				+            ref = listCreate();
			
 
				+            listSetFreeMethod(ref,(void (*)(void*))sdsfree);
			
 
				+            len = rand() % 256;
			
 
				+
			
 
				+            /* Create lists */
			
 
				+            for (j = 0; j < len; j++) {
			
 
				+                where = (rand() & 1) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
			
 
				+                if (rand() % 2) {
			
 
				+                    buflen = randstring(buf,1,sizeof(buf)-1);
			
 
				+                } else {
			
 
				+                    switch(rand() % 3) {
			
 
				+                    case 0:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()) >> 20);
			
 
				+                        break;
			
 
				+                    case 1:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()));
			
 
				+                        break;
			
 
				+                    case 2:
			
 
				+                        buflen = sprintf(buf,"%lld",(0LL + rand()) << 20);
			
 
				+                        break;
			
 
				+                    default:
			
 
				+                        assert(NULL);
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                /* Add to ziplist */
			
 
				+                zl = ziplistPush(zl, (unsigned char*)buf, buflen, where);
			
 
				+
			
 
				+                /* Add to reference list */
			
 
				+                if (where == ZIPLIST_HEAD) {
			
 
				+                    listAddNodeHead(ref,sdsnewlen(buf, buflen));
			
 
				+                } else if (where == ZIPLIST_TAIL) {
			
 
				+                    listAddNodeTail(ref,sdsnewlen(buf, buflen));
			
 
				+                } else {
			
 
				+                    assert(NULL);
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            assert(listLength(ref) == ziplistLen(zl));
			
 
				+            for (j = 0; j < len; j++) {
			
 
				+                /* Naive way to get elements, but similar to the stresser
			
 
				+                 * executed from the Tcl test suite. */
			
 
				+                p = ziplistIndex(zl,j);
			
 
				+                refnode = listIndex(ref,j);
			
 
				+
			
 
				+                assert(ziplistGet(p,&sstr,&slen,&sval));
			
 
				+                if (sstr == NULL) {
			
 
				+                    buflen = sprintf(buf,"%lld",sval);
			
 
				+                } else {
			
 
				+                    buflen = slen;
			
 
				+                    memcpy(buf,sstr,buflen);
			
 
				+                    buf[buflen] = '\0';
			
 
				+                }
			
 
				+                assert(memcmp(buf,listNodeValue(refnode),buflen) == 0);
			
 
				+            }
			
 
				+            zfree(zl);
			
 
				+            listRelease(ref);
			
 
				+        }
			
 
				+        printf("Done. usec=%lld\n\n", usec()-start);
			
 
				+    }
			
 
				+
			
 
				+    printf("Stress with variable ziplist size:\n");
			
 
				+    {
			
 
				+        unsigned long long start = usec();
			
 
				+        int maxsize = accurate ? 16384 : 16;
			
 
				+        stress(ZIPLIST_HEAD,100000,maxsize,256);
			
 
				+        stress(ZIPLIST_TAIL,100000,maxsize,256);
			
 
				+        printf("Done. usec=%lld\n\n", usec()-start);
			
 
				+    }
			
 
				+
			
 
				+    /* Benchmarks */
			
 
				+    {
			
 
				+        zl = ziplistNew();
			
 
				+        iteration = accurate ? 100000 : 100;
			
 
				+        for (int i=0; i<iteration; i++) {
			
 
				+            char buf[4096] = "asdf";
			
 
				+            zl = ziplistPush(zl, (unsigned char*)buf, 4, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)buf, 40, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)buf, 400, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)buf, 4000, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"1", 1, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"10", 2, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"100", 3, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"1000", 4, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"10000", 5, ZIPLIST_TAIL);
			
 
				+            zl = ziplistPush(zl, (unsigned char*)"100000", 6, ZIPLIST_TAIL);
			
 
				+        }
			
 
				+
			
 
				+        printf("Benchmark ziplistFind:\n");
			
 
				+        {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *fptr = ziplistIndex(zl, ZIPLIST_HEAD);
			
 
				+                fptr = ziplistFind(zl, fptr, (unsigned char*)"nothing", 7, 1);
			
 
				+            }
			
 
				+            printf("%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        printf("Benchmark ziplistIndex:\n");
			
 
				+        {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                ziplistIndex(zl, 99999);
			
 
				+            }
			
 
				+            printf("%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        printf("Benchmark ziplistValidateIntegrity:\n");
			
 
				+        {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                ziplistValidateIntegrity(zl, ziplistBlobLen(zl), 1, NULL, NULL);
			
 
				+            }
			
 
				+            printf("%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        printf("Benchmark ziplistCompare with string\n");
			
 
				+        {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *eptr = ziplistIndex(zl,0);
			
 
				+                while (eptr != NULL) {
			
 
				+                    ziplistCompare(eptr,(unsigned char*)"nothing",7);
			
 
				+                    eptr = ziplistNext(zl,eptr);
			
 
				+                }
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        printf("Benchmark ziplistCompare with number\n");
			
 
				+        {
			
 
				+            unsigned long long start = usec();
			
 
				+            for (int i = 0; i < 2000; i++) {
			
 
				+                unsigned char *eptr = ziplistIndex(zl,0);
			
 
				+                while (eptr != NULL) {
			
 
				+                    ziplistCompare(eptr,(unsigned char*)"99999",5);
			
 
				+                    eptr = ziplistNext(zl,eptr);
			
 
				+                }
			
 
				+            }
			
 
				+            printf("Done. usec=%lld\n", usec()-start);
			
 
				+        }
			
 
				+
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Stress __ziplistCascadeUpdate:\n");
			
 
				+    {
			
 
				+        char data[ZIP_BIG_PREVLEN];
			
 
				+        zl = ziplistNew();
			
 
				+        iteration = accurate ? 100000 : 100;
			
 
				+        for (int i = 0; i < iteration; i++) {
			
 
				+            zl = ziplistPush(zl, (unsigned char*)data, ZIP_BIG_PREVLEN-4, ZIPLIST_TAIL);
			
 
				+        }
			
 
				+        unsigned long long start = usec();
			
 
				+        zl = ziplistPush(zl, (unsigned char*)data, ZIP_BIG_PREVLEN-3, ZIPLIST_HEAD);
			
 
				+        printf("Done. usec=%lld\n\n", usec()-start);
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("Edge cases of __ziplistCascadeUpdate:\n");
			
 
				+    {
			
 
				+        /* Inserting a entry with data length greater than ZIP_BIG_PREVLEN-4 
			
 
				+         * will leads to cascade update. */
			
 
				+        size_t s1 = ZIP_BIG_PREVLEN-4, s2 = ZIP_BIG_PREVLEN-3;
			
 
				+        zl = ziplistNew();
			
 
				+
			
 
				+        zlentry e[4] = {{.prevrawlensize = 0, .prevrawlen = 0, .lensize = 0,
			
 
				+                         .len = 0, .headersize = 0, .encoding = 0, .p = NULL}};
			
 
				+
			
 
				+        zl = insertHelper(zl, 'a', s1, ZIPLIST_ENTRY_HEAD(zl));
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1 && e[0].prevrawlen == 0);
			
 
				+        assert(compareHelper(zl, 'a', s1, 0));
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        /* No expand. */
			
 
				+        zl = insertHelper(zl, 'b', s1, ZIPLIST_ENTRY_HEAD(zl));
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1 && e[0].prevrawlen == 0);
			
 
				+        assert(compareHelper(zl, 'b', s1, 0));
			
 
				+
			
 
				+        assert(e[1].prevrawlensize == 1 && e[1].prevrawlen == strEntryBytesSmall(s1));
			
 
				+        assert(compareHelper(zl, 'a', s1, 1));
			
 
				+
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        /* Expand(tail included). */
			
 
				+        zl = insertHelper(zl, 'c', s2, ZIPLIST_ENTRY_HEAD(zl));
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1 && e[0].prevrawlen == 0);
			
 
				+        assert(compareHelper(zl, 'c', s2, 0));
			
 
				+
			
 
				+        assert(e[1].prevrawlensize == 5 && e[1].prevrawlen == strEntryBytesSmall(s2));
			
 
				+        assert(compareHelper(zl, 'b', s1, 1));
			
 
				+
			
 
				+        assert(e[2].prevrawlensize == 5 && e[2].prevrawlen == strEntryBytesLarge(s1));
			
 
				+        assert(compareHelper(zl, 'a', s1, 2));
			
 
				+
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        /* Expand(only previous head entry). */
			
 
				+        zl = insertHelper(zl, 'd', s2, ZIPLIST_ENTRY_HEAD(zl));
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1 && e[0].prevrawlen == 0);
			
 
				+        assert(compareHelper(zl, 'd', s2, 0));
			
 
				+
			
 
				+        assert(e[1].prevrawlensize == 5 && e[1].prevrawlen == strEntryBytesSmall(s2));
			
 
				+        assert(compareHelper(zl, 'c', s2, 1));
			
 
				+
			
 
				+        assert(e[2].prevrawlensize == 5 && e[2].prevrawlen == strEntryBytesLarge(s2));
			
 
				+        assert(compareHelper(zl, 'b', s1, 2));
			
 
				+
			
 
				+        assert(e[3].prevrawlensize == 5 && e[3].prevrawlen == strEntryBytesLarge(s1));
			
 
				+        assert(compareHelper(zl, 'a', s1, 3));
			
 
				+
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        /* Delete from mid. */
			
 
				+        unsigned char *p = ziplistIndex(zl, 2);
			
 
				+        zl = ziplistDelete(zl, &p);
			
 
				+        verify(zl, e);
			
 
				+
			
 
				+        assert(e[0].prevrawlensize == 1 && e[0].prevrawlen == 0);
			
 
				+        assert(compareHelper(zl, 'd', s2, 0));
			
 
				+
			
 
				+        assert(e[1].prevrawlensize == 5 && e[1].prevrawlen == strEntryBytesSmall(s2));
			
 
				+        assert(compareHelper(zl, 'c', s2, 1));
			
 
				+
			
 
				+        assert(e[2].prevrawlensize == 5 && e[2].prevrawlen == strEntryBytesLarge(s2));
			
 
				+        assert(compareHelper(zl, 'a', s1, 2));
			
 
				+
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("__ziplistInsert nextdiff == -4 && reqlen < 4 (issue #7170):\n");
			
 
				+    {
			
 
				+        zl = ziplistNew();
			
 
				+
			
 
				+        /* We set some values to almost reach the critical point - 254 */
			
 
				+        char A_252[253] = {0}, A_250[251] = {0};
			
 
				+        memset(A_252, 'A', 252);
			
 
				+        memset(A_250, 'A', 250);
			
 
				+
			
 
				+        /* After the rpush, the list look like: [one two A_252 A_250 three 10] */
			
 
				+        zl = ziplistPush(zl, (unsigned char*)"one", 3, ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl, (unsigned char*)"two", 3, ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl, (unsigned char*)A_252, strlen(A_252), ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl, (unsigned char*)A_250, strlen(A_250), ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl, (unsigned char*)"three", 5, ZIPLIST_TAIL);
			
 
				+        zl = ziplistPush(zl, (unsigned char*)"10", 2, ZIPLIST_TAIL);
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        p = ziplistIndex(zl, 2);
			
 
				+        if (!ziplistCompare(p, (unsigned char*)A_252, strlen(A_252))) {
			
 
				+            printf("ERROR: not \"A_252\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        /* When we remove A_252, the list became: [one two A_250 three 10]
			
 
				+         * A_250's prev node became node two, because node two quite small
			
 
				+         * So A_250's prevlenSize shrink to 1, A_250's total size became 253(1+2+250)
			
 
				+         * The prev node of node three is still node A_250.
			
 
				+         * We will not shrink the node three's prevlenSize, keep it at 5 bytes */
			
 
				+        zl = ziplistDelete(zl, &p);
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        p = ziplistIndex(zl, 3);
			
 
				+        if (!ziplistCompare(p, (unsigned char*)"three", 5)) {
			
 
				+            printf("ERROR: not \"three\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        /* We want to insert a node after A_250, the list became: [one two A_250 10 three 10]
			
 
				+         * Because the new node is quite small, node three prevlenSize will shrink to 1 */
			
 
				+        zl = ziplistInsert(zl, p, (unsigned char*)"10", 2);
			
 
				+        ziplistRepr(zl);
			
 
				+
			
 
				+        /* Last element should equal 10 */
			
 
				+        p = ziplistIndex(zl, -1);
			
 
				+        if (!ziplistCompare(p, (unsigned char*)"10", 2)) {
			
 
				+            printf("ERROR: not \"10\"\n");
			
 
				+            return 1;
			
 
				+        }
			
 
				+
			
 
				+        zfree(zl);
			
 
				+    }
			
 
				+
			
 
				+    printf("ALL TESTS PASSED!\n");
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/ziplist.h
+++ b/src/ziplist.h
@@ -0,0 +1,74 @@
 
				+/*
			
 
				+ * Copyright (c) 2009-2012, Pieter Noordhuis <pcnoordhuis at gmail dot com>
			
 
				+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef _ZIPLIST_H
			
 
				+#define _ZIPLIST_H
			
 
				+
			
 
				+#define ZIPLIST_HEAD 0
			
 
				+#define ZIPLIST_TAIL 1
			
 
				+
			
 
				+/* Each entry in the ziplist is either a string or an integer. */
			
 
				+typedef struct {
			
 
				+    /* When string is used, it is provided with the length (slen). */
			
 
				+    unsigned char *sval;
			
 
				+    unsigned int slen;
			
 
				+    /* When integer is used, 'sval' is NULL, and lval holds the value. */
			
 
				+    long long lval;
			
 
				+} ziplistEntry;
			
 
				+
			
 
				+unsigned char *ziplistNew(void);
			
 
				+unsigned char *ziplistMerge(unsigned char **first, unsigned char **second);
			
 
				+unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where);
			
 
				+unsigned char *ziplistIndex(unsigned char *zl, int index);
			
 
				+unsigned char *ziplistNext(unsigned char *zl, unsigned char *p);
			
 
				+unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p);
			
 
				+unsigned int ziplistGet(unsigned char *p, unsigned char **sval, unsigned int *slen, long long *lval);
			
 
				+unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);
			
 
				+unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p);
			
 
				+unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num);
			
 
				+unsigned char *ziplistReplace(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);
			
 
				+unsigned int ziplistCompare(unsigned char *p, unsigned char *s, unsigned int slen);
			
 
				+unsigned char *ziplistFind(unsigned char *zl, unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip);
			
 
				+unsigned int ziplistLen(unsigned char *zl);
			
 
				+size_t ziplistBlobLen(unsigned char *zl);
			
 
				+void ziplistRepr(unsigned char *zl);
			
 
				+typedef int (*ziplistValidateEntryCB)(unsigned char* p, unsigned int head_count, void* userdata);
			
 
				+int ziplistValidateIntegrity(unsigned char *zl, size_t size, int deep,
			
 
				+                             ziplistValidateEntryCB entry_cb, void *cb_userdata);
			
 
				+void ziplistRandomPair(unsigned char *zl, unsigned long total_count, ziplistEntry *key, ziplistEntry *val);
			
 
				+void ziplistRandomPairs(unsigned char *zl, unsigned int count, ziplistEntry *keys, ziplistEntry *vals);
			
 
				+unsigned int ziplistRandomPairsUnique(unsigned char *zl, unsigned int count, ziplistEntry *keys, ziplistEntry *vals);
			
 
				+int ziplistSafeToAdd(unsigned char* zl, size_t add);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int ziplistTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif /* _ZIPLIST_H */
			
--- a/src/zipmap.c
+++ b/src/zipmap.c
@@ -0,0 +1,542 @@
 
				+/* String -> String Map data structure optimized for size.
			
 
				+ * This file implements a data structure mapping strings to other strings
			
 
				+ * implementing an O(n) lookup data structure designed to be very memory
			
 
				+ * efficient.
			
 
				+ *
			
 
				+ * The Redis Hash type uses this data structure for hashes composed of a small
			
 
				+ * number of elements, to switch to a hash table once a given number of
			
 
				+ * elements is reached.
			
 
				+ *
			
 
				+ * Given that many times Redis Hashes are used to represent objects composed
			
 
				+ * of few fields, this is a very big win in terms of used memory.
			
 
				+ *
			
 
				+ * --------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+/* Memory layout of a zipmap, for the map "foo" => "bar", "hello" => "world":
			
 
				+ *
			
 
				+ * <zmlen><len>"foo"<len><free>"bar"<len>"hello"<len><free>"world"
			
 
				+ *
			
 
				+ * <zmlen> is 1 byte length that holds the current size of the zipmap.
			
 
				+ * When the zipmap length is greater than or equal to 254, this value
			
 
				+ * is not used and the zipmap needs to be traversed to find out the length.
			
 
				+ *
			
 
				+ * <len> is the length of the following string (key or value).
			
 
				+ * <len> lengths are encoded in a single value or in a 5 bytes value.
			
 
				+ * If the first byte value (as an unsigned 8 bit value) is between 0 and
			
 
				+ * 253, it's a single-byte length. If it is 254 then a four bytes unsigned
			
 
				+ * integer follows (in the host byte ordering). A value of 255 is used to
			
 
				+ * signal the end of the hash.
			
 
				+ *
			
 
				+ * <free> is the number of free unused bytes after the string, resulting
			
 
				+ * from modification of values associated to a key. For instance if "foo"
			
 
				+ * is set to "bar", and later "foo" will be set to "hi", it will have a
			
 
				+ * free byte to use if the value will enlarge again later, or even in
			
 
				+ * order to add a key/value pair if it fits.
			
 
				+ *
			
 
				+ * <free> is always an unsigned 8 bit number, because if after an
			
 
				+ * update operation there are more than a few free bytes, the zipmap will be
			
 
				+ * reallocated to make sure it is as small as possible.
			
 
				+ *
			
 
				+ * The most compact representation of the above two elements hash is actually:
			
 
				+ *
			
 
				+ * "\x02\x03foo\x03\x00bar\x05hello\x05\x00world\xff"
			
 
				+ *
			
 
				+ * Note that because keys and values are prefixed length "objects",
			
 
				+ * the lookup will take O(N) where N is the number of elements
			
 
				+ * in the zipmap and *not* the number of bytes needed to represent the zipmap.
			
 
				+ * This lowers the constant times considerably.
			
 
				+ */
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <string.h>
			
 
				+#include "zmalloc.h"
			
 
				+#include "endianconv.h"
			
 
				+
			
 
				+#define ZIPMAP_BIGLEN 254
			
 
				+#define ZIPMAP_END 255
			
 
				+
			
 
				+/* The following defines the max value for the <free> field described in the
			
 
				+ * comments above, that is, the max number of trailing bytes in a value. */
			
 
				+#define ZIPMAP_VALUE_MAX_FREE 4
			
 
				+
			
 
				+/* The following macro returns the number of bytes needed to encode the length
			
 
				+ * for the integer value _l, that is, 1 byte for lengths < ZIPMAP_BIGLEN and
			
 
				+ * 5 bytes for all the other lengths. */
			
 
				+#define ZIPMAP_LEN_BYTES(_l) (((_l) < ZIPMAP_BIGLEN) ? 1 : sizeof(unsigned int)+1)
			
 
				+
			
 
				+/* Create a new empty zipmap. */
			
 
				+unsigned char *zipmapNew(void) {
			
 
				+    unsigned char *zm = zmalloc(2);
			
 
				+
			
 
				+    zm[0] = 0; /* Length */
			
 
				+    zm[1] = ZIPMAP_END;
			
 
				+    return zm;
			
 
				+}
			
 
				+
			
 
				+/* Decode the encoded length pointed by 'p' */
			
 
				+static unsigned int zipmapDecodeLength(unsigned char *p) {
			
 
				+    unsigned int len = *p;
			
 
				+
			
 
				+    if (len < ZIPMAP_BIGLEN) return len;
			
 
				+    memcpy(&len,p+1,sizeof(unsigned int));
			
 
				+    memrev32ifbe(&len);
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+static unsigned int zipmapGetEncodedLengthSize(unsigned char *p) {
			
 
				+    return (*p < ZIPMAP_BIGLEN) ? 1: 5;
			
 
				+}
			
 
				+
			
 
				+/* Encode the length 'l' writing it in 'p'. If p is NULL it just returns
			
 
				+ * the amount of bytes required to encode such a length. */
			
 
				+static unsigned int zipmapEncodeLength(unsigned char *p, unsigned int len) {
			
 
				+    if (p == NULL) {
			
 
				+        return ZIPMAP_LEN_BYTES(len);
			
 
				+    } else {
			
 
				+        if (len < ZIPMAP_BIGLEN) {
			
 
				+            p[0] = len;
			
 
				+            return 1;
			
 
				+        } else {
			
 
				+            p[0] = ZIPMAP_BIGLEN;
			
 
				+            memcpy(p+1,&len,sizeof(len));
			
 
				+            memrev32ifbe(p+1);
			
 
				+            return 1+sizeof(len);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+/* Search for a matching key, returning a pointer to the entry inside the
			
 
				+ * zipmap. Returns NULL if the key is not found.
			
 
				+ *
			
 
				+ * If NULL is returned, and totlen is not NULL, it is set to the entire
			
 
				+ * size of the zipmap, so that the calling function will be able to
			
 
				+ * reallocate the original zipmap to make room for more entries. */
			
 
				+static unsigned char *zipmapLookupRaw(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned int *totlen) {
			
 
				+    unsigned char *p = zm+1, *k = NULL;
			
 
				+    unsigned int l,llen;
			
 
				+
			
 
				+    while(*p != ZIPMAP_END) {
			
 
				+        unsigned char free;
			
 
				+
			
 
				+        /* Match or skip the key */
			
 
				+        l = zipmapDecodeLength(p);
			
 
				+        llen = zipmapEncodeLength(NULL,l);
			
 
				+        if (key != NULL && k == NULL && l == klen && !memcmp(p+llen,key,l)) {
			
 
				+            /* Only return when the user doesn't care
			
 
				+             * for the total length of the zipmap. */
			
 
				+            if (totlen != NULL) {
			
 
				+                k = p;
			
 
				+            } else {
			
 
				+                return p;
			
 
				+            }
			
 
				+        }
			
 
				+        p += llen+l;
			
 
				+        /* Skip the value as well */
			
 
				+        l = zipmapDecodeLength(p);
			
 
				+        p += zipmapEncodeLength(NULL,l);
			
 
				+        free = p[0];
			
 
				+        p += l+1+free; /* +1 to skip the free byte */
			
 
				+    }
			
 
				+    if (totlen != NULL) *totlen = (unsigned int)(p-zm)+1;
			
 
				+    return k;
			
 
				+}
			
 
				+
			
 
				+static unsigned long zipmapRequiredLength(unsigned int klen, unsigned int vlen) {
			
 
				+    unsigned int l;
			
 
				+
			
 
				+    l = klen+vlen+3;
			
 
				+    if (klen >= ZIPMAP_BIGLEN) l += 4;
			
 
				+    if (vlen >= ZIPMAP_BIGLEN) l += 4;
			
 
				+    return l;
			
 
				+}
			
 
				+
			
 
				+/* Return the total amount used by a key (encoded length + payload) */
			
 
				+static unsigned int zipmapRawKeyLength(unsigned char *p) {
			
 
				+    unsigned int l = zipmapDecodeLength(p);
			
 
				+    return zipmapEncodeLength(NULL,l) + l;
			
 
				+}
			
 
				+
			
 
				+/* Return the total amount used by a value
			
 
				+ * (encoded length + single byte free count + payload) */
			
 
				+static unsigned int zipmapRawValueLength(unsigned char *p) {
			
 
				+    unsigned int l = zipmapDecodeLength(p);
			
 
				+    unsigned int used;
			
 
				+
			
 
				+    used = zipmapEncodeLength(NULL,l);
			
 
				+    used += p[used] + 1 + l;
			
 
				+    return used;
			
 
				+}
			
 
				+
			
 
				+/* If 'p' points to a key, this function returns the total amount of
			
 
				+ * bytes used to store this entry (entry = key + associated value + trailing
			
 
				+ * free space if any). */
			
 
				+static unsigned int zipmapRawEntryLength(unsigned char *p) {
			
 
				+    unsigned int l = zipmapRawKeyLength(p);
			
 
				+    return l + zipmapRawValueLength(p+l);
			
 
				+}
			
 
				+
			
 
				+static inline unsigned char *zipmapResize(unsigned char *zm, unsigned int len) {
			
 
				+    zm = zrealloc(zm, len);
			
 
				+    zm[len-1] = ZIPMAP_END;
			
 
				+    return zm;
			
 
				+}
			
 
				+
			
 
				+/* Set key to value, creating the key if it does not already exist.
			
 
				+ * If 'update' is not NULL, *update is set to 1 if the key was
			
 
				+ * already preset, otherwise to 0. */
			
 
				+unsigned char *zipmapSet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char *val, unsigned int vlen, int *update) {
			
 
				+    unsigned int zmlen, offset;
			
 
				+    unsigned int freelen, reqlen = zipmapRequiredLength(klen,vlen);
			
 
				+    unsigned int empty, vempty;
			
 
				+    unsigned char *p;
			
 
				+
			
 
				+    freelen = reqlen;
			
 
				+    if (update) *update = 0;
			
 
				+    p = zipmapLookupRaw(zm,key,klen,&zmlen);
			
 
				+    if (p == NULL) {
			
 
				+        /* Key not found: enlarge */
			
 
				+        zm = zipmapResize(zm, zmlen+reqlen);
			
 
				+        p = zm+zmlen-1;
			
 
				+        zmlen = zmlen+reqlen;
			
 
				+
			
 
				+        /* Increase zipmap length (this is an insert) */
			
 
				+        if (zm[0] < ZIPMAP_BIGLEN) zm[0]++;
			
 
				+    } else {
			
 
				+        /* Key found. Is there enough space for the new value? */
			
 
				+        /* Compute the total length: */
			
 
				+        if (update) *update = 1;
			
 
				+        freelen = zipmapRawEntryLength(p);
			
 
				+        if (freelen < reqlen) {
			
 
				+            /* Store the offset of this key within the current zipmap, so
			
 
				+             * it can be resized. Then, move the tail backwards so this
			
 
				+             * pair fits at the current position. */
			
 
				+            offset = p-zm;
			
 
				+            zm = zipmapResize(zm, zmlen-freelen+reqlen);
			
 
				+            p = zm+offset;
			
 
				+
			
 
				+            /* The +1 in the number of bytes to be moved is caused by the
			
 
				+             * end-of-zipmap byte. Note: the *original* zmlen is used. */
			
 
				+            memmove(p+reqlen, p+freelen, zmlen-(offset+freelen+1));
			
 
				+            zmlen = zmlen-freelen+reqlen;
			
 
				+            freelen = reqlen;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    /* We now have a suitable block where the key/value entry can
			
 
				+     * be written. If there is too much free space, move the tail
			
 
				+     * of the zipmap a few bytes to the front and shrink the zipmap,
			
 
				+     * as we want zipmaps to be very space efficient. */
			
 
				+    empty = freelen-reqlen;
			
 
				+    if (empty >= ZIPMAP_VALUE_MAX_FREE) {
			
 
				+        /* First, move the tail <empty> bytes to the front, then resize
			
 
				+         * the zipmap to be <empty> bytes smaller. */
			
 
				+        offset = p-zm;
			
 
				+        memmove(p+reqlen, p+freelen, zmlen-(offset+freelen+1));
			
 
				+        zmlen -= empty;
			
 
				+        zm = zipmapResize(zm, zmlen);
			
 
				+        p = zm+offset;
			
 
				+        vempty = 0;
			
 
				+    } else {
			
 
				+        vempty = empty;
			
 
				+    }
			
 
				+
			
 
				+    /* Just write the key + value and we are done. */
			
 
				+    /* Key: */
			
 
				+    p += zipmapEncodeLength(p,klen);
			
 
				+    memcpy(p,key,klen);
			
 
				+    p += klen;
			
 
				+    /* Value: */
			
 
				+    p += zipmapEncodeLength(p,vlen);
			
 
				+    *p++ = vempty;
			
 
				+    memcpy(p,val,vlen);
			
 
				+    return zm;
			
 
				+}
			
 
				+
			
 
				+/* Remove the specified key. If 'deleted' is not NULL the pointed integer is
			
 
				+ * set to 0 if the key was not found, to 1 if it was found and deleted. */
			
 
				+unsigned char *zipmapDel(unsigned char *zm, unsigned char *key, unsigned int klen, int *deleted) {
			
 
				+    unsigned int zmlen, freelen;
			
 
				+    unsigned char *p = zipmapLookupRaw(zm,key,klen,&zmlen);
			
 
				+    if (p) {
			
 
				+        freelen = zipmapRawEntryLength(p);
			
 
				+        memmove(p, p+freelen, zmlen-((p-zm)+freelen+1));
			
 
				+        zm = zipmapResize(zm, zmlen-freelen);
			
 
				+
			
 
				+        /* Decrease zipmap length */
			
 
				+        if (zm[0] < ZIPMAP_BIGLEN) zm[0]--;
			
 
				+
			
 
				+        if (deleted) *deleted = 1;
			
 
				+    } else {
			
 
				+        if (deleted) *deleted = 0;
			
 
				+    }
			
 
				+    return zm;
			
 
				+}
			
 
				+
			
 
				+/* Call before iterating through elements via zipmapNext() */
			
 
				+unsigned char *zipmapRewind(unsigned char *zm) {
			
 
				+    return zm+1;
			
 
				+}
			
 
				+
			
 
				+/* This function is used to iterate through all the zipmap elements.
			
 
				+ * In the first call the first argument is the pointer to the zipmap + 1.
			
 
				+ * In the next calls what zipmapNext returns is used as first argument.
			
 
				+ * Example:
			
 
				+ *
			
 
				+ * unsigned char *i = zipmapRewind(my_zipmap);
			
 
				+ * while((i = zipmapNext(i,&key,&klen,&value,&vlen)) != NULL) {
			
 
				+ *     printf("%d bytes key at $p\n", klen, key);
			
 
				+ *     printf("%d bytes value at $p\n", vlen, value);
			
 
				+ * }
			
 
				+ */
			
 
				+unsigned char *zipmapNext(unsigned char *zm, unsigned char **key, unsigned int *klen, unsigned char **value, unsigned int *vlen) {
			
 
				+    if (zm[0] == ZIPMAP_END) return NULL;
			
 
				+    if (key) {
			
 
				+        *key = zm;
			
 
				+        *klen = zipmapDecodeLength(zm);
			
 
				+        *key += ZIPMAP_LEN_BYTES(*klen);
			
 
				+    }
			
 
				+    zm += zipmapRawKeyLength(zm);
			
 
				+    if (value) {
			
 
				+        *value = zm+1;
			
 
				+        *vlen = zipmapDecodeLength(zm);
			
 
				+        *value += ZIPMAP_LEN_BYTES(*vlen);
			
 
				+    }
			
 
				+    zm += zipmapRawValueLength(zm);
			
 
				+    return zm;
			
 
				+}
			
 
				+
			
 
				+/* Search a key and retrieve the pointer and len of the associated value.
			
 
				+ * If the key is found the function returns 1, otherwise 0. */
			
 
				+int zipmapGet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char **value, unsigned int *vlen) {
			
 
				+    unsigned char *p;
			
 
				+
			
 
				+    if ((p = zipmapLookupRaw(zm,key,klen,NULL)) == NULL) return 0;
			
 
				+    p += zipmapRawKeyLength(p);
			
 
				+    *vlen = zipmapDecodeLength(p);
			
 
				+    *value = p + ZIPMAP_LEN_BYTES(*vlen) + 1;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+/* Return 1 if the key exists, otherwise 0 is returned. */
			
 
				+int zipmapExists(unsigned char *zm, unsigned char *key, unsigned int klen) {
			
 
				+    return zipmapLookupRaw(zm,key,klen,NULL) != NULL;
			
 
				+}
			
 
				+
			
 
				+/* Return the number of entries inside a zipmap */
			
 
				+unsigned int zipmapLen(unsigned char *zm) {
			
 
				+    unsigned int len = 0;
			
 
				+    if (zm[0] < ZIPMAP_BIGLEN) {
			
 
				+        len = zm[0];
			
 
				+    } else {
			
 
				+        unsigned char *p = zipmapRewind(zm);
			
 
				+        while((p = zipmapNext(p,NULL,NULL,NULL,NULL)) != NULL) len++;
			
 
				+
			
 
				+        /* Re-store length if small enough */
			
 
				+        if (len < ZIPMAP_BIGLEN) zm[0] = len;
			
 
				+    }
			
 
				+    return len;
			
 
				+}
			
 
				+
			
 
				+/* Return the raw size in bytes of a zipmap, so that we can serialize
			
 
				+ * the zipmap on disk (or everywhere is needed) just writing the returned
			
 
				+ * amount of bytes of the C array starting at the zipmap pointer. */
			
 
				+size_t zipmapBlobLen(unsigned char *zm) {
			
 
				+    unsigned int totlen;
			
 
				+    zipmapLookupRaw(zm,NULL,0,&totlen);
			
 
				+    return totlen;
			
 
				+}
			
 
				+
			
 
				+/* Validate the integrity of the data structure.
			
 
				+ * when `deep` is 0, only the integrity of the header is validated.
			
 
				+ * when `deep` is 1, we scan all the entries one by one. */
			
 
				+int zipmapValidateIntegrity(unsigned char *zm, size_t size, int deep) {
			
 
				+#define OUT_OF_RANGE(p) ( \
			
 
				+        (p) < zm + 2 || \
			
 
				+        (p) > zm + size - 1)
			
 
				+    unsigned int l, s, e;
			
 
				+
			
 
				+    /* check that we can actually read the header (or ZIPMAP_END). */
			
 
				+    if (size < 2)
			
 
				+        return 0;
			
 
				+
			
 
				+    /* the last byte must be the terminator. */
			
 
				+    if (zm[size-1] != ZIPMAP_END)
			
 
				+        return 0;
			
 
				+
			
 
				+    if (!deep)
			
 
				+        return 1;
			
 
				+
			
 
				+    unsigned int count = 0;
			
 
				+    unsigned char *p = zm + 1; /* skip the count */
			
 
				+    while(*p != ZIPMAP_END) {
			
 
				+        /* read the field name length encoding type */
			
 
				+        s = zipmapGetEncodedLengthSize(p);
			
 
				+        /* make sure the entry length doesn't reach outside the edge of the zipmap */
			
 
				+        if (OUT_OF_RANGE(p+s))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* read the field name length */
			
 
				+        l = zipmapDecodeLength(p);
			
 
				+        p += s; /* skip the encoded field size */
			
 
				+        p += l; /* skip the field */
			
 
				+
			
 
				+        /* make sure the entry doesn't reach outside the edge of the zipmap */
			
 
				+        if (OUT_OF_RANGE(p))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* read the value length encoding type */
			
 
				+        s = zipmapGetEncodedLengthSize(p);
			
 
				+        /* make sure the entry length doesn't reach outside the edge of the zipmap */
			
 
				+        if (OUT_OF_RANGE(p+s))
			
 
				+            return 0;
			
 
				+
			
 
				+        /* read the value length */
			
 
				+        l = zipmapDecodeLength(p);
			
 
				+        p += s; /* skip the encoded value size*/
			
 
				+        e = *p++; /* skip the encoded free space (always encoded in one byte) */
			
 
				+        p += l+e; /* skip the value and free space */
			
 
				+        count++;
			
 
				+
			
 
				+        /* make sure the entry doesn't reach outside the edge of the zipmap */
			
 
				+        if (OUT_OF_RANGE(p))
			
 
				+            return 0;
			
 
				+    }
			
 
				+
			
 
				+    /* check that the zipmap is not empty. */
			
 
				+    if (count == 0) return 0;
			
 
				+
			
 
				+    /* check that the count in the header is correct */
			
 
				+    if (zm[0] != ZIPMAP_BIGLEN && zm[0] != count)
			
 
				+        return 0;
			
 
				+
			
 
				+    return 1;
			
 
				+#undef OUT_OF_RANGE
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+static void zipmapRepr(unsigned char *p) {
			
 
				+    unsigned int l;
			
 
				+
			
 
				+    printf("{status %u}",*p++);
			
 
				+    while(1) {
			
 
				+        if (p[0] == ZIPMAP_END) {
			
 
				+            printf("{end}");
			
 
				+            break;
			
 
				+        } else {
			
 
				+            unsigned char e;
			
 
				+
			
 
				+            l = zipmapDecodeLength(p);
			
 
				+            printf("{key %u}",l);
			
 
				+            p += zipmapEncodeLength(NULL,l);
			
 
				+            if (l != 0 && fwrite(p,l,1,stdout) == 0) perror("fwrite");
			
 
				+            p += l;
			
 
				+
			
 
				+            l = zipmapDecodeLength(p);
			
 
				+            printf("{value %u}",l);
			
 
				+            p += zipmapEncodeLength(NULL,l);
			
 
				+            e = *p++;
			
 
				+            if (l != 0 && fwrite(p,l,1,stdout) == 0) perror("fwrite");
			
 
				+            p += l+e;
			
 
				+            if (e) {
			
 
				+                printf("[");
			
 
				+                while(e--) printf(".");
			
 
				+                printf("]");
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    printf("\n");
			
 
				+}
			
 
				+
			
 
				+#define UNUSED(x) (void)(x)
			
 
				+int zipmapTest(int argc, char *argv[], int flags) {
			
 
				+    unsigned char *zm;
			
 
				+
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+
			
 
				+    zm = zipmapNew();
			
 
				+
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "name",4, (unsigned char*) "foo",3,NULL);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "surname",7, (unsigned char*) "foo",3,NULL);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "age",3, (unsigned char*) "foo",3,NULL);
			
 
				+    zipmapRepr(zm);
			
 
				+
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "hello",5, (unsigned char*) "world!",6,NULL);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "bar",3,NULL);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "!",1,NULL);
			
 
				+    zipmapRepr(zm);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "12345",5,NULL);
			
 
				+    zipmapRepr(zm);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "new",3, (unsigned char*) "xx",2,NULL);
			
 
				+    zm = zipmapSet(zm,(unsigned char*) "noval",5, (unsigned char*) "",0,NULL);
			
 
				+    zipmapRepr(zm);
			
 
				+    zm = zipmapDel(zm,(unsigned char*) "new",3,NULL);
			
 
				+    zipmapRepr(zm);
			
 
				+
			
 
				+    printf("\nLook up large key:\n");
			
 
				+    {
			
 
				+        unsigned char buf[512];
			
 
				+        unsigned char *value;
			
 
				+        unsigned int vlen, i;
			
 
				+        for (i = 0; i < 512; i++) buf[i] = 'a';
			
 
				+
			
 
				+        zm = zipmapSet(zm,buf,512,(unsigned char*) "long",4,NULL);
			
 
				+        if (zipmapGet(zm,buf,512,&value,&vlen)) {
			
 
				+            printf("  <long key> is associated to the %d bytes value: %.*s\n",
			
 
				+                vlen, vlen, value);
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    printf("\nPerform a direct lookup:\n");
			
 
				+    {
			
 
				+        unsigned char *value;
			
 
				+        unsigned int vlen;
			
 
				+
			
 
				+        if (zipmapGet(zm,(unsigned char*) "foo",3,&value,&vlen)) {
			
 
				+            printf("  foo is associated to the %d bytes value: %.*s\n",
			
 
				+                vlen, vlen, value);
			
 
				+        }
			
 
				+    }
			
 
				+    printf("\nIterate through elements:\n");
			
 
				+    {
			
 
				+        unsigned char *i = zipmapRewind(zm);
			
 
				+        unsigned char *key, *value;
			
 
				+        unsigned int klen, vlen;
			
 
				+
			
 
				+        while((i = zipmapNext(i,&key,&klen,&value,&vlen)) != NULL) {
			
 
				+            printf("  %d:%.*s => %d:%.*s\n", klen, klen, key, vlen, vlen, value);
			
 
				+        }
			
 
				+    }
			
 
				+    zfree(zm);
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/zipmap.h
+++ b/src/zipmap.h
@@ -0,0 +1,54 @@
 
				+/* String -> String Map data structure optimized for size.
			
 
				+ *
			
 
				+ * See zipmap.c for more info.
			
 
				+ *
			
 
				+ * --------------------------------------------------------------------------
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef _ZIPMAP_H
			
 
				+#define _ZIPMAP_H
			
 
				+
			
 
				+unsigned char *zipmapNew(void);
			
 
				+unsigned char *zipmapSet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char *val, unsigned int vlen, int *update);
			
 
				+unsigned char *zipmapDel(unsigned char *zm, unsigned char *key, unsigned int klen, int *deleted);
			
 
				+unsigned char *zipmapRewind(unsigned char *zm);
			
 
				+unsigned char *zipmapNext(unsigned char *zm, unsigned char **key, unsigned int *klen, unsigned char **value, unsigned int *vlen);
			
 
				+int zipmapGet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char **value, unsigned int *vlen);
			
 
				+int zipmapExists(unsigned char *zm, unsigned char *key, unsigned int klen);
			
 
				+unsigned int zipmapLen(unsigned char *zm);
			
 
				+size_t zipmapBlobLen(unsigned char *zm);
			
 
				+void zipmapRepr(unsigned char *p);
			
 
				+int zipmapValidateIntegrity(unsigned char *zm, size_t size, int deep);
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int zipmapTest(int argc, char *argv[], int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif
			
--- a/src/zmalloc.c
+++ b/src/zmalloc.c
@@ -0,0 +1,731 @@
 
				+/* zmalloc - total amount of allocated memory aware version of malloc()
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+// #include "fmacros.h"
			
 
				+#include "config.h"
			
 
				+// #include "solarisfixes.h"
			
 
				+
			
 
				+#include <stdio.h>
			
 
				+#include <stdlib.h>
			
 
				+#include <stdint.h>
			
 
				+#include <unistd.h>
			
 
				+#include <assert.h>
			
 
				+
			
 
				+#ifdef __linux__
			
 
				+#include <sys/mman.h>
			
 
				+#endif
			
 
				+
			
 
				+/* This function provide us access to the original libc free(). This is useful
			
 
				+ * for instance to free results obtained by backtrace_symbols(). We need
			
 
				+ * to define this function before including zmalloc.h that may shadow the
			
 
				+ * free implementation if we use jemalloc or another non standard allocator. */
			
 
				+void zlibc_free(void *ptr) {
			
 
				+    free(ptr);
			
 
				+}
			
 
				+
			
 
				+#include <string.h>
			
 
				+#include <pthread.h>
			
 
				+#include "zmalloc.h"
			
 
				+#include "atomicvar.h"
			
 
				+
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+#define PREFIX_SIZE (0)
			
 
				+#define ASSERT_NO_SIZE_OVERFLOW(sz)
			
 
				+#else
			
 
				+#if defined(__sun) || defined(__sparc) || defined(__sparc__)
			
 
				+#define PREFIX_SIZE (sizeof(long long))
			
 
				+#else
			
 
				+#define PREFIX_SIZE (sizeof(size_t))
			
 
				+#endif
			
 
				+#define ASSERT_NO_SIZE_OVERFLOW(sz) assert((sz) + PREFIX_SIZE > (sz))
			
 
				+#endif
			
 
				+
			
 
				+/* When using the libc allocator, use a minimum allocation size to match the
			
 
				+ * jemalloc behavior that doesn't return NULL in this case.
			
 
				+ */
			
 
				+#define MALLOC_MIN_SIZE(x) ((x) > 0 ? (x) : sizeof(long))
			
 
				+
			
 
				+/* Explicitly override malloc/free etc when using tcmalloc. */
			
 
				+#if defined(USE_TCMALLOC)
			
 
				+#define malloc(size) tc_malloc(size)
			
 
				+#define calloc(count,size) tc_calloc(count,size)
			
 
				+#define realloc(ptr,size) tc_realloc(ptr,size)
			
 
				+#define free(ptr) tc_free(ptr)
			
 
				+#elif defined(USE_JEMALLOC)
			
 
				+#define malloc(size) je_malloc(size)
			
 
				+#define calloc(count,size) je_calloc(count,size)
			
 
				+#define realloc(ptr,size) je_realloc(ptr,size)
			
 
				+#define free(ptr) je_free(ptr)
			
 
				+#define mallocx(size,flags) je_mallocx(size,flags)
			
 
				+#define dallocx(ptr,flags) je_dallocx(ptr,flags)
			
 
				+#endif
			
 
				+
			
 
				+#define update_zmalloc_stat_alloc(__n) atomicIncr(used_memory,(__n))
			
 
				+#define update_zmalloc_stat_free(__n) atomicDecr(used_memory,(__n))
			
 
				+
			
 
				+static redisAtomic size_t used_memory = 0;
			
 
				+
			
 
				+static void zmalloc_default_oom(size_t size) {
			
 
				+    fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
			
 
				+        size);
			
 
				+    fflush(stderr);
			
 
				+    abort();
			
 
				+}
			
 
				+
			
 
				+static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom;
			
 
				+
			
 
				+/* Try allocating memory, and return NULL if failed.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *ztrymalloc_usable(size_t size, size_t *usable) {
			
 
				+    ASSERT_NO_SIZE_OVERFLOW(size);
			
 
				+    void *ptr = malloc(MALLOC_MIN_SIZE(size)+PREFIX_SIZE);
			
 
				+
			
 
				+    if (!ptr) return NULL;
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+    size = zmalloc_size(ptr);
			
 
				+    update_zmalloc_stat_alloc(size);
			
 
				+    if (usable) *usable = size;
			
 
				+    return ptr;
			
 
				+#else
			
 
				+    *((size_t*)ptr) = size;
			
 
				+    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
			
 
				+    if (usable) *usable = size;
			
 
				+    return (char*)ptr+PREFIX_SIZE;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Allocate memory or panic */
			
 
				+void *zmalloc(size_t size) {
			
 
				+    void *ptr = ztrymalloc_usable(size, NULL);
			
 
				+    if (!ptr) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Try allocating memory, and return NULL if failed. */
			
 
				+void *ztrymalloc(size_t size) {
			
 
				+    void *ptr = ztrymalloc_usable(size, NULL);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Allocate memory or panic.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *zmalloc_usable(size_t size, size_t *usable) {
			
 
				+    void *ptr = ztrymalloc_usable(size, usable);
			
 
				+    if (!ptr) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Allocation and free functions that bypass the thread cache
			
 
				+ * and go straight to the allocator arena bins.
			
 
				+ * Currently implemented only for jemalloc. Used for online defragmentation. */
			
 
				+#ifdef HAVE_DEFRAG
			
 
				+void *zmalloc_no_tcache(size_t size) {
			
 
				+    ASSERT_NO_SIZE_OVERFLOW(size);
			
 
				+    void *ptr = mallocx(size+PREFIX_SIZE, MALLOCX_TCACHE_NONE);
			
 
				+    if (!ptr) zmalloc_oom_handler(size);
			
 
				+    update_zmalloc_stat_alloc(zmalloc_size(ptr));
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+void zfree_no_tcache(void *ptr) {
			
 
				+    if (ptr == NULL) return;
			
 
				+    update_zmalloc_stat_free(zmalloc_size(ptr));
			
 
				+    dallocx(ptr, MALLOCX_TCACHE_NONE);
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+/* Try allocating memory and zero it, and return NULL if failed.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *ztrycalloc_usable(size_t size, size_t *usable) {
			
 
				+    ASSERT_NO_SIZE_OVERFLOW(size);
			
 
				+    void *ptr = calloc(1, MALLOC_MIN_SIZE(size)+PREFIX_SIZE);
			
 
				+    if (ptr == NULL) return NULL;
			
 
				+
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+    size = zmalloc_size(ptr);
			
 
				+    update_zmalloc_stat_alloc(size);
			
 
				+    if (usable) *usable = size;
			
 
				+    return ptr;
			
 
				+#else
			
 
				+    *((size_t*)ptr) = size;
			
 
				+    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
			
 
				+    if (usable) *usable = size;
			
 
				+    return (char*)ptr+PREFIX_SIZE;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Allocate memory and zero it or panic */
			
 
				+void *zcalloc(size_t size) {
			
 
				+    void *ptr = ztrycalloc_usable(size, NULL);
			
 
				+    if (!ptr) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Try allocating memory, and return NULL if failed. */
			
 
				+void *ztrycalloc(size_t size) {
			
 
				+    void *ptr = ztrycalloc_usable(size, NULL);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Allocate memory or panic.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *zcalloc_usable(size_t size, size_t *usable) {
			
 
				+    void *ptr = ztrycalloc_usable(size, usable);
			
 
				+    if (!ptr) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Try reallocating memory, and return NULL if failed.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *ztryrealloc_usable(void *ptr, size_t size, size_t *usable) {
			
 
				+    ASSERT_NO_SIZE_OVERFLOW(size);
			
 
				+#ifndef HAVE_MALLOC_SIZE
			
 
				+    void *realptr;
			
 
				+#endif
			
 
				+    size_t oldsize;
			
 
				+    void *newptr;
			
 
				+
			
 
				+    /* not allocating anything, just redirect to free. */
			
 
				+    if (size == 0 && ptr != NULL) {
			
 
				+        zfree(ptr);
			
 
				+        if (usable) *usable = 0;
			
 
				+        return NULL;
			
 
				+    }
			
 
				+    /* Not freeing anything, just redirect to malloc. */
			
 
				+    if (ptr == NULL)
			
 
				+        return ztrymalloc_usable(size, usable);
			
 
				+
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+    oldsize = zmalloc_size(ptr);
			
 
				+    newptr = realloc(ptr,size);
			
 
				+    if (newptr == NULL) {
			
 
				+        if (usable) *usable = 0;
			
 
				+        return NULL;
			
 
				+    }
			
 
				+
			
 
				+    update_zmalloc_stat_free(oldsize);
			
 
				+    size = zmalloc_size(newptr);
			
 
				+    update_zmalloc_stat_alloc(size);
			
 
				+    if (usable) *usable = size;
			
 
				+    return newptr;
			
 
				+#else
			
 
				+    realptr = (char*)ptr-PREFIX_SIZE;
			
 
				+    oldsize = *((size_t*)realptr);
			
 
				+    newptr = realloc(realptr,size+PREFIX_SIZE);
			
 
				+    if (newptr == NULL) {
			
 
				+        if (usable) *usable = 0;
			
 
				+        return NULL;
			
 
				+    }
			
 
				+
			
 
				+    *((size_t*)newptr) = size;
			
 
				+    update_zmalloc_stat_free(oldsize);
			
 
				+    update_zmalloc_stat_alloc(size);
			
 
				+    if (usable) *usable = size;
			
 
				+    return (char*)newptr+PREFIX_SIZE;
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Reallocate memory and zero it or panic */
			
 
				+void *zrealloc(void *ptr, size_t size) {
			
 
				+    ptr = ztryrealloc_usable(ptr, size, NULL);
			
 
				+    if (!ptr && size != 0) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Try Reallocating memory, and return NULL if failed. */
			
 
				+void *ztryrealloc(void *ptr, size_t size) {
			
 
				+    ptr = ztryrealloc_usable(ptr, size, NULL);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Reallocate memory or panic.
			
 
				+ * '*usable' is set to the usable size if non NULL. */
			
 
				+void *zrealloc_usable(void *ptr, size_t size, size_t *usable) {
			
 
				+    ptr = ztryrealloc_usable(ptr, size, usable);
			
 
				+    if (!ptr && size != 0) zmalloc_oom_handler(size);
			
 
				+    return ptr;
			
 
				+}
			
 
				+
			
 
				+/* Provide zmalloc_size() for systems where this function is not provided by
			
 
				+ * malloc itself, given that in that case we store a header with this
			
 
				+ * information as the first bytes of every allocation. */
			
 
				+#ifndef HAVE_MALLOC_SIZE
			
 
				+size_t zmalloc_size(void *ptr) {
			
 
				+    void *realptr = (char*)ptr-PREFIX_SIZE;
			
 
				+    size_t size = *((size_t*)realptr);
			
 
				+    return size+PREFIX_SIZE;
			
 
				+}
			
 
				+size_t zmalloc_usable_size(void *ptr) {
			
 
				+    return zmalloc_size(ptr)-PREFIX_SIZE;
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+void zfree(void *ptr) {
			
 
				+#ifndef HAVE_MALLOC_SIZE
			
 
				+    void *realptr;
			
 
				+    size_t oldsize;
			
 
				+#endif
			
 
				+
			
 
				+    if (ptr == NULL) return;
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+    update_zmalloc_stat_free(zmalloc_size(ptr));
			
 
				+    free(ptr);
			
 
				+#else
			
 
				+    realptr = (char*)ptr-PREFIX_SIZE;
			
 
				+    oldsize = *((size_t*)realptr);
			
 
				+    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
			
 
				+    free(realptr);
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Similar to zfree, '*usable' is set to the usable size being freed. */
			
 
				+void zfree_usable(void *ptr, size_t *usable) {
			
 
				+#ifndef HAVE_MALLOC_SIZE
			
 
				+    void *realptr;
			
 
				+    size_t oldsize;
			
 
				+#endif
			
 
				+
			
 
				+    if (ptr == NULL) return;
			
 
				+#ifdef HAVE_MALLOC_SIZE
			
 
				+    update_zmalloc_stat_free(*usable = zmalloc_size(ptr));
			
 
				+    free(ptr);
			
 
				+#else
			
 
				+    realptr = (char*)ptr-PREFIX_SIZE;
			
 
				+    *usable = oldsize = *((size_t*)realptr);
			
 
				+    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
			
 
				+    free(realptr);
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+char *zstrdup(const char *s) {
			
 
				+    size_t l = strlen(s)+1;
			
 
				+    char *p = zmalloc(l);
			
 
				+
			
 
				+    memcpy(p,s,l);
			
 
				+    return p;
			
 
				+}
			
 
				+
			
 
				+size_t zmalloc_used_memory(void) {
			
 
				+    size_t um;
			
 
				+    atomicGet(used_memory,um);
			
 
				+    return um;
			
 
				+}
			
 
				+
			
 
				+void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) {
			
 
				+    zmalloc_oom_handler = oom_handler;
			
 
				+}
			
 
				+
			
 
				+/* Use 'MADV_DONTNEED' to release memory to operating system quickly.
			
 
				+ * We do that in a fork child process to avoid CoW when the parent modifies
			
 
				+ * these shared pages. */
			
 
				+void zmadvise_dontneed(void *ptr) {
			
 
				+#if defined(USE_JEMALLOC) && defined(__linux__)
			
 
				+    static size_t page_size = 0;
			
 
				+    if (page_size == 0) page_size = sysconf(_SC_PAGESIZE);
			
 
				+    size_t page_size_mask = page_size - 1;
			
 
				+
			
 
				+    size_t real_size = zmalloc_size(ptr);
			
 
				+    if (real_size < page_size) return;
			
 
				+
			
 
				+    /* We need to align the pointer upwards according to page size, because
			
 
				+     * the memory address is increased upwards and we only can free memory
			
 
				+     * based on page. */
			
 
				+    char *aligned_ptr = (char *)(((size_t)ptr+page_size_mask) & ~page_size_mask);
			
 
				+    real_size -= (aligned_ptr-(char*)ptr);
			
 
				+    if (real_size >= page_size) {
			
 
				+        madvise((void *)aligned_ptr, real_size&~page_size_mask, MADV_DONTNEED);
			
 
				+    }
			
 
				+#else
			
 
				+    (void)(ptr);
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+/* Get the RSS information in an OS-specific way.
			
 
				+ *
			
 
				+ * WARNING: the function zmalloc_get_rss() is not designed to be fast
			
 
				+ * and may not be called in the busy loops where Redis tries to release
			
 
				+ * memory expiring or swapping out objects.
			
 
				+ *
			
 
				+ * For this kind of "fast RSS reporting" usages use instead the
			
 
				+ * function RedisEstimateRSS() that is a much faster (and less precise)
			
 
				+ * version of the function. */
			
 
				+
			
 
				+#if defined(HAVE_PROC_STAT)
			
 
				+#include <sys/types.h>
			
 
				+#include <sys/stat.h>
			
 
				+#include <fcntl.h>
			
 
				+
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    int page = sysconf(_SC_PAGESIZE);
			
 
				+    size_t rss;
			
 
				+    char buf[4096];
			
 
				+    char filename[256];
			
 
				+    int fd, count;
			
 
				+    char *p, *x;
			
 
				+
			
 
				+    snprintf(filename,256,"/proc/%ld/stat",(long) getpid());
			
 
				+    if ((fd = open(filename,O_RDONLY)) == -1) return 0;
			
 
				+    if (read(fd,buf,4096) <= 0) {
			
 
				+        close(fd);
			
 
				+        return 0;
			
 
				+    }
			
 
				+    close(fd);
			
 
				+
			
 
				+    p = buf;
			
 
				+    count = 23; /* RSS is the 24th field in /proc/<pid>/stat */
			
 
				+    while(p && count--) {
			
 
				+        p = strchr(p,' ');
			
 
				+        if (p) p++;
			
 
				+    }
			
 
				+    if (!p) return 0;
			
 
				+    x = strchr(p,' ');
			
 
				+    if (!x) return 0;
			
 
				+    *x = '\0';
			
 
				+
			
 
				+    rss = strtoll(p,NULL,10);
			
 
				+    rss *= page;
			
 
				+    return rss;
			
 
				+}
			
 
				+#elif defined(HAVE_TASKINFO)
			
 
				+#include <sys/types.h>
			
 
				+#include <sys/sysctl.h>
			
 
				+#include <mach/task.h>
			
 
				+#include <mach/mach_init.h>
			
 
				+
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    task_t task = MACH_PORT_NULL;
			
 
				+    struct task_basic_info t_info;
			
 
				+    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
			
 
				+
			
 
				+    if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS)
			
 
				+        return 0;
			
 
				+    task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count);
			
 
				+
			
 
				+    return t_info.resident_size;
			
 
				+}
			
 
				+#elif defined(__FreeBSD__) || defined(__DragonFly__)
			
 
				+#include <sys/types.h>
			
 
				+#include <sys/sysctl.h>
			
 
				+#include <sys/user.h>
			
 
				+
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    struct kinfo_proc info;
			
 
				+    size_t infolen = sizeof(info);
			
 
				+    int mib[4];
			
 
				+    mib[0] = CTL_KERN;
			
 
				+    mib[1] = KERN_PROC;
			
 
				+    mib[2] = KERN_PROC_PID;
			
 
				+    mib[3] = getpid();
			
 
				+
			
 
				+    if (sysctl(mib, 4, &info, &infolen, NULL, 0) == 0)
			
 
				+#if defined(__FreeBSD__)
			
 
				+        return (size_t)info.ki_rssize * getpagesize();
			
 
				+#else
			
 
				+        return (size_t)info.kp_vm_rssize * getpagesize();
			
 
				+#endif
			
 
				+
			
 
				+    return 0L;
			
 
				+}
			
 
				+#elif defined(__NetBSD__)
			
 
				+#include <sys/types.h>
			
 
				+#include <sys/sysctl.h>
			
 
				+
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    struct kinfo_proc2 info;
			
 
				+    size_t infolen = sizeof(info);
			
 
				+    int mib[6];
			
 
				+    mib[0] = CTL_KERN;
			
 
				+    mib[1] = KERN_PROC;
			
 
				+    mib[2] = KERN_PROC_PID;
			
 
				+    mib[3] = getpid();
			
 
				+    mib[4] = sizeof(info);
			
 
				+    mib[5] = 1;
			
 
				+    if (sysctl(mib, 4, &info, &infolen, NULL, 0) == 0)
			
 
				+        return (size_t)info.p_vm_rssize * getpagesize();
			
 
				+
			
 
				+    return 0L;
			
 
				+}
			
 
				+#elif defined(HAVE_PSINFO)
			
 
				+#include <unistd.h>
			
 
				+#include <sys/procfs.h>
			
 
				+#include <fcntl.h>
			
 
				+
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    struct prpsinfo info;
			
 
				+    char filename[256];
			
 
				+    int fd;
			
 
				+
			
 
				+    snprintf(filename,256,"/proc/%ld/psinfo",(long) getpid());
			
 
				+
			
 
				+    if ((fd = open(filename,O_RDONLY)) == -1) return 0;
			
 
				+    if (ioctl(fd, PIOCPSINFO, &info) == -1) {
			
 
				+        close(fd);
			
 
				+	return 0;
			
 
				+    }
			
 
				+
			
 
				+    close(fd);
			
 
				+    return info.pr_rssize;
			
 
				+}
			
 
				+#else
			
 
				+size_t zmalloc_get_rss(void) {
			
 
				+    /* If we can't get the RSS in an OS-specific way for this system just
			
 
				+     * return the memory usage we estimated in zmalloc()..
			
 
				+     *
			
 
				+     * Fragmentation will appear to be always 1 (no fragmentation)
			
 
				+     * of course... */
			
 
				+    return zmalloc_used_memory();
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+#if defined(USE_JEMALLOC)
			
 
				+
			
 
				+int zmalloc_get_allocator_info(size_t *allocated,
			
 
				+                               size_t *active,
			
 
				+                               size_t *resident) {
			
 
				+    uint64_t epoch = 1;
			
 
				+    size_t sz;
			
 
				+    *allocated = *resident = *active = 0;
			
 
				+    /* Update the statistics cached by mallctl. */
			
 
				+    sz = sizeof(epoch);
			
 
				+    je_mallctl("epoch", &epoch, &sz, &epoch, sz);
			
 
				+    sz = sizeof(size_t);
			
 
				+    /* Unlike RSS, this does not include RSS from shared libraries and other non
			
 
				+     * heap mappings. */
			
 
				+    je_mallctl("stats.resident", resident, &sz, NULL, 0);
			
 
				+    /* Unlike resident, this doesn't not include the pages jemalloc reserves
			
 
				+     * for re-use (purge will clean that). */
			
 
				+    je_mallctl("stats.active", active, &sz, NULL, 0);
			
 
				+    /* Unlike zmalloc_used_memory, this matches the stats.resident by taking
			
 
				+     * into account all allocations done by this process (not only zmalloc). */
			
 
				+    je_mallctl("stats.allocated", allocated, &sz, NULL, 0);
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+void set_jemalloc_bg_thread(int enable) {
			
 
				+    /* let jemalloc do purging asynchronously, required when there's no traffic 
			
 
				+     * after flushdb */
			
 
				+    char val = !!enable;
			
 
				+    je_mallctl("background_thread", NULL, 0, &val, 1);
			
 
				+}
			
 
				+
			
 
				+int jemalloc_purge() {
			
 
				+    /* return all unused (reserved) pages to the OS */
			
 
				+    char tmp[32];
			
 
				+    unsigned narenas = 0;
			
 
				+    size_t sz = sizeof(unsigned);
			
 
				+    if (!je_mallctl("arenas.narenas", &narenas, &sz, NULL, 0)) {
			
 
				+        sprintf(tmp, "arena.%d.purge", narenas);
			
 
				+        if (!je_mallctl(tmp, NULL, 0, NULL, 0))
			
 
				+            return 0;
			
 
				+    }
			
 
				+    return -1;
			
 
				+}
			
 
				+
			
 
				+#else
			
 
				+
			
 
				+int zmalloc_get_allocator_info(size_t *allocated,
			
 
				+                               size_t *active,
			
 
				+                               size_t *resident) {
			
 
				+    *allocated = *resident = *active = 0;
			
 
				+    return 1;
			
 
				+}
			
 
				+
			
 
				+void set_jemalloc_bg_thread(int enable) {
			
 
				+    ((void)(enable));
			
 
				+}
			
 
				+
			
 
				+int jemalloc_purge() {
			
 
				+    return 0;
			
 
				+}
			
 
				+
			
 
				+#endif
			
 
				+
			
 
				+#if defined(__APPLE__)
			
 
				+/* For proc_pidinfo() used later in zmalloc_get_smap_bytes_by_field().
			
 
				+ * Note that this file cannot be included in zmalloc.h because it includes
			
 
				+ * a Darwin queue.h file where there is a "LIST_HEAD" macro (!) defined
			
 
				+ * conficting with Redis user code. */
			
 
				+#include <libproc.h>
			
 
				+#endif
			
 
				+
			
 
				+/* Get the sum of the specified field (converted form kb to bytes) in
			
 
				+ * /proc/self/smaps. The field must be specified with trailing ":" as it
			
 
				+ * apperas in the smaps output.
			
 
				+ *
			
 
				+ * If a pid is specified, the information is extracted for such a pid,
			
 
				+ * otherwise if pid is -1 the information is reported is about the
			
 
				+ * current process.
			
 
				+ *
			
 
				+ * Example: zmalloc_get_smap_bytes_by_field("Rss:",-1);
			
 
				+ */
			
 
				+#if defined(HAVE_PROC_SMAPS)
			
 
				+size_t zmalloc_get_smap_bytes_by_field(char *field, long pid) {
			
 
				+    char line[1024];
			
 
				+    size_t bytes = 0;
			
 
				+    int flen = strlen(field);
			
 
				+    FILE *fp;
			
 
				+
			
 
				+    if (pid == -1) {
			
 
				+        fp = fopen("/proc/self/smaps","r");
			
 
				+    } else {
			
 
				+        char filename[128];
			
 
				+        snprintf(filename,sizeof(filename),"/proc/%ld/smaps",pid);
			
 
				+        fp = fopen(filename,"r");
			
 
				+    }
			
 
				+
			
 
				+    if (!fp) return 0;
			
 
				+    while(fgets(line,sizeof(line),fp) != NULL) {
			
 
				+        if (strncmp(line,field,flen) == 0) {
			
 
				+            char *p = strchr(line,'k');
			
 
				+            if (p) {
			
 
				+                *p = '\0';
			
 
				+                bytes += strtol(line+flen,NULL,10) * 1024;
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    fclose(fp);
			
 
				+    return bytes;
			
 
				+}
			
 
				+#else
			
 
				+/* Get sum of the specified field from libproc api call.
			
 
				+ * As there are per page value basis we need to convert
			
 
				+ * them accordingly.
			
 
				+ *
			
 
				+ * Note that AnonHugePages is a no-op as THP feature
			
 
				+ * is not supported in this platform
			
 
				+ */
			
 
				+size_t zmalloc_get_smap_bytes_by_field(char *field, long pid) {
			
 
				+#if defined(__APPLE__)
			
 
				+    struct proc_regioninfo pri;
			
 
				+    if (pid == -1) pid = getpid();
			
 
				+    if (proc_pidinfo(pid, PROC_PIDREGIONINFO, 0, &pri,
			
 
				+                     PROC_PIDREGIONINFO_SIZE) == PROC_PIDREGIONINFO_SIZE)
			
 
				+    {
			
 
				+        int pagesize = getpagesize();
			
 
				+        if (!strcmp(field, "Private_Dirty:")) {
			
 
				+            return (size_t)pri.pri_pages_dirtied * pagesize;
			
 
				+        } else if (!strcmp(field, "Rss:")) {
			
 
				+            return (size_t)pri.pri_pages_resident * pagesize;
			
 
				+        } else if (!strcmp(field, "AnonHugePages:")) {
			
 
				+            return 0;
			
 
				+        }
			
 
				+    }
			
 
				+    return 0;
			
 
				+#endif
			
 
				+    ((void) field);
			
 
				+    ((void) pid);
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
 
				+
			
 
				+/* Return the total number bytes in pages marked as Private Dirty.
			
 
				+ *
			
 
				+ * Note: depending on the platform and memory footprint of the process, this
			
 
				+ * call can be slow, exceeding 1000ms!
			
 
				+ */
			
 
				+size_t zmalloc_get_private_dirty(long pid) {
			
 
				+    return zmalloc_get_smap_bytes_by_field("Private_Dirty:",pid);
			
 
				+}
			
 
				+
			
 
				+/* Returns the size of physical memory (RAM) in bytes.
			
 
				+ * It looks ugly, but this is the cleanest way to achieve cross platform results.
			
 
				+ * Cleaned up from:
			
 
				+ *
			
 
				+ * http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system
			
 
				+ *
			
 
				+ * Note that this function:
			
 
				+ * 1) Was released under the following CC attribution license:
			
 
				+ *    http://creativecommons.org/licenses/by/3.0/deed.en_US.
			
 
				+ * 2) Was originally implemented by David Robert Nadeau.
			
 
				+ * 3) Was modified for Redis by Matt Stancliff.
			
 
				+ * 4) This note exists in order to comply with the original license.
			
 
				+ */
			
 
				+size_t zmalloc_get_memory_size(void) {
			
 
				+#if defined(__unix__) || defined(__unix) || defined(unix) || \
			
 
				+    (defined(__APPLE__) && defined(__MACH__))
			
 
				+#if defined(CTL_HW) && (defined(HW_MEMSIZE) || defined(HW_PHYSMEM64))
			
 
				+    int mib[2];
			
 
				+    mib[0] = CTL_HW;
			
 
				+#if defined(HW_MEMSIZE)
			
 
				+    mib[1] = HW_MEMSIZE;            /* OSX. --------------------- */
			
 
				+#elif defined(HW_PHYSMEM64)
			
 
				+    mib[1] = HW_PHYSMEM64;          /* NetBSD, OpenBSD. --------- */
			
 
				+#endif
			
 
				+    int64_t size = 0;               /* 64-bit */
			
 
				+    size_t len = sizeof(size);
			
 
				+    if (sysctl( mib, 2, &size, &len, NULL, 0) == 0)
			
 
				+        return (size_t)size;
			
 
				+    return 0L;          /* Failed? */
			
 
				+
			
 
				+#elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
			
 
				+    /* FreeBSD, Linux, OpenBSD, and Solaris. -------------------- */
			
 
				+    return (size_t)sysconf(_SC_PHYS_PAGES) * (size_t)sysconf(_SC_PAGESIZE);
			
 
				+
			
 
				+#elif defined(CTL_HW) && (defined(HW_PHYSMEM) || defined(HW_REALMEM))
			
 
				+    /* DragonFly BSD, FreeBSD, NetBSD, OpenBSD, and OSX. -------- */
			
 
				+    int mib[2];
			
 
				+    mib[0] = CTL_HW;
			
 
				+#if defined(HW_REALMEM)
			
 
				+    mib[1] = HW_REALMEM;        /* FreeBSD. ----------------- */
			
 
				+#elif defined(HW_PHYSMEM)
			
 
				+    mib[1] = HW_PHYSMEM;        /* Others. ------------------ */
			
 
				+#endif
			
 
				+    unsigned int size = 0;      /* 32-bit */
			
 
				+    size_t len = sizeof(size);
			
 
				+    if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
			
 
				+        return (size_t)size;
			
 
				+    return 0L;          /* Failed? */
			
 
				+#else
			
 
				+    return 0L;          /* Unknown method to get the data. */
			
 
				+#endif
			
 
				+#else
			
 
				+    return 0L;          /* Unknown OS. */
			
 
				+#endif
			
 
				+}
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+#define UNUSED(x) ((void)(x))
			
 
				+int zmalloc_test(int argc, char **argv, int flags) {
			
 
				+    void *ptr;
			
 
				+
			
 
				+    UNUSED(argc);
			
 
				+    UNUSED(argv);
			
 
				+    UNUSED(flags);
			
 
				+    printf("Malloc prefix size: %d\n", (int) PREFIX_SIZE);
			
 
				+    printf("Initial used memory: %zu\n", zmalloc_used_memory());
			
 
				+    ptr = zmalloc(123);
			
 
				+    printf("Allocated 123 bytes; used: %zu\n", zmalloc_used_memory());
			
 
				+    ptr = zrealloc(ptr, 456);
			
 
				+    printf("Reallocated to 456 bytes; used: %zu\n", zmalloc_used_memory());
			
 
				+    zfree(ptr);
			
 
				+    printf("Freed pointer; used: %zu\n", zmalloc_used_memory());
			
 
				+    return 0;
			
 
				+}
			
 
				+#endif
			
--- a/src/zmalloc.h
+++ b/src/zmalloc.h
@@ -0,0 +1,142 @@
 
				+/* zmalloc - total amount of allocated memory aware version of malloc()
			
 
				+ *
			
 
				+ * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez 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.
			
 
				+ */
			
 
				+
			
 
				+#ifndef __ZMALLOC_H
			
 
				+#define __ZMALLOC_H
			
 
				+
			
 
				+/* Double expansion needed for stringification of macro values. */
			
 
				+#define __xstr(s) __str(s)
			
 
				+#define __str(s) #s
			
 
				+
			
 
				+#if defined(USE_TCMALLOC)
			
 
				+#define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR))
			
 
				+#include <google/tcmalloc.h>
			
 
				+#if (TC_VERSION_MAJOR == 1 && TC_VERSION_MINOR >= 6) || (TC_VERSION_MAJOR > 1)
			
 
				+#define HAVE_MALLOC_SIZE 1
			
 
				+#define zmalloc_size(p) tc_malloc_size(p)
			
 
				+#else
			
 
				+#error "Newer version of tcmalloc required"
			
 
				+#endif
			
 
				+
			
 
				+#elif defined(USE_JEMALLOC)
			
 
				+#define ZMALLOC_LIB ("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX))
			
 
				+#include <jemalloc/jemalloc.h>
			
 
				+#if (JEMALLOC_VERSION_MAJOR == 2 && JEMALLOC_VERSION_MINOR >= 1) || (JEMALLOC_VERSION_MAJOR > 2)
			
 
				+#define HAVE_MALLOC_SIZE 1
			
 
				+#define zmalloc_size(p) je_malloc_usable_size(p)
			
 
				+#else
			
 
				+#error "Newer version of jemalloc required"
			
 
				+#endif
			
 
				+
			
 
				+#elif defined(__APPLE__)
			
 
				+#include <malloc/malloc.h>
			
 
				+#define HAVE_MALLOC_SIZE 1
			
 
				+#define zmalloc_size(p) malloc_size(p)
			
 
				+#endif
			
 
				+
			
 
				+/* On native libc implementations, we should still do our best to provide a
			
 
				+ * HAVE_MALLOC_SIZE capability. This can be set explicitly as well:
			
 
				+ *
			
 
				+ * NO_MALLOC_USABLE_SIZE disables it on all platforms, even if they are
			
 
				+ *      known to support it.
			
 
				+ * USE_MALLOC_USABLE_SIZE forces use of malloc_usable_size() regardless
			
 
				+ *      of platform.
			
 
				+ */
			
 
				+#ifndef ZMALLOC_LIB
			
 
				+#define ZMALLOC_LIB "libc"
			
 
				+
			
 
				+#if !defined(NO_MALLOC_USABLE_SIZE) && \
			
 
				+    (defined(__GLIBC__) || defined(__FreeBSD__) || \
			
 
				+     defined(USE_MALLOC_USABLE_SIZE))
			
 
				+
			
 
				+/* Includes for malloc_usable_size() */
			
 
				+#ifdef __FreeBSD__
			
 
				+#include <malloc_np.h>
			
 
				+#else
			
 
				+#include <malloc.h>
			
 
				+#endif
			
 
				+
			
 
				+#define HAVE_MALLOC_SIZE 1
			
 
				+#define zmalloc_size(p) malloc_usable_size(p)
			
 
				+
			
 
				+#endif
			
 
				+#endif
			
 
				+
			
 
				+/* We can enable the Redis defrag capabilities only if we are using Jemalloc
			
 
				+ * and the version used is our special version modified for Redis having
			
 
				+ * the ability to return per-allocation fragmentation hints. */
			
 
				+#if defined(USE_JEMALLOC) && defined(JEMALLOC_FRAG_HINT)
			
 
				+#define HAVE_DEFRAG
			
 
				+#endif
			
 
				+
			
 
				+void *zmalloc(size_t size);
			
 
				+void *zcalloc(size_t size);
			
 
				+void *zrealloc(void *ptr, size_t size);
			
 
				+void *ztrymalloc(size_t size);
			
 
				+void *ztrycalloc(size_t size);
			
 
				+void *ztryrealloc(void *ptr, size_t size);
			
 
				+void zfree(void *ptr);
			
 
				+void *zmalloc_usable(size_t size, size_t *usable);
			
 
				+void *zcalloc_usable(size_t size, size_t *usable);
			
 
				+void *zrealloc_usable(void *ptr, size_t size, size_t *usable);
			
 
				+void *ztrymalloc_usable(size_t size, size_t *usable);
			
 
				+void *ztrycalloc_usable(size_t size, size_t *usable);
			
 
				+void *ztryrealloc_usable(void *ptr, size_t size, size_t *usable);
			
 
				+void zfree_usable(void *ptr, size_t *usable);
			
 
				+char *zstrdup(const char *s);
			
 
				+size_t zmalloc_used_memory(void);
			
 
				+void zmalloc_set_oom_handler(void (*oom_handler)(size_t));
			
 
				+size_t zmalloc_get_rss(void);
			
 
				+int zmalloc_get_allocator_info(size_t *allocated, size_t *active, size_t *resident);
			
 
				+void set_jemalloc_bg_thread(int enable);
			
 
				+int jemalloc_purge();
			
 
				+size_t zmalloc_get_private_dirty(long pid);
			
 
				+size_t zmalloc_get_smap_bytes_by_field(char *field, long pid);
			
 
				+size_t zmalloc_get_memory_size(void);
			
 
				+void zlibc_free(void *ptr);
			
 
				+void zmadvise_dontneed(void *ptr);
			
 
				+
			
 
				+#ifdef HAVE_DEFRAG
			
 
				+void zfree_no_tcache(void *ptr);
			
 
				+void *zmalloc_no_tcache(size_t size);
			
 
				+#endif
			
 
				+
			
 
				+#ifndef HAVE_MALLOC_SIZE
			
 
				+size_t zmalloc_size(void *ptr);
			
 
				+size_t zmalloc_usable_size(void *ptr);
			
 
				+#else
			
 
				+#define zmalloc_usable_size(p) zmalloc_size(p)
			
 
				+#endif
			
 
				+
			
 
				+#ifdef REDIS_TEST
			
 
				+int zmalloc_test(int argc, char **argv, int flags);
			
 
				+#endif
			
 
				+
			
 
				+#endif /* __ZMALLOC_H */
			
--- a/third/.gitignore
+++ b/third/.gitignore
@@ -0,0 +1,5 @@
 
				+cJSON/
			
 
				+hiredis/
			
 
				+llhttp/
			
 
				+natsc/
			
 
				+tomlc99/
			
--- a/third/README.md
+++ b/third/README.md
@@ -0,0 +1,17 @@
 
				+## Third Party Libraries
			
 
				+
			
 
				+- cJSON
			
 
				+- hiredis
			
 
				+- llhttp
			
 
				+- natsc
			
 
				+- tomlc99
			
 
				+
			
 
				+## TODO
			
 
				+
			
 
				+- Add `libbeanstalkd`
			
 
				+- Add `libmariadb`
			
 
				+- Add `pgsql`
			
 
				+- Add `lua51`
			
 
				+- Add `luajit2.1`
			
 
				+- Add `protobuf`
			
 
				+- Add `libuv`
			
--- a/third/cJSON.tar.gz
+++ b/third/cJSON.tar.gz
--- a/third/hiredis.tar.gz
+++ b/third/hiredis.tar.gz
--- a/third/llhttp.tar.gz
+++ b/third/llhttp.tar.gz
--- a/third/natsc.tar.gz
+++ b/third/natsc.tar.gz
--- a/third/tomlc99.tar.gz
+++ b/third/tomlc99.tar.gz