diff --git a/include/proto/pattern.h b/include/proto/pattern.h
index 9b7c40e..830630b 100644
--- a/include/proto/pattern.h
+++ b/include/proto/pattern.h
@@ -40,7 +40,7 @@
  * The function returns 1 if the processing is ok, return 0
  * if the parser fails, with <err> message filled.
  */
-int pattern_register(struct pattern_head *head, char *reference, int refflags, const char *arg, struct sample_storage *smp, int patflags, char **err);
+int pattern_register(struct pattern_head *head, int unique_id, int refflags, const char *arg, struct sample_storage *smp, int patflags, char **err);
 void pattern_finalize_config(void);
 
 /* return the PAT_MATCH_* index for match name "name", or < 0 if not found */
@@ -197,7 +197,9 @@
  * pattern_ref manipulation.
  */
 struct pat_ref *pat_ref_lookup(const char *reference);
+struct pat_ref *pat_ref_lookupid(int unique_id);
 struct pat_ref *pat_ref_new(const char *reference, unsigned int flags);
+struct pat_ref *pat_ref_newid(int unique_id, unsigned int flags);
 int pat_ref_append(struct pat_ref *ref, char *pattern, char *sample, int line);
 int pat_ref_add(struct pat_ref *ref, const char *pattern, const char *sample, char **err);
 int pat_ref_set(struct pat_ref *ref, const char *pattern, const char *sample);
diff --git a/include/types/pattern.h b/include/types/pattern.h
index dfee109..156e57b 100644
--- a/include/types/pattern.h
+++ b/include/types/pattern.h
@@ -97,6 +97,7 @@
 	struct list list; /* Used to chain refs. */
 	unsigned int flags; /* flags PAT_REF_*. */
 	char *reference; /* The reference name. */
+	int unique_id; /* Each pattern reference have unique id. */
 	struct list head; /* The head of the list of struct pat_ref_elt. */
 	struct list pat; /* The head of the list of struct pattern_expr. */
 };
diff --git a/src/acl.c b/src/acl.c
index d4d1cfb..4e33213 100644
--- a/src/acl.c
+++ b/src/acl.c
@@ -598,7 +598,7 @@
 			}
 		}
 
-		if (!pattern_register(&expr->pat, NULL, PAT_REF_ACL, arg, NULL, patflags, err))
+		if (!pattern_register(&expr->pat, -1, PAT_REF_ACL, arg, NULL, patflags, err))
 			goto out_free_expr;
 		args++;
 	}
diff --git a/src/dumpstats.c b/src/dumpstats.c
index 57a9fc5..f6768c9 100644
--- a/src/dumpstats.c
+++ b/src/dumpstats.c
@@ -982,6 +982,27 @@
 	}
 }
 
+static inline
+struct pat_ref *pat_ref_lookup_ref(const char *reference)
+{
+	int id;
+	char *error;
+
+	/* If the reference starts by a '#', this is numeric id. */
+	if (reference[0] == '#') {
+		/* Try to convert the numeric id. If the conversion fails, the lookup fails. */
+		id = strtol(reference + 1, &error, 10);
+		if (*error != '\0')
+			return NULL;
+
+		/* Perform the unique id lookup. */
+		return pat_ref_lookupid(id);
+	}
+
+	/* Perform the string lookup. */
+	return pat_ref_lookup(reference);
+}
+
 /* This function is used with map and acl management. It permits to browse
  * each reference.
  */
@@ -1123,13 +1144,13 @@
 			}
 
 			/* lookup into the refs and check the map flag */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1222,13 +1243,13 @@
 			}
 
 			/* lookup into the refs and check the map flag */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1293,12 +1314,12 @@
 			}
 
 			/* lookup into the maps */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1605,9 +1626,9 @@
 			}
 
 			/* Lookup the reference in the maps. */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
-				appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1872,10 +1893,10 @@
 			}
 
 			/* Lookup the reference in the maps. */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
-				appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1929,12 +1950,12 @@
 			}
 
 			/* Lookup for the reference. */
-			appctx->ctx.map.ref = pat_ref_lookup(args[2]);
+			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -4736,6 +4757,14 @@
 
 	switch (appctx->st2) {
 	case STAT_ST_INIT:
+		/* Display the column headers. If the message cannot be sent,
+		 * quit the fucntion with returning 0. The function is called
+		 * later and restart at the state "STAT_ST_INIT".
+		 */
+		chunk_reset(&trash);
+		chunk_appendf(&trash, "# id (name)\n");
+		if (bi_putchk(si->ib, &trash) == -1)
+			return 0;
 
 		/* Now, we start the browsing of the references lists.
 		 * Note that the following call to LIST_ELEM return bad pointer. The only
@@ -4750,24 +4779,23 @@
 
 	case STAT_ST_LIST:
 		while (appctx->ctx.map.ref) {
-
 			chunk_reset(&trash);
 
 			/* Build messages. If the reference is used by another category than
 			 * the listed categorie, display the information in the massage.
 			 */
-			if ((appctx->ctx.map.display_flags & PAT_REF_MAP) &&
-			    (appctx->ctx.map.ref->flags & PAT_REF_ACL)) {
-				chunk_appendf(&trash, "%s (also used by an ACL)\n",
-				              appctx->ctx.map.ref->reference);
+			chunk_appendf(&trash, "%d (%s)", appctx->ctx.map.ref->unique_id,
+			              appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "");
+
+			if (appctx->ctx.map.display_flags & PAT_REF_MAP) {
+				if (appctx->ctx.map.ref->flags & PAT_REF_ACL)
+					chunk_appendf(&trash, " - also used by an ACL");
 			}
-			else if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
-			         (appctx->ctx.map.ref->flags & PAT_REF_MAP)) {
-				chunk_appendf(&trash, "%s (also used by a map)\n",
-				              appctx->ctx.map.ref->reference);
+			else {
+				if (appctx->ctx.map.ref->flags & PAT_REF_MAP)
+					chunk_appendf(&trash, " - also used by a map");
 			}
-			else
-				chunk_appendf(&trash, "%s\n", appctx->ctx.map.ref->reference);
+			chunk_appendf(&trash, "\n");
 
 			if (bi_putchk(si->ib, &trash) == -1) {
 				/* let's try again later from this session. We add ourselves into
diff --git a/src/haproxy.c b/src/haproxy.c
index 2b83c62..fb8c8a1 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -89,6 +89,7 @@
 #include <proto/hdr_idx.h>
 #include <proto/listener.h>
 #include <proto/log.h>
+#include <proto/pattern.h>
 #include <proto/protocol.h>
 #include <proto/proto_http.h>
 #include <proto/proxy.h>
@@ -693,6 +694,8 @@
 			exit(1);
 	}
 
+	pattern_finalize_config();
+
 	err_code |= check_config_validity();
 	if (err_code & (ERR_ABORT|ERR_FATAL)) {
 		Alert("Fatal errors found in configuration.\n");
diff --git a/src/pattern.c b/src/pattern.c
index e35a59d..8625048 100644
--- a/src/pattern.c
+++ b/src/pattern.c
@@ -1562,6 +1562,23 @@
  * value as string form.
  *
  * This is used with modifiable ACL and MAPS
+ *
+ * The pattern reference are stored with two identifiers: the unique_id and
+ * the reference.
+ *
+ * The reference identify a file. Each file with the same name point to the
+ * same reference. We can register many times one file. If the file is modified,
+ * all his dependencies are also modified. The reference can be used with map or
+ * acl.
+ *
+ * The unique_id identify inline acl. The unique id is unique for each acl.
+ * You cannot force the same id in the configuration file, because this repoort
+ * an error.
+ *
+ * A particular case appears if the filename is a number. In this case, the
+ * unique_id is set with the number represented by the filename and the
+ * reference is also set. This method prevent double unique_id.
+ *
  */
 
 /* This function lookup for reference. If the reference is found, they return
@@ -1572,11 +1589,24 @@
 	struct pat_ref *ref;
 
 	list_for_each_entry(ref, &pattern_reference, list)
-		if (strcmp(reference, ref->reference) == 0)
+		if (ref->reference && strcmp(reference, ref->reference) == 0)
 			return ref;
 	return NULL;
 }
 
+/* This function lookup for unique id. If the reference is found, they return
+ * pointer to the struct pat_ref, else return NULL.
+ */
+struct pat_ref *pat_ref_lookupid(int unique_id)
+{
+	struct pat_ref *ref;
+
+	list_for_each_entry(ref, &pattern_reference, list)
+		if (ref->unique_id == unique_id)
+			return ref;
+	return NULL;
+}
+
 /* This function remove all pattern match <key> from the the reference
  * and from each expr member of the reference. This fucntion returns 1
  * if the deletion is done and return 0 is the entry is not found.
@@ -1662,7 +1692,35 @@
 		return NULL;
 	}
 
+	ref->flags = flags;
+	ref->unique_id = -1;
+
+	LIST_INIT(&ref->head);
+	LIST_INIT(&ref->pat);
+
+	LIST_ADDQ(&pattern_reference, &ref->list);
+
+	return ref;
+}
+
+/* This function create new reference. <unique_id> is the unique id. If
+ * the value of <unique_id> is -1, the unique id is calculated later.
+ * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
+ * be unique. The user must check the reference with "pat_ref_lookup()"
+ * or pat_ref_lookupid before calling this function. If the function
+ * fail, it return NULL, else return new struct pat_ref.
+ */
+struct pat_ref *pat_ref_newid(int unique_id, unsigned int flags)
+{
+	struct pat_ref *ref;
+
+	ref = malloc(sizeof(*ref));
+	if (!ref)
+		return NULL;
+
+	ref->reference = NULL;
 	ref->flags = flags;
+	ref->unique_id = unique_id;
 	LIST_INIT(&ref->head);
 	LIST_INIT(&ref->pat);
 
@@ -1961,7 +2019,7 @@
  * return -2 if out of memory
  */
 int pattern_register(struct pattern_head *head,
-                     char *reference, int refflags,
+                     int unique_id, int refflags,
                      const char *arg,
                      struct sample_storage *smp,
                      int patflags, char **err)
@@ -1969,30 +2027,27 @@
 	struct pattern_expr *expr;
 	struct pat_ref *ref;
 
-	/* If reference is set, look up for existing reference. If the
-	 * reference is not found, create it.
-	 */
-	if (reference) {
-		ref = pat_ref_lookup(reference);
-		if (!ref) {
-			ref = pat_ref_new(reference, refflags);
-			if (!ref) {
-				memprintf(err, "out of memory");
-				return 0;
-			}
+	/* Look if the unique id already exists. If exists, abort the acl creation. */
+	if (unique_id >= 0) {
+		ref = pat_ref_lookupid(unique_id);
+		if (ref) {
+			memprintf(err, "The unique id \"%d\" is already used.", unique_id);
+			return 0;
 		}
 	}
-	else
-		ref = NULL;
 
-	/* look for reference or create it */
-	expr = pattern_lookup_expr(head, ref);
-	if (!expr) {
-		expr = pattern_new_expr(head, ref, err);
-		if (!expr)
-			return 0;
+	/* Create new reference. */
+	ref = pat_ref_newid(unique_id, refflags);
+	if (!ref) {
+		memprintf(err, "out of memory");
+		return 0;
 	}
 
+	/* create new pattern_expr. */
+	expr = pattern_new_expr(head, ref, err);
+	if (!expr)
+		return 0;
+
 	/* Index value. */
 	return pattern_add(expr, arg, smp, patflags, err);
 }
@@ -2060,10 +2115,10 @@
 	struct pat_ref *ref;
 	struct pattern_expr *expr;
 
-	/* Look for existing reference. If the reference doesn't exists,
-	 * create it and load file.
-	 */
+	/* Lookup for the existing reference. */
 	ref = pat_ref_lookup(filename);
+
+	/* If the reference doesn't exists, create it and load associated file. */
 	if (!ref) {
 		ref = pat_ref_new(filename, refflags);
 		if (!ref) {
@@ -2170,3 +2225,50 @@
 	expr->pat_head->delete(expr, &pattern);
 	return 1;
 }
+
+/* This function finalize the configuration parsing. Its set all the
+ * automatic ids
+ */
+void pattern_finalize_config(void)
+{
+	int i = 0;
+	struct pat_ref *ref, *ref2, *ref3;
+	struct list pr = LIST_HEAD_INIT(pr);
+
+	list_for_each_entry(ref, &pattern_reference, list) {
+		if (ref->unique_id == -1) {
+			/* Look for the first free id. */
+			while (1) {
+				list_for_each_entry(ref2, &pattern_reference, list) {
+					if (ref2->unique_id == i) {
+						i++;
+						break;
+					}
+				}
+				if (&ref2->list == &pattern_reference);
+					break;
+			}
+
+			/* Uses the unique id and increment it for the next entry. */
+			ref->unique_id = i;
+			i++;
+		}
+	}
+
+	/* This sort the reference list by id. */
+	list_for_each_entry_safe(ref, ref2, &pattern_reference, list) {
+		LIST_DEL(&ref->list);
+		list_for_each_entry(ref3, &pr, list) {
+			if (ref->unique_id < ref3->unique_id) {
+				LIST_ADDQ(&ref3->list, &ref->list);
+				break;
+			}
+		}
+		if (&ref3->list == &pr)
+			LIST_ADDQ(&pr, &ref->list);
+	}
+
+	/* swap root */
+	LIST_ADD(&pr, &pattern_reference);
+	LIST_DEL(&pr);
+}