Merge lp:~oif-team/grail/trunk.glue into lp:grail

[Henrik Rydberg]

This branch is a rebase of grail2.next, with one important change; it uses EXPECT_DRAG to trigger drag events, but it uses CENTER to report drag events. This presents a simple and accurate solution to the drag problem, where

1. All applications can rely on the drag events not to be lost.

2. All applications treat rotation around a finger as rotation, even if not listened for.

3. Apps not using rotation behaves the same as before, but pure rotation gestures will rightfully not be detected as drag.

4. Apps wanting more accurate/detailed drag/rotation behavior should use gesture frames directly instead.

This branch has been tested with unity on an XT2, which good feel. It seems the solution does not have to be more complicated than this.

[Henrik Rydberg (rydberg)]

Two more patches, further enhancing the unity gesture experience. The first one fixes a problem with the rewritten recognizer, and the second finally gives very clear and distinct recognition of all of drag, pinch and rotate.

Tested in unity and eog. Rotating the picture is effortless, with no side effects. Pinching to zoom is effortless (although eog seems to have some problems there). Dragging with one or two fingers (touchscreen) works just fine, no side effects.

IMHO, this is the best linux gesture experience I have had so far.

Enjoy,
Henrik

[Henrik Rydberg (rydberg)]

Upon request, added some more explanation of the structs used in gru and gin.

Also, this merge is against trunk, but 2.x would be fine too, as discussed (they are equal atm).

[Henrik Rydberg (rydberg)]

The branch has been updated with a more logical patch sequence, some bug fixes, and more importantly, with a gesture test suite, framing the critical modifications to the recognizer. The tests are real-time gesture recognition checks, are run using make check, and take about a minute to perform (with serial execution). At the introduction of the suite, several tests fail intentionally, because of the inability of the current grail to separate drag and rotation gestures. After the switch to grail2 and tuning, all tests pass. So, from the point of view of the tests, this branch presents a major improvement over grail1. Manual tests using unity, evince and eog point at the same thing.

I think this is it, guys. Enjoy!

[Jussi Pakkanen (jpakkane)]

I created a new branch of this which merges trunk:

https://code.launchpad.net/~jpakkane/utouch-grail/glue-work

It has some conflicts, mainly due to Chase's removal of center of start frame. I got it to compile but some tests fail. I'll look into it next. Also there probably some latent issues there.

[Daniel d'Andrada (dandrader)]

It's been open for almost an year now. Thus closing it to help "keep the desk clean".
Please reopen if this merge is still relevant and wanted.

Unmerged revisions

166. By Henrik Rydberg on 2011-05-05

Add XI2 support to grail-gesture

Use the grail2 API to implement the event loop using XI events.

Signed-off-by: Henrik Rydberg <email address hidden>

165. By Henrik Rydberg on 2011-05-05

Move grail engine into pump function

Move the grail engine into the pump function, and make init/destroy
equivalent to open/close, if gesture callbacks are defined. This way,
pulling can be replaced by pumping. This concludes the grail2 API.

Signed-off-by: Henrik Rydberg <email address hidden>

164. By Henrik Rydberg on 2011-05-05

Trim the pinch and rotate bars

Gesture testing reveals a tendency to favor rotate over pinch for
small rotations. This patch lowers the pinch bar and increase the
rotate bar, leading to a more accurate recognition of both pinch
and rotate.

With this patch, all gesture tests are passing.

Signed-off-by: Henrik Rydberg <email address hidden>

163. By Henrik Rydberg on 2011-05-05

Lower priority of pinch

When performing a rotate gesture, it is very common to also trigger
the pinch primitive. Conversely, during a pinch, rotate or drag are
seldom triggered. This patch lowers the priority of pinch gestures in
favor of rotate and drag, leading to a distinct recognition of all
three basic gestures.

Signed-off-by: Henrik Rydberg <email address hidden>

162. By Henrik Rydberg on 2011-05-05

Replace recognizer with gesture frames

This patch replaces the internal recognizer with one based on the
gesture frame elements. Fully functional, and equivalent to the
previous implementation.

With this patch, the pinch tests are no longer failing, while the drag
tests still have false positives from rotation.

Signed-off-by: Henrik Rydberg <email address hidden>

161. By Henrik Rydberg on 2011-05-05

Add a gesture test suite

To ensure correctness when replacing of the internal recognizer, add a
test suite of real-time gestures. The tests take about a minute to
perform on any computer (serial mode).

Note that some of the tests are designed to fail at this stage; the
failures represent the inability of the current code to separate some
drag and rotate gestures.

Signed-off-by: Henrik Rydberg <email address hidden>

160. By Henrik Rydberg on 2011-05-05

Always output the global gesture frame

Currently, the global gesture frame is not output for one- and
two-finger gestures, but the per-contact-pair gesture elements
are used in its stead. This leads to undesired behavior when a
finger leaves the surface; it suffices to consider the start time
of a single-finger drag to see that the glue time is not respected
in that case. This patch makes sure the global gesture is always
output, such that any finger combination change leads to a restarted
gesture element.

Signed-off-by: Henrik Rydberg <email address hidden>

159. By Henrik Rydberg on 2011-05-05

Add missing grail element member documentation

The documentation of moveness in the grail_element struct got lost, fixed
with this patch.

Signed-off-by: Henrik Rydberg <email address hidden>

158. By Henrik Rydberg on 2011-05-05

Add inner product to grail bits api

Move the implementation of inner product to a more public place.

Signed-off-by: Henrik Rydberg <email address hidden>

157. By Henrik Rydberg on 2011-05-05

Deprecate open/close

Move the open/close api functions to the legacy area. No functional
changes.

Signed-off-by: Henrik Rydberg <email address hidden>

=== modified file 'include/grail-bits.h'
--- include/grail-bits.h	2011-04-28 16:53:57 +0000
+++ include/grail-bits.h	2011-05-05 13:31:23 +0000
@@ -76,6 +76,8 @@
 void GRAIL_PUBLIC grail_mask_clear_mask(grail_mask_t *a, const grail_mask_t *b,
 					int bytes);
 
+int GRAIL_PUBLIC grail_mask_inner(const grail_mask_t *a, const grail_mask_t *b,
+				  int bytes);
 int GRAIL_PUBLIC grail_mask_count(const grail_mask_t *mask, int bytes);
 int GRAIL_PUBLIC grail_mask_get_first(const grail_mask_t *mask, int bytes);
 int GRAIL_PUBLIC grail_mask_get_next(int i, const grail_mask_t *mask,

=== modified file 'include/grail.h'
--- include/grail.h	2011-04-28 16:53:57 +0000
+++ include/grail.h	2011-05-05 13:31:23 +0000
@@ -174,6 +174,7 @@
  * @drop_scale_ms: scaling expect timeout (ms)
  * @drop_angle_ms: rotation expect timeout (ms)
  * @pivot_unbound: when true, the pivot is not bound to the contact area
+ * @tap_time_ms: maximum tap time (ms)
  *
  * The parameters are used to tune the behavior of the gesture recognition.
  *
@@ -197,6 +198,7 @@
 	float drop_scale_ms;
 	float drop_angle_ms;
 	int pivot_unbound;
+	float tap_time_ms;
 };
 
 /**
@@ -238,6 +240,7 @@
  * @velocity: current center velocity (surface units per second)
  * @radius: gesture radius from center (surface units)
  * @transform: the transformation matrix of the gesture
+ * @moveness: fraction of center movement attributed to drag motion
  * @pivot: current center of rotate and scale (surface units)
  * @drag: accumulated transformation displacement (surface units)
  * @scale: accumulated scale (dimensionless)
@@ -359,21 +362,6 @@
 };
 
 /**
- * grail_open - open a grail device
- * @ge: the grail device to open
- * @fd: file descriptor of the kernel device
- *
- * Initialize the internal grail structures and configure it by reading the
- * protocol capabilities through the file descriptor.
- *
- * The callbacks, parameters and priv pointer should be set prior to this
- * call.
- *
- * Returns zero on success, negative error number otherwise.
- */
-int GRAIL_PUBLIC grail_open(struct grail *ge, int fd);
-
-/**
  * grail_idle - check state of kernel device
  * @ge: the grail device in use
  * @fd: file descriptor of the kernel device
@@ -401,16 +389,6 @@
 int GRAIL_PUBLIC grail_pull(struct grail *ge, int fd);
 
 /**
- * grail_close - close the grail device
- * @ge: the grail device to close
- * @fd: file descriptor of the kernel device
- *
- * Deallocates all memory associated with grail, and clears the grail
- * structure.
- */
-void GRAIL_PUBLIC grail_close(struct grail *ge, int fd);
-
-/**
  * grail_set_bbox - set the grail unit bounding box
  * @ge: the grail device in use
  * @min: the minimum (lower-left) corner of the bounding box
@@ -454,6 +432,23 @@
 const struct utouch_frame GRAIL_PUBLIC *
 grail_get_contact_frame(const struct grail *ge);
 
+/**
+ * grail_get_gesture_frame - get current gesture frame
+ * @ge: the grail device in use
+ *
+ * Return the gesture frame currently being processed. If called from
+ * within a gesture callback, it is guaranteed to return the frame
+ * corresponding to the gesture.
+ *
+ * The returned pointer can be NULL if no input has yet been extracted
+ * through the grail instance.
+ *
+ * The frame pointer is ABI agnostic, owned by the grail instance, and
+ * has grail scope.
+ */
+const struct grail_frame GRAIL_PUBLIC *
+grail_get_gesture_frame(const struct grail *ge);
+
 #ifndef GRAIL_NO_LEGACY_API
 
 struct grail_contact {
@@ -468,6 +463,8 @@
 	float pressure;
 };
 
+int GRAIL_PUBLIC grail_open(struct grail *ge, int fd);
+void GRAIL_PUBLIC grail_close(struct grail *ge, int fd);
 void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage);
 
 int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,

=== modified file 'include/grail.h.orig'
--- include/grail.h.orig	2011-04-28 16:53:34 +0000
+++ include/grail.h.orig	2011-05-05 13:31:23 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * Copyright (C) 2010-2011 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -26,11 +25,14 @@
 #include <linux/input.h>
 #include <grail-bits.h>
 #include <grail-types.h>
+#include <utouch/frame.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define GRAIL_VERSION           0x00011000
+
 #define DIM_GRAIL_TYPE		64
 #define DIM_GRAIL_TYPE_BYTES	((DIM_GRAIL_TYPE + 7) >> 3)
 
@@ -41,8 +43,30 @@
 #define GRAIL_STATUS_UPDATE	1
 #define GRAIL_STATUS_END	2
 
-typedef float grail_prop_t;		/* gesture properties */
-typedef __u64 grail_time_t;		/* time in milliseconds */
+#define GRAIL_EXPECT_CENTER_X	0x0001
+#define GRAIL_EXPECT_CENTER_Y	0x0002
+#define GRAIL_EXPECT_DRAG_X	0x0004
+#define GRAIL_EXPECT_DRAG_Y	0x0008
+#define GRAIL_EXPECT_SCALE	0x0010
+#define GRAIL_EXPECT_ANGLE	0x0020
+#define GRAIL_EXPECT_MASK	0x003f
+
+typedef float grail_prop_t;			/* gesture properties */
+typedef utouch_frame_time_t grail_time_t;	/* time in milliseconds */
+typedef struct grail *grail_handle;		/* the grail instance handle */
+
+/**
+ * struct grail_get_version - get grail library version
+ *
+ * Report the version of the grail library, which can be different from
+ * the value of GRAIL_VERSION in this header file.
+ *
+ * This function allows for fallback options from major interface
+ * extensions within the same ABI version. For the normal cases of ABI
+ * agnostic or backwards incompatible changes, this function is not
+ * needed.
+ */
+unsigned int GRAIL_PUBLIC grail_get_version(void);
 
 /**
  * struct grail_coord - coordinate in bounding box units
@@ -53,32 +77,63 @@
 	float x, y;
 };
 
-/**
- * struct grail_contact - MT event information in bounding box units
- * @id: Contact tracking id
- * @tool_type: Tool type (ABS_MT_TOOL_TYPE)
- * @pos: Position of contact (bbox units)
- * @touch_major: Major axis of contact shape (bbox units)
- * @touch_minor: Minor axis of contact shape (bbox units)
- * @width_major: Major axis of perimeter (bbox units)
- * @width_minor: Minor axis of perimeter (bbox units)
- * @angle: Angle of orientation (vertical: 0 horizontal: +-M_PI_2)
- * @pressure: Pressure of contact (min: 0 max: 1)
- *
- * Depending on the native support of the underlying device, some or all of
- * the listed properties may be computed.
- */
-struct grail_contact {
-	int id;
-	int tool_type;
-	struct grail_coord pos;
-	float touch_major;
-	float touch_minor;
-	float width_major;
-	float width_minor;
-	float angle;
-	float pressure;
-};
+grail_handle GRAIL_PUBLIC grail_new_raw(utouch_frame_handle fh,
+					unsigned int num_frames,
+					void *select,
+					unsigned int version,
+					unsigned int control_size,
+					unsigned int frame_size,
+					unsigned int slot_size);
+
+/**
+ * grail_new - allocate and initialize a new grail instance
+ * @fh: utouch frame handle to use
+ * @num_frames: number of frames in cyclic buffer
+ * @select: client selection callback
+ *
+ * Initialize the internal grail structures.
+ *
+ * Returns zero in case of failure.
+ */
+#define grail_new(fh, num_frames, select)		\
+	grail_new_raw(fh, num_frames, select,		\
+		      GRAIL_VERSION,			\
+		      sizeof(struct grail_control),	\
+		      sizeof(struct grail_frame),	\
+		      sizeof(struct grail_element))
+
+/**
+ * grail_delete - destroy and delete grail instance
+ * @ge: grail instance in use
+ *
+ * Deallocates all internal memory structures.
+ */
+void GRAIL_PUBLIC grail_delete(grail_handle ge);
+
+/**
+ * grail_get_control - get mutable control structure
+ * @ge: the grail device in use
+ *
+ * Return the control struct of the grail instance.
+ *
+ * The control pointer is ABI agnostic, owned by the grail instance, and
+ * has grail scope.
+ */
+struct grail_control GRAIL_PUBLIC *grail_get_control(grail_handle ge);
+
+/**
+ * grail_pump_frame - insert touch frames into grail
+ * @ge: the grail device in use
+ * @frame: the touch frame to insert
+ *
+ * Insert a new touch frame into the grail engine. If the frame induces a
+ * new gesture frame, a pointer to the frame is returned.
+ *
+ * The grail frame pointer is ABI agnostic, owned by the grail instance, and
+ * has grail scope.
+ */
+const struct grail_frame GRAIL_PUBLIC *
+grail_pump_frame(grail_handle ge, const struct utouch_frame *frame);
 
 /**
  * struct grail_client_id - Gesture client information
@@ -106,6 +161,143 @@
 };
 
 /**
+ * struct grail_control - control parameters of grail
+ * @glue_ms: minimum time to hold activation (ms)
+ * @bar_center_x: horizontal distance to activate (surface width fraction)
+ * @bar_center_y: vertical distance to activate (surface height fraction)
+ * @bar_drag_x: horizontal distance to activate (surface width fraction)
+ * @bar_drag_y: vertical distance to activate (surface height fraction)
+ * @bar_scale: minimum scaling to activate (fraction)
+ * @bar_angle: minimum angle to activate (radians)
+ * @drop_x_ms: horizontal expect timeout (ms)
+ * @drop_y_ms: vertical expect timeout (ms)
+ * @drop_scale_ms: scaling expect timeout (ms)
+ * @drop_angle_ms: rotation expect timeout (ms)
+ * @pivot_unbound: when true, the pivot is not bound to the contact area
+ *
+ * The parameters are used to tune the behavior of the gesture recognition.
+ *
+ * The moveness is a number between zero and one denoting the
+ * character of the current transform. Zero means pure rotate and
+ * scale, one means pure drag.
+ *
+ * Later versions of this struct may grow in size, but will remain
+ * binary compatible with older versions.
+ */
+struct grail_control {
+	float glue_ms;
+	float bar_center_x;
+	float bar_center_y;
+	float bar_drag_x;
+	float bar_drag_y;
+	float bar_scale;
+	float bar_angle;
+	float drop_x_ms;
+	float drop_y_ms;
+	float drop_scale_ms;
+	float drop_angle_ms;
+	int pivot_unbound;
+};
+
+/**
+ * struct grail_frame - frame of ongoing elementary transformations
+ * @prev: pointer to the previous gesture frame
+ * @touch: pointer to the touch frame triggering this gesture frame
+ * @num_ongoing: number of elements in the ongoing array
+ * @ongoing: array of ongoing transformation elements
+ * @slots: array of all transformation slots
+ *
+ * A gesture frame consists of one or several touch frames glued
+ * together into a stable transition, combined with information on
+ * ongoing elementary gestural transformations. The array of ongoing
+ * elements contains all elements with a nonzero expect mask.
+ *
+ * Later versions of this struct may grow in size, but will remain
+ * binary compatible with older versions.
+ */
+struct grail_frame {
+	const struct grail_frame *prev;
+	const struct utouch_frame *touch;
+	unsigned int num_ongoing;
+	struct grail_element **ongoing;
+	struct grail_element **slots;
+};
+
+/**
+ * struct grail_element - elementary gesture transformation
+ * @prev: respective element of previous frame
+ * @slot: the transformation slot occupied by this element
+ * @id: unique identifier of the ongoing transformation
+ * @num_touches: number of contacts of this element
+ * @touches: array of contacts of this element
+ * @start_time: start time of this element
+ * @start_center: center position at start of transform (surface units)
+ * @expect_mask: bitmask of expected gestures (grail main types)
+ * @active_mask: bitmask of activated gestures (grail main types)
+ * @center: gesture center position (surface units)
+ * @velocity: current center velocity (surface units per second)
+ * @radius: gesture radius from center (surface units)
+ * @transform: the transformation matrix of the gesture
+ * @pivot: current center of rotate and scale (surface units)
+ * @drag: accumulated transformation displacement (surface units)
+ * @scale: accumulated scale (dimensionless)
+ * @angle: accumulated rotation angle (radians)
+ *
+ * The grail element describes the ongoing gestural transformation of
+ * a particular set of contacts. The expect mask describes which
+ * gestural transformations may become active during the course of
+ * events, and the active mask describes which have passed their
+ * respective activation threshold. The set of expected gestures can
+ * change over time, for instance by exclusion or timeout.
+ *
+ * Applications handling rotation, either by transformation matrix or
+ * angle, should use the drag displacement. For other applications,
+ * the center displacement may be used instead, as to not lose
+ * movement accuracy.
+ *
+ * Later versions of this struct may grow in size, but will remain
+ * binary compatible with older versions.
+ */
+struct grail_element {
+	const struct grail_element *prev;
+	int slot;
+	int id;
+	int num_touches;
+	const struct utouch_contact **touches;
+	grail_time_t start_time;
+	struct grail_coord start_center;
+	unsigned int expect_mask;
+	unsigned int active_mask;
+	struct grail_coord center;
+	struct grail_coord velocity;
+	float radius2;
+	float transform[6];
+	float moveness;
+	struct grail_coord pivot;
+	struct grail_coord drag;
+	float scale2;
+	float angle;
+};
+
+/**
+ * grail_element_transform - transform coordinates using element
+ * @slot: the transformation element to use
+ * @q: the grail coordinate to fill
+ * @x: the grail coordinate to transform
+ *
+ * Performs the 3x3 transform *q = T *p, where T is the element
+ * transform.
+ */
+static inline void grail_element_transform(const struct grail_element *slot,
+					   struct grail_coord *q,
+					   const struct grail_coord *p)
+{
+	const float *T = slot->transform;
+	q->x = T[0] * p->x + T[1] * p->y + T[2];
+	q->y = T[3] * p->x + T[4] * p->y + T[5];
+}
+
+/**
  * struct grail_event - Gesture event
  * @type: The gesture type
  * @id: Unique identifier foof the gesture instance
@@ -231,19 +423,6 @@
 				 const struct grail_coord *max);
 
 /**
- * grail_filter_abs_events - filter kernel motion events
- * @ge: the grail device in use
- * @usage: When true, filter kernel motion events.
- *
- * Single-finger pointer events are treated as pointer gestures in
- * grail. When filter_motion_events is non-zero, the kernel events
- * corresponding to pointer movement are removed from the event
- * stream.
- *
- */
-void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage);
-
-/**
  * grail_get_units - get device coordinate ranges
  * @ge: the grail device in use
  * @min: minimum x and y coordinates
@@ -259,17 +438,60 @@
 				  struct grail_coord *min, struct grail_coord *max);
 
 /**
- * grail_get_contacts - get current contact state
- * @ge: the grail device in use
- * @touch: array of contacts to be filled in
- * @max_touch: maximum number of contacts supported by the array
- *
- * Extract the contact state as currently seen by grail.
- *
- */
+ * grail_get_contact_frame - get current contact frame
+ * @ge: the grail device in use
+ *
+ * Return the contact frame current being processed. If called from
+ * within a gesture callback, it is guaranteed to return the frame
+ * corresponding to the gesture.
+ *
+ * The returned pointer can be NULL if no input has yet been extracted
+ * through the grail instance.
+ *
+ * The frame pointer is ABI agnostic, owned by the grail instance, and
+ * has grail scope.
+ */
+const struct utouch_frame GRAIL_PUBLIC *
+grail_get_contact_frame(const struct grail *ge);
+
+/**
+ * grail_get_gesture_frame - get current gesture frame
+ * @ge: the grail device in use
+ *
+ * Return the gesture frame currently being processed. If called from
+ * within a gesture callback, it is guaranteed to return the frame
+ * corresponding to the gesture.
+ *
+ * The returned pointer can be NULL if no input has yet been extracted
+ * through the grail instance.
+ *
+ * The frame pointer is ABI agnostic, owned by the grail instance, and
+ * has grail scope.
+ */
+const struct grail_frame GRAIL_PUBLIC *
+grail_get_gesture_frame(const struct grail *ge);
+
+#ifndef GRAIL_NO_LEGACY_API
+
+struct grail_contact {
+	int id;
+	int tool_type;
+	struct grail_coord pos;
+	float touch_major;
+	float touch_minor;
+	float width_major;
+	float width_minor;
+	float angle;
+	float pressure;
+};
+
+void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage);
+
 int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,
 				    struct grail_contact *touch, int max_touch);
 
+#endif
+
 #ifdef __cplusplus
 }
 #endif

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-04-28 16:53:41 +0000
+++ src/Makefile.am	2011-05-05 13:31:23 +0000
@@ -14,13 +14,6 @@
 	grail-bits.c \
 	grail-inserter.c \
 	grail-inserter.h \
-	grail-gestures.c \
-	grail-gestures.h \
-	gestures-touch.c \
-	gestures-drag.c \
-	gestures-pinch.c \
-	gestures-rotate.c \
-	gestures-tapping.c \
 	grail-recognizer.c \
 	grail-recognizer.h \
 	grail-event.c \

=== removed file 'src/gestures-drag.c'
--- src/gestures-drag.c	2011-04-28 16:53:57 +0000
+++ src/gestures-drag.c	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_DRAG1,
-	GRAIL_TYPE_DRAG2,
-	GRAIL_TYPE_DRAG3,
-	GRAIL_TYPE_DRAG4,
-	GRAIL_TYPE_DRAG5,
-};
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	if (m->single) {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].raw_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].raw_delta;
-	} else {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].action_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].action_delta;
-	}
-	s->prop[GRAIL_PROP_DRAG_VX] = m->fm[FM_X].velocity;
-	s->prop[GRAIL_PROP_DRAG_VY] = m->fm[FM_Y].velocity;
-	s->prop[GRAIL_PROP_DRAG_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_DRAG_Y] = m->fm[FM_Y].value;
-	s->nprop = 6;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-static const int fm_mask = 0x03;
-
-int gru_drag(struct grail *ge,
-	    const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->drag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type < 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->windrag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MDRAG,
-						   PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EDRAG,
-						   PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-

=== removed file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2011-04-28 16:53:57 +0000
+++ src/gestures-pinch.c	1970-01-01 00:00:00 +0000
@@ -1,129 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_PINCH2,
-	GRAIL_TYPE_PINCH3,
-	GRAIL_TYPE_PINCH4,
-	GRAIL_TYPE_PINCH5,
-};
-
-static const int fm_mask = 0x04;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s,
-		      const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_PINCH_DR] = m->fm[FM_R].action_delta;
-	s->prop[GRAIL_PROP_PINCH_VR] = m->fm[FM_R].velocity;
-	s->prop[GRAIL_PROP_PINCH_R] = m->fm[FM_R].value;
-	s->nprop = 3;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->pinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winpinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MPINCH,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EPINCH,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== removed file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2011-04-28 16:53:57 +0000
+++ src/gestures-rotate.c	1970-01-01 00:00:00 +0000
@@ -1,128 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_ROTATE2,
-	GRAIL_TYPE_ROTATE3,
-	GRAIL_TYPE_ROTATE4,
-	GRAIL_TYPE_ROTATE5,
-};
-
-static const int fm_mask = 0x08;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_ROTATE_DA] = m->fm[FM_A].action_delta;
-	s->prop[GRAIL_PROP_ROTATE_VA] = m->fm[FM_A].velocity;
-	s->prop[GRAIL_PROP_ROTATE_A] = m->fm[FM_A].value;
-	s->nprop = 3;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->rotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winrotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MROTATE,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EROTATE,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== removed file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2011-04-28 16:53:57 +0000
+++ src/gestures-tapping.c	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-
-static const int fm_mask = 0x07;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct tapping_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
-	s->prop[GRAIL_PROP_TAP_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_TAP_Y] = m->fm[FM_Y].value;
-	s->nprop = 3;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct tapping_model *state = &gru->tapping;
-	struct move_model *move = &gru->move;
-	state->tap = 0;
-	if (frame->num_active && !frame->prev->num_active) {
-		state->mintouch = 0;
-		state->maxtouch = 0;
-	}
-	if (move->ntouch > state->maxtouch) {
-		if (state->active) {
-			gin_gid_discard(ge, state->gid);
-			state->active = 0;
-		}
-		state->start = move->time;
-		state->maxtouch = move->ntouch;
-		set_props(ge->gin, state, move, frame);
-		if (state->maxtouch <= 5) {
-			int type = GRAIL_TYPE_TAP1 + state->maxtouch - 1;
-			state->gid = gin_gid_begin(ge, type, PRIO_TAP, frame);
-			state->active = 1;
-		}
-		return 0;
-	}
-	if (!state->active) {
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		return 0;
-	}
-	if (move->ntouch <= state->mintouch) {
-		int x = state->prop[GRAIL_PROP_TAP_X];
-		int y = state->prop[GRAIL_PROP_TAP_Y];
-		int t = move->time - state->start;
-		if (t > move->fm[FM_X].bar_ms) {
-			gin_gid_discard(ge, state->gid);
-			state->mintouch = move->ntouch;
-			state->maxtouch = move->ntouch;
-			state->active = 0;
-			return 0;
-		}
-		state->tap = state->maxtouch;
-		state->prop[GRAIL_PROP_TAP_DT] = t;
-		gin_gid_event(ge, state->gid, x, y, state->maxtouch,
-			      state->prop, state->nprop, 1);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-		return 1;
-	}
-	if (!move->ntouch)
-		return 0;
-	state->prop[GRAIL_PROP_TAP_DT] = move->time - state->start;
-	if ((move->active & fm_mask) ||
-	    move->time - state->start > move->fm[FM_X].bar_ms) {
-		gin_gid_discard(ge, state->gid);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-	}
-	return 0;
-}

=== removed file 'src/gestures-touch.c'
--- src/gestures-touch.c	2011-04-04 17:27:38 +0000
+++ src/gestures-touch.c	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_TOUCH1,
-	GRAIL_TYPE_TOUCH2,
-	GRAIL_TYPE_TOUCH3,
-	GRAIL_TYPE_TOUCH4,
-	GRAIL_TYPE_TOUCH5,
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->touch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type <= 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, -PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->wintouch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MTOUCH,
-						   -PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_ETOUCH,
-						   -PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2011-04-28 16:53:57 +0000
+++ src/grail-api.c	2011-05-05 13:31:23 +0000
@@ -31,105 +31,11 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 
-#define DIM_FRAMES 100
-#define FRAME_RATE 100
-
 unsigned int GRAIL_PUBLIC grail_get_version(void)
 {
 	return GRAIL_VERSION;
 }
 
-int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
-{
-	struct grail_impl *x;
-	struct stat fs;
-	int ret;
-
-	ret = fstat(fd, &fs);
-	if (ret)
-		return ret;
-
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		return -ENOMEM;
-
-	if (!fs.st_rdev)
-		x->fptest = fdopen(fd, "r");
-
-	x->evemu = evemu_new(x->fptest ? "fptest" : 0);
-	if (!x->evemu) {
-		ret = -ENOMEM;
-		goto freemem;
-	}
-	if (x->fptest)
-		ret = evemu_read(x->evemu, x->fptest) <= 0;
-	else
-		ret = evemu_extract(x->evemu, fd);
-	if (ret)
-		goto freemem;
-	if (!utouch_frame_is_supported_mtdev(x->evemu)) {
-		ret = -ENODEV;
-		goto freemem;
-	}
-
-	if (!x->fptest) {
-		x->mtdev = mtdev_new_open(fd);
-		if (!x->mtdev) {
-			ret = -ENOMEM;
-			goto freemem;
-		}
-	}
-	x->fh = utouch_frame_new_engine(DIM_FRAMES, DIM_TOUCH, FRAME_RATE);
-	if (!x->fh) {
-		ret = -ENOMEM;
-		goto freedev;
-	}
-	ret = utouch_frame_init_mtdev(x->fh, x->evemu);
-	if (ret)
-		goto freeframe;
-
-	ge->impl = x;
-
-	ret = gin_init(ge);
-	if (ret)
-		goto freeframe;
-
-	ret = gru_init(ge);
-	if (ret)
-		goto freegin;
-
-	return 0;
- freegin:
-	gin_destroy(ge);
- freeframe:
-	utouch_frame_delete_engine(x->fh);
- freedev:
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
- freemem:
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-	return ret;
-}
-
-void GRAIL_PUBLIC grail_close(struct grail *ge, int fd)
-{
-	struct grail_impl *x = ge->impl;
-	gru_destroy(ge);
-	gin_destroy(ge);
-	utouch_frame_delete_engine(x->fh);
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-}
-
 int GRAIL_PUBLIC grail_idle(struct grail *ge, int fd, int ms)
 {
 	struct grail_impl *x = ge->impl;
@@ -156,6 +62,12 @@
 	return ge->impl->touch;
 }
 
+const struct grail_frame GRAIL_PUBLIC *
+grail_get_gesture_frame(const struct grail *ge)
+{
+	return ge->impl->frame;
+}
+
 static void flush_events(struct grail *ge)
 {
 	struct grail_impl *impl = ge->impl;
@@ -169,89 +81,6 @@
 	}
 }
 
-static int skip_event(const struct input_event *ev, int count)
-{
-	switch (ev->type) {
-	case EV_ABS:
-		return 1;
-	case EV_KEY:
-		return ev->code >= BTN_DIGI && ev->code < BTN_WHEEL;
-	case EV_SYN:
-		switch (ev->code) {
-		case SYN_MT_REPORT:
-			return 1;
-		case SYN_REPORT:
-			return count == 0;
-		default:
-			return 0;
-		}
-	default:
-		return 0;
-	}
-}
-
-static void flush_gestures(struct grail *ge)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event iev;
-	struct grail_event gev;
-	int count = 0;
-
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (skip_event(&iev, count))
-			continue;
-		if (ge->event)
-			ge->event(ge, &iev);
-		if (iev.type == EV_SYN && iev.code == SYN_REPORT)
-			count = 0;
-		else
-			count++;
-	}
-	while (!grailbuf_empty(&impl->gbuf)) {
-		grailbuf_get(&impl->gbuf, &gev);
-		if (ge->gesture)
-			ge->gesture(ge, &gev);
-	}
-}
-
-static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct gesture_inserter *gin = ge->gin;
-
-	return grail_mask_count(gin->used, sizeof(gin->used)) == 0 &&
-		frame->time - frame->mod_time > gru->move.fm[FM_X].hold_ms;
-}
-
-static void report_frame(struct grail *ge,
-			 const struct utouch_frame *touch,
-			 const struct input_event *syn)
-{
-	struct grail_impl *impl = ge->impl;
-	struct grail_event gev;
-
-	impl->touch = touch;
-
-	if (touch->num_active && !touch->prev->num_active) {
-		impl->ongoing = 1;
-		impl->gesture = 0;
-	}
-
-	if (!impl->ongoing)
-		return;
-
-	gin_frame_begin(ge, touch);
-	gru_recognize(ge, touch);
-	gin_frame_end(ge, touch);
-
-	if (!grailbuf_empty(&impl->gbuf))
-		impl->gesture = 1;
-
-	if (touch->num_active == 0 || gesture_timeout(ge, touch))
-		impl->ongoing &= impl->gesture;
-}
-
 static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
 {
 	struct grail_impl *impl = ge->impl;
@@ -262,14 +91,12 @@
 	if (ev->type == EV_SYN || ev->type == EV_ABS || ev->type == EV_KEY) {
 		frame = utouch_frame_pump_mtdev(impl->fh, ev);
 		if (frame)
-			report_frame(ge, frame, ev);
+			grail_pump_frame(ge, frame);
 	}
 
 	if (ev->type == EV_SYN) {
 		if (!impl->ongoing)
 			flush_events(ge);
-		if (impl->gesture)
-			flush_gestures(ge);
 	}
 }
 

=== modified file 'src/grail-bits.c'
--- src/grail-bits.c	2011-04-28 16:53:57 +0000
+++ src/grail-bits.c	2011-05-05 13:31:23 +0000
@@ -59,6 +59,16 @@
 		*a++ &= ~*b++;
 }
 
+int GRAIL_PUBLIC grail_mask_inner(const grail_mask_t *a, const grail_mask_t *b,
+				  int bytes)
+{
+	int k;
+	for (k = 0; k < bytes; k++)
+		if (a[k] & b[k])
+			return 1;
+	return 0;
+}
+
 int GRAIL_PUBLIC grail_mask_count(const grail_mask_t *mask, int bytes)
 {
 	int count = 0;

=== modified file 'src/grail-frame.c'
--- src/grail-frame.c	2011-04-28 16:53:57 +0000
+++ src/grail-frame.c	2011-05-05 13:31:23 +0000
@@ -20,6 +20,8 @@
  ****************************************************************************/
 
 #include "grail-impl.h"
+#include "grail-inserter.h"
+#include "grail-recognizer.h"
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -261,7 +263,7 @@
 	int i, j, n = impl->num_touches;
 	struct grail_element *best = 0;
 
-	if (touch->num_active < 3) {
+	if (!touch->num_active) {
 		stop_slot(impl, slot);
 		return;
 	}
@@ -291,6 +293,8 @@
 				best = s;
 		}
 	}
+	if (!best)
+		best = slots[0];
 
 	update_slot(impl, slot, best->transform[1], best->transform[0]);
 }
@@ -372,14 +376,75 @@
 	}
 }
 
+static int skip_event(const struct input_event *ev, int count)
+{
+	switch (ev->type) {
+	case EV_ABS:
+		return 1;
+	case EV_KEY:
+		return ev->code >= BTN_DIGI && ev->code < BTN_WHEEL;
+	case EV_SYN:
+		switch (ev->code) {
+		case SYN_MT_REPORT:
+			return 1;
+		case SYN_REPORT:
+			return count == 0;
+		default:
+			return 0;
+		}
+	default:
+		return 0;
+	}
+}
+
+static void flush_gestures(struct grail *ge)
+{
+	struct grail_impl *impl = ge->impl;
+	struct input_event iev;
+	struct grail_event gev;
+	int count = 0;
+
+	while (!evbuf_empty(&impl->evbuf)) {
+		evbuf_get(&impl->evbuf, &iev);
+		if (skip_event(&iev, count))
+			continue;
+		if (ge->event)
+			ge->event(ge, &iev);
+		if (iev.type == EV_SYN && iev.code == SYN_REPORT)
+			count = 0;
+		else
+			count++;
+	}
+	while (!grailbuf_empty(&impl->gbuf)) {
+		grailbuf_get(&impl->gbuf, &gev);
+		if (ge->gesture)
+			ge->gesture(ge, &gev);
+	}
+}
+
+static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
+{
+	struct gesture_inserter *gin = ge->gin;
+	struct grail_impl *impl = ge->impl;
+
+	return grail_mask_count(gin->used, sizeof(gin->used)) == 0 &&
+		frame->time - frame->mod_time > impl->ctl->drop_x_ms;
+}
+
 const struct grail_frame GRAIL_PUBLIC *
 grail_pump_frame(grail_handle ge, const struct utouch_frame *touch)
 {
 	struct grail_impl *impl = ge->impl;
-	struct grail_frame *frame = impl->frames[impl->nextframe];
-	const struct grail_frame *prev = frame->prev;
+	struct grail_frame *frame;
+	const struct grail_frame *prev;
 	int i;
 
+	if (!impl->frames)
+		return 0;
+
+	frame = impl->frames[impl->nextframe];
+	prev = frame->prev;
+
 	if (touch->slot_revision == touch->prev->slot_revision &&
 	    !prev->num_ongoing)
 		return 0;
@@ -394,5 +459,34 @@
 
 	impl->nextframe = (impl->nextframe + 1) % impl->num_frames;
 
+	if (!ge->gesture)
+		return frame;
+
+	impl->touch = touch;
+	impl->frame = frame;
+
+	if (touch->num_active && !touch->prev->num_active) {
+		impl->ongoing = 1;
+		impl->gesture = 0;
+	}
+
+	if (!impl->ongoing)
+		return frame;
+
+	gin_frame_begin(ge, touch);
+
+	gru_recognize(ge, frame, touch);
+
+	gin_frame_end(ge, touch);
+
+	if (!grailbuf_empty(&impl->gbuf))
+		impl->gesture = 1;
+
+	if (touch->num_active == 0 || gesture_timeout(ge, touch))
+		impl->ongoing &= impl->gesture;
+
+	if (impl->gesture)
+		flush_gestures(ge);
+
 	return frame;
 }

=== removed file 'src/grail-gestures.c'
--- src/grail-gestures.c	2011-04-28 16:53:57 +0000
+++ src/grail-gestures.c	1970-01-01 00:00:00 +0000
@@ -1,210 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include "grail-impl.h"
-#include <math.h>
-
-static const float FM_SN[DIM_FM] = { 1000, 1000, 1000, 1000 };
-static const float FM_BAR[DIM_FM] = { 50, 50, 50, 50 };
-static const grail_time_t FM_HOLD_MS[DIM_FM] = { 60, 60, 60, 60 };
-static const grail_time_t FM_BAR_MS[DIM_FM] = { 300, 300, 500, 500 };
-static const grail_time_t SAMPLE_MS = 10;
-static const float EPS = 1e-3;
-
-static void compute_position(float *x, float *y,
-			     const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	*x = 0;
-	*y = 0;
-	if (n < 1)
-		return;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		*x += t->x;
-		*y += t->y;
-	}
-	*x /= n;
-	*y /= n;
-}
-
-static float compute_radius(float x, float y,
-			    const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float r = 0, r2 = 0;
-	if (n < 2)
-		return r;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		float dx = t->x - x;
-		float dy = t->y - y;
-		r2 += dx * dx + dy * dy;
-	}
-	r2 /= n;
-	r = sqrt(r2);
-	return r;
-}
-
-static float compute_rotation(float x, float y, float r,
-			      const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float da = 0, darc2 = 0;
-	if (n < 2)
-		return da;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		const struct utouch_contact *ot = t->prev;
-		float dx = t->x - x;
-		float dy = t->y - y;
-		float mx = t->x - ot->x;
-		float my = t->y - ot->y;
-		darc2 += dx * my - dy * mx;
-	}
-	darc2 /= n;
-	da = darc2 / (r * r);
-	return da;
-}
-
-static void move_reset(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	fm->raw_delta = 0;
-	fm->action_delta = 0;
-	fm->velocity = 0;
-	fm->value = x;
-	fm->original = x;
-	fm->original_ms = t;
-	fm->sample = x;
-	fm->sample_ms = t;
-	m->tickle &= ~(1 << i);
-	m->active &= ~(1 << i);
-	m->timeout &= ~(1 << i);
-}
-
-static void move_update(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	float dt = t - fm->sample_ms;
-	fm->raw_delta = x - fm->value;
-	fm->action_delta = fm->raw_delta;
-	fm->value = x;
-	if (dt > SAMPLE_MS) {
-		fm->velocity = (x - fm->sample) / dt;
-		fm->sample = x;
-		fm->sample_ms = t;
-	}
-	if (fabs(fm->raw_delta) > EPS)
-		m->tickle |= (1 << i);
-	else
-		m->tickle &= ~(1 << i);
-	if (m->active & (1 << i))
-		return;
-	fm->action_delta = 0;
-	if (fabs(x - fm->original) > fm->bar) {
-		if (t - fm->original_ms > fm->hold_ms) {
-			m->active |= (1 << i);
-			fm->action_delta = x - fm->original;
-		}
-	} else if (t - fm->original_ms > fm->bar_ms) {
-		m->timeout |= (1 << i);
-	}
-}
-
-void gru_init_motion(struct grail *ge)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *m = &gru->move;
-	float D[DIM_FM];
-	int i;
-	D[FM_X] = s->mapped_max_x - s->mapped_min_x;
-	D[FM_Y] = s->mapped_max_y - s->mapped_min_y;
-	D[FM_R] = sqrt(D[FM_X] * D[FM_X] + D[FM_Y] * D[FM_Y]);
-	D[FM_A] = 2 * M_PI;
-	for (i = 0; i < DIM_FM; i++) {
-		m->fm[i].fuzz = D[i] / FM_SN[i];
-		m->fm[i].bar = D[i] / FM_BAR[i];
-		m->fm[i].hold_ms = FM_HOLD_MS[i];
-		m->fm[i].bar_ms = FM_BAR_MS[i];
-	}
-}
-
-void gru_motion(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	const struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *m = &gru->move;
-	grail_time_t t = frame->time;
-	float x, y, r, a;
-
-	compute_position(&x, &y, frame);
-	if (frame->prev->revision != frame->revision) {
-		r = compute_radius(x, y, frame);
-		a = 0;
-		move_reset(m, FM_X, x, t);
-		move_reset(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 0;
-	} else if (frame->num_active < 2) {
-		r = 0;
-		a = 0;
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 1;
-		m->multi = 0;
-	} else {
-		r = compute_radius(x, y, frame);
-		a = m->fm[FM_A].value;
-		if (!s->is_semi_mt)
-			a += compute_rotation(x, y, r, frame);
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_update(m, FM_R, r, t);
-		move_update(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 1;
-	}
-	m->ntouch = frame->num_active;
-	m->time = t;
-}
-
-void gru_event(struct grail *ge, int gid,
-	       const struct move_model *m,
-	       const grail_prop_t *prop, int nprop)
-{
-	gin_gid_event(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		      prop, nprop, 0);
-}
-
-void gru_end(struct grail *ge, int gid, const struct move_model *m,
-	     const grail_prop_t *prop, int nprop)
-{
-	gin_gid_end(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		    prop, nprop);
-}

=== removed file 'src/grail-gestures.h'
--- src/grail-gestures.h	2011-04-28 16:53:57 +0000
+++ src/grail-gestures.h	1970-01-01 00:00:00 +0000
@@ -1,115 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef _GRAIL_GESTURES_H
-#define _GRAIL_GESTURES_H
-
-#include "grail-inserter.h"
-
-#define PRIO_POINTER	1
-#define PRIO_GESTURE	2
-#define PRIO_ENV	3
-#define PRIO_META	4
-#define PRIO_TAP	5
-
-#define DIM_FM		4
-
-#define FM_X		0
-#define FM_Y		1
-#define FM_R		2
-#define FM_A		3
-
-struct filter_model {
-	float raw_delta;
-	float action_delta;
-	float velocity;
-	float value;
-	float original;
-	float sample;
-	float fuzz;
-	float bar;
-	grail_time_t original_ms;
-	grail_time_t sample_ms;
-	grail_time_t hold_ms;
-	grail_time_t bar_ms;
-};
-
-struct move_model {
-	struct filter_model fm[DIM_FM];
-	int tickle, active, timeout;
-	int single, multi, ntouch;
-	grail_time_t time;
-};
-
-void gru_init_motion(struct grail *ge);
-void gru_motion(struct grail *ge,
-		const struct utouch_frame *frame);
-void gru_event(struct grail *ge, int gid,
-	       const struct move_model *move,
-	       const grail_prop_t *prop, int nprop);
-void gru_end(struct grail *ge, int gid,
-	     const struct move_model *move,
-	     const grail_prop_t *prop, int nprop);
-
-struct combo_model {
-	int active, gid;
-	int mintouch, maxtouch;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_drag(struct grail *ge,
-	     const struct utouch_frame *frame);
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame);
-
-static inline int out_of_bounds(const struct combo_model *s,
-				const struct move_model *m)
-{
-	return m->ntouch < s->mintouch || m->ntouch > s->maxtouch;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame);
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame);
-
-struct tapping_model {
-	grail_time_t start;
-	int mintouch, maxtouch;
-	int active, gid, tap;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame);
-
-#endif
-

=== modified file 'src/grail-impl.h'
--- src/grail-impl.h	2011-04-28 16:53:57 +0000
+++ src/grail-impl.h	2011-05-05 13:31:23 +0000
@@ -59,6 +59,35 @@
 
 void destroy_grail2(struct grail_impl *x);
 
+/*
+ * struct grail_impl - gesture engine state
+ * @evemu: evemu instance (grail1 only)
+ * @mtdev: mtdev instance (grail1 only)
+ * @fh: frame handler instance (grail1: owner, grail2: referenced)
+ * @touch: current touch frame
+ * @evbuf: input event buffer (grail1 only)
+ * @gbuf: gesture event buffer (grail1 only)
+ * @filter_abs: if true, abs events are filtered (grail1 only)
+ * @ongoing: if true, a gesture is ongoing (grail1 only)
+ * @gesture: if true, a gesture is active (events sent) (grail1 only)
+ * @fptest: file pointer used for data input from file (grail1 only)
+ * @ctl: mutable grail control structure
+ * @select: grail event secltion callback
+ * @num_frames: number of gestures frames in cyclic buffer
+ * @num_slots: number of allocated gesture element slots
+ * @num_touches: number of touches supported for frame instance
+ * @nextframe: index of next frame to be (re)used
+ * @seqid: next gesture frame sequence number
+ * @control_size: maximum number of bytes for grail_control struct
+ * @frame_size: maximum number of bytes for grail_frame struct
+ * @slot_size: maximum number of bytes for grail_element struct
+ * @frames: cyclic array of allocated gesture frames
+ * @frame: current gesture frame (grail1 only)
+ *
+ * The grail engine supports both the grail1 interface, with
+ * open/close and event pulling, and the grail2 interface, with
+ * new/delete, gesture frames and event pumping.
+ */
 struct grail_impl {
 	struct evemu_device *evemu;
 	struct mtdev *mtdev;
@@ -82,6 +111,7 @@
 	unsigned int frame_size;
 	unsigned int slot_size;
 	struct grail_frame **frames;
+	const struct grail_frame *frame;
 };
 
 #endif

=== modified file 'src/grail-init.c'
--- src/grail-init.c	2011-04-28 16:53:57 +0000
+++ src/grail-init.c	2011-05-05 13:31:23 +0000
@@ -36,12 +36,13 @@
 	c->bar_center_y = 0.03;
 	c->bar_drag_x = 0.03;
 	c->bar_drag_y = 0.03;
-	c->bar_scale = 0.3;
-	c->bar_angle = 0.1;
+	c->bar_scale = 0.2;
+	c->bar_angle = 0.2;
 	c->drop_x_ms = 300;
 	c->drop_y_ms = 300;
 	c->drop_scale_ms = 300;
 	c->drop_angle_ms = 300;
+	c->tap_time_ms = 300;
 
 	return c;
 }
@@ -206,6 +207,7 @@
 {
 	struct grail *ge;
 	struct grail_impl *x;
+	int ret;
 
 	ge = calloc(1, sizeof(*ge));
 	if (!ge)
@@ -219,8 +221,17 @@
 		goto out;
 
 	ge->impl = x;
+
+	ret = gin_init(ge);
+	if (ret)
+		goto out;
+	ret = gru_init(ge);
+	if (ret)
+		goto freegin;
+
 	return ge;
-
+ freegin:
+	gin_destroy(ge);
  out:
 	free(x);
 	free(ge);
@@ -229,6 +240,8 @@
 
 void GRAIL_PUBLIC grail_delete(grail_handle ge)
 {
+	gru_destroy(ge);
+	gin_destroy(ge);
 	destroy_grail2(ge->impl);
 	free(ge->impl);
 	free(ge);

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2011-04-28 16:53:57 +0000
+++ src/grail-inserter.c	2011-05-05 13:31:23 +0000
@@ -19,7 +19,6 @@
  *
  ****************************************************************************/
 
-#include "grail-gestures.h"
 #include "grail-inserter.h"
 #include "grail-impl.h"
 #include <malloc.h>
@@ -38,18 +37,6 @@
 	return -1;
 }
 
-static int mask_overlap(const grail_mask_t *a, const grail_mask_t *b,
-			int bytes)
-{
-	int i;
-
-	for (i = 0; i < bytes; i++)
-		if (a[i] & b[i])
-			return 1;
-
-	return 0;
-}
-
 // todo: spanning tree for multi-user case
 static void setup_new_gestures(struct grail *ge,
 			       const struct utouch_frame *frame)
@@ -158,15 +145,6 @@
 
 	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
 		struct slot_state *s = &gin->state[i];
-		if (!s->timeout)
-			continue;
-		if (mask_overlap(keep, s->span, sizeof(keep)))
-			continue;
-		gin_gid_discard(ge, s->id);
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
 		struct gesture_event ev;
 		grail_mask_set(gin->types, s->type);
 		if (s->priority < hold[s->slice] && !s->sent)
@@ -203,7 +181,6 @@
 		s->priority = priority;
 		s->slice = 0;
 	}
-	s->timeout = 0;
 	s->sent = 0;
 	s->id = gin->gestureid++ & MAX_GESTURE_ID;
 	s->status = GRAIL_STATUS_BEGIN;
@@ -231,13 +208,6 @@
 	grail_mask_set(gin->unused, i);
 }
 
-void gin_gid_timeout(struct grail *ge, int gid)
-{
-	int i = find_gslot(ge->gin, gid);
-	if (i >= 0)
-		ge->gin->state[i].timeout = 1;
-}
-
 void gin_gid_event(struct grail *ge, int gid,
 		   float x, float y, int ntouch,
 		   const grail_prop_t *prop, int nprop,
@@ -298,7 +268,4 @@
 	s->mapped_min_y = tmin->y;
 	s->mapped_max_x = tmax->x;
 	s->mapped_max_y = tmax->y;
-
-	if (ge->gru)
-		gru_init_motion(ge);
 }

=== modified file 'src/grail-inserter.h'
--- src/grail-inserter.h	2011-04-28 16:53:57 +0000
+++ src/grail-inserter.h	2011-05-05 13:31:23 +0000
@@ -33,11 +33,27 @@
 
 #define DIM_CLIENT		32
 
+/*
+ * struct slot_state - gesture state
+ * @type: gesture type of this gesture
+ * @priority: priority of this gesture
+ * @slice: 0: normal gesture, 1: touch gesture
+ * @sent: events have been sent for this gesture
+ * @id: unique identifier of this gesture
+ * @status: gesture status (begin, update, end)
+ * @nclient: number of clients listening to this gesture
+ * @client_id: array of clients listening to this gesture
+ * @span: bitmask of contact slots used in this gesture
+ * @buf: gesture event buffer
+ *
+ * This structure keeps track of an individual gesture, from the
+ * tentative state before being qualified as a gesture, through the
+ * beginning of the gesture to the end of the gesture.
+ */
 struct slot_state {
 	int type;
 	int priority;
 	int slice;
-	int timeout;
 	int sent;
 	int id;
 	int status;
@@ -47,6 +63,20 @@
 	struct gebuf buf;
 };
 
+/*
+ * struct gesture_inserter - gesture inserter state
+ * @state: array of simultaneous gesture states
+ * @types: bitmask of ongoing gesture types
+ * @unused: bitmask of unused gesture slots
+ * @fresh: bitmask of slots initiated in this frame
+ * @used: bitmask of used gesture slots
+ * @time: time of current gesture frame
+ * @gestureid: next gesture id to be used
+ * @grab_active: used to signal an active system gesture grab
+ * @grab_client: the grabbing client
+ *
+ * This is the state of the gesture inserter.
+ */
 struct gesture_inserter {
 	struct slot_state state[DIM_INSTANCE];
 	grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
@@ -80,7 +110,6 @@
 int gin_gid_begin(struct grail *ge, int type, int priority,
 		  const struct utouch_frame *frame);
 void gin_gid_discard(struct grail *ge, int gid);
-void gin_gid_timeout(struct grail *ge, int gid);
 
 void gin_gid_event(struct grail *ge, int gid,
 		   float x, float y, int ntouch,

=== modified file 'src/grail-legacy.c'
--- src/grail-legacy.c	2011-04-28 16:53:57 +0000
+++ src/grail-legacy.c	2011-05-05 13:31:23 +0000
@@ -31,6 +31,111 @@
 
 #ifndef GRAIL_NO_LEGACY_ABI
 
+#define DIM_FRAMES 100
+#define FRAME_RATE 100
+
+int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
+{
+	struct grail_impl *x;
+	struct stat fs;
+	int ret;
+
+	ret = fstat(fd, &fs);
+	if (ret)
+		return ret;
+
+	x = calloc(1, sizeof(*x));
+	if (!x)
+		return -ENOMEM;
+
+	if (!fs.st_rdev)
+		x->fptest = fdopen(fd, "r");
+
+	x->evemu = evemu_new(x->fptest ? "fptest" : 0);
+	if (!x->evemu) {
+		ret = -ENOMEM;
+		goto freemem;
+	}
+	if (x->fptest)
+		ret = evemu_read(x->evemu, x->fptest) <= 0;
+	else
+		ret = evemu_extract(x->evemu, fd);
+	if (ret)
+		goto freemem;
+	if (!utouch_frame_is_supported_mtdev(x->evemu)) {
+		ret = -ENODEV;
+		goto freemem;
+	}
+
+	if (!x->fptest) {
+		x->mtdev = mtdev_new_open(fd);
+		if (!x->mtdev) {
+			ret = -ENOMEM;
+			goto freemem;
+		}
+	}
+	x->fh = utouch_frame_new_engine(DIM_FRAMES, DIM_TOUCH, FRAME_RATE);
+	if (!x->fh) {
+		ret = -ENOMEM;
+		goto freedev;
+	}
+	ret = utouch_frame_init_mtdev(x->fh, x->evemu);
+	if (ret)
+		goto freeframe;
+
+	ret = create_grail2(x, x->fh, DIM_FRAMES, NULL,
+			    GRAIL_VERSION,
+			    sizeof(struct grail_control),
+			    sizeof(struct grail_frame),
+			    sizeof(struct grail_element));
+	if (ret)
+		goto freeframe;
+
+	ge->impl = x;
+
+	ret = gin_init(ge);
+	if (ret)
+		goto freegrail2;
+
+	ret = gru_init(ge);
+	if (ret)
+		goto freegin;
+
+	return 0;
+ freegin:
+	gin_destroy(ge);
+ freegrail2:
+	destroy_grail2(x);
+ freeframe:
+	utouch_frame_delete_engine(x->fh);
+ freedev:
+	if (x->mtdev)
+		mtdev_close_delete(x->mtdev);
+ freemem:
+	evemu_delete(x->evemu);
+	if (x->fptest)
+		fclose(x->fptest);
+	free(x);
+	ge->impl = 0;
+	return ret;
+}
+
+void GRAIL_PUBLIC grail_close(struct grail *ge, int fd)
+{
+	struct grail_impl *x = ge->impl;
+	gru_destroy(ge);
+	gin_destroy(ge);
+	destroy_grail2(x);
+	utouch_frame_delete_engine(x->fh);
+	if (x->mtdev)
+		mtdev_close_delete(x->mtdev);
+	evemu_delete(x->evemu);
+	if (x->fptest)
+		fclose(x->fptest);
+	free(x);
+	ge->impl = 0;
+}
+
 void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage)
 {
 	struct grail_impl *x = ge->impl;

=== modified file 'src/grail-recognizer.c'
--- src/grail-recognizer.c	2011-04-28 16:53:57 +0000
+++ src/grail-recognizer.c	2011-05-05 13:31:23 +0000
@@ -23,6 +23,177 @@
 #include <string.h>
 #include <malloc.h>
 #include <errno.h>
+#include <math.h>
+
+static const int MAX_TOUCH_GESTURE = 5;
+
+static void touch_props(const struct gesture_inserter *gin,
+			struct combo_model *s, const struct grail_element *m,
+			const struct utouch_frame *frame)
+{
+	s->nprop = 0;
+}
+
+static void drag_props(const struct gesture_inserter *gin,
+		       struct combo_model *s, const struct grail_element *m,
+		       const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_DRAG_DX] = m->center.x - m->prev->center.x;
+	s->prop[GRAIL_PROP_DRAG_DY] = m->center.y - m->prev->center.y;
+	s->prop[GRAIL_PROP_DRAG_VX] = m->velocity.x;
+	s->prop[GRAIL_PROP_DRAG_VY] = m->velocity.y;
+	s->prop[GRAIL_PROP_DRAG_X] = m->center.x - m->start_center.x;
+	s->prop[GRAIL_PROP_DRAG_Y] = m->center.y - m->start_center.x;
+	s->nprop = 6;
+}
+
+static void pinch_props(const struct gesture_inserter *gin,
+			struct combo_model *s, const struct grail_element *m,
+			const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_PINCH_DR] =
+		sqrt(m->radius2) - sqrt(m->prev->radius2);
+	s->prop[GRAIL_PROP_PINCH_VR] = 0;
+	s->prop[GRAIL_PROP_PINCH_R] = sqrt(m->radius2);
+	s->nprop = 3;
+}
+
+static void rotate_props(const struct gesture_inserter *gin,
+			 struct combo_model *s, const struct grail_element *m,
+			 const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_ROTATE_DA] = m->angle - m->prev->angle;
+	s->prop[GRAIL_PROP_ROTATE_VA] = 0;
+	s->prop[GRAIL_PROP_ROTATE_A] = m->angle;
+	s->nprop = 3;
+}
+
+static void tap_props(const struct gesture_inserter *gin,
+		      struct combo_model *s, const struct grail_element *m,
+		      const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_TAP_DT] = frame->time - s->start;
+	s->prop[GRAIL_PROP_TAP_X] = m->center.x;
+	s->prop[GRAIL_PROP_TAP_Y] = m->center.y;
+	s->nprop = 3;
+}
+
+static const struct gesture_handler touch_handler = {
+	0,
+	{
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_TOUCH1, 1, 1, PRIO_DRAG },
+		{ GRAIL_TYPE_TOUCH2, 2, 2, PRIO_DRAG },
+		{ GRAIL_TYPE_TOUCH3, 3, 3, PRIO_DRAG },
+		{ GRAIL_TYPE_TOUCH4, 4, 4, PRIO_DRAG },
+		{ GRAIL_TYPE_TOUCH5, 5, 5, PRIO_DRAG }
+	},
+	touch_props
+};
+
+static const struct gesture_handler drag_handler = {
+	GRAIL_EXPECT_DRAG_X | GRAIL_EXPECT_DRAG_Y,
+	{
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_DRAG1, 1, 1, PRIO_DRAG },
+		{ GRAIL_TYPE_DRAG2, 2, 2, PRIO_DRAG },
+		{ GRAIL_TYPE_DRAG3, 3, 3, PRIO_DRAG },
+		{ GRAIL_TYPE_DRAG4, 4, 4, PRIO_DRAG },
+		{ GRAIL_TYPE_DRAG5, 5, 5, PRIO_DRAG }
+	},
+	drag_props
+};
+
+static const struct gesture_handler pinch_handler = {
+	GRAIL_EXPECT_SCALE,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_PINCH2, 2, 2, PRIO_PINCH },
+		{ GRAIL_TYPE_PINCH3, 3, 3, PRIO_PINCH },
+		{ GRAIL_TYPE_PINCH4, 4, 4, PRIO_PINCH },
+		{ GRAIL_TYPE_PINCH5, 5, 5, PRIO_PINCH }
+	},
+	pinch_props
+};
+
+static const struct gesture_handler rotate_handler = {
+	GRAIL_EXPECT_ANGLE,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_ROTATE2, 2, 2, PRIO_ROTATE },
+		{ GRAIL_TYPE_ROTATE3, 3, 3, PRIO_ROTATE },
+		{ GRAIL_TYPE_ROTATE4, 4, 4, PRIO_ROTATE },
+		{ GRAIL_TYPE_ROTATE5, 5, 5, PRIO_ROTATE }
+	},
+	rotate_props
+};
+
+static const struct gesture_handler tap_handler = {
+	GRAIL_EXPECT_MASK,
+	{
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_TAP1, 1, 1, PRIO_TAP },
+		{ GRAIL_TYPE_TAP2, 2, 2, PRIO_TAP },
+		{ GRAIL_TYPE_TAP3, 3, 3, PRIO_TAP },
+		{ GRAIL_TYPE_TAP4, 4, 4, PRIO_TAP },
+		{ GRAIL_TYPE_TAP5, 5, 5, PRIO_TAP }
+	},
+	tap_props
+};
+
+static const struct gesture_handler wintouch_handler = {
+	0,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_ETOUCH, 1, 3, PRIO_EDRAG },
+		{ GRAIL_TYPE_MTOUCH, 1, 4, PRIO_MDRAG },
+		{ -1, 0, 0, 0 },
+	},
+	touch_props
+};
+
+static const struct gesture_handler windrag_handler = {
+	GRAIL_EXPECT_DRAG_X | GRAIL_EXPECT_DRAG_Y,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_EDRAG, 1, 3, PRIO_EDRAG },
+		{ GRAIL_TYPE_MDRAG, 1, 4, PRIO_MDRAG },
+		{ -1, 0, 0, 0 },
+	},
+	drag_props
+};
+
+static const struct gesture_handler winpinch_handler = {
+	GRAIL_EXPECT_SCALE,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_EPINCH, 2, 3, PRIO_EPINCH },
+		{ GRAIL_TYPE_MPINCH, 2, 4, PRIO_MPINCH },
+		{ -1, 0, 0, 0 },
+	},
+	pinch_props
+};
+
+static const struct gesture_handler winrotate_handler = {
+	GRAIL_EXPECT_ANGLE,
+	{
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ -1, 0, 0, 0 },
+		{ GRAIL_TYPE_EROTATE, 2, 3, PRIO_EROTATE },
+		{ GRAIL_TYPE_MROTATE, 2, 4, PRIO_MROTATE },
+		{ -1, 0, 0, 0 },
+	},
+	rotate_props
+};
 
 int gru_init(struct grail *ge)
 {
@@ -30,8 +201,18 @@
 	gru = calloc(1, sizeof(struct gesture_recognizer));
 	if (!gru)
 		return -ENOMEM;
+
+	gru->touch.handler = &touch_handler;
+	gru->drag.handler = &drag_handler;
+	gru->pinch.handler = &pinch_handler;
+	gru->rotate.handler = &rotate_handler;
+	gru->tapping.handler = &tap_handler;
+	gru->wintouch.handler = &wintouch_handler;
+	gru->windrag.handler = &windrag_handler;
+	gru->winpinch.handler = &winpinch_handler;
+	gru->winrotate.handler = &winrotate_handler;
+
 	ge->gru = gru;
-	gru_init_motion(ge);
 	return 0;
 }
 
@@ -41,18 +222,166 @@
 	ge->gru = NULL;
 }
 
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame)
-{
-	if (!ge->gin || !ge->gru)
-		return;
-	gru_motion(ge, frame);
-	gru_touch(ge, frame);
-	gru_drag(ge, frame);
-	gru_pinch(ge, frame);
-	gru_rotate(ge, frame);
-	gru_wintouch(ge, frame);
-	gru_windrag(ge, frame);
-	gru_winpinch(ge, frame);
-	gru_winrotate(ge, frame);
-	gru_tapping(ge, frame);
+static void set_props(struct grail *ge,
+		      struct combo_model *s,
+		      const struct utouch_frame *frame)
+{
+	const struct gesture_handler *gh = s->handler;
+	gh->set_props(ge->gin, s, ge->gru->move, frame);
+	s->nprop += gin_add_contact_props(ge->gin, s->prop + s->nprop, frame);
+}
+
+static int gru_touch_handler(struct grail *ge,
+			     struct combo_model *state,
+			     const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct gesture_inserter *gin = ge->gin;
+	struct grail_element *move = gru->move;
+	const struct gesture_handler *gh = state->handler;
+	int ntouch = move->num_touches;
+	if (frame->slot_revision != frame->prev->slot_revision) {
+		if (state->active) {
+			gin_gid_end(ge, state->gid, move->center.x,
+				    move->center.y, ntouch,
+				    state->prop, state->nprop);
+			state->active = 0;
+		}
+	}
+	if (ntouch > MAX_TOUCH_GESTURE)
+		return 0;
+	if (!state->active) {
+		struct gesture_head h = gh->getype[ntouch];
+		if (h.type < 0)
+			return 0;
+		state->gid = gin_gid_begin(ge, h.type, -h.priority, frame);
+		state->mintouch = h.mintouch;
+		state->maxtouch = h.maxtouch;
+		state->active = 1;
+	}
+	set_props(ge, state, frame);
+	gin_gid_event(ge, state->gid, move->center.x, move->center.y,
+		      ntouch, state->prop, state->nprop, 0);
+	return 1;
+}
+
+static int gru_gesture_handler(struct grail *ge,
+			       struct combo_model *state,
+			       const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct gesture_inserter *gin = ge->gin;
+	struct grail_element *move = gru->move;
+	const struct gesture_handler *gh = state->handler;
+	int expect = move->expect_mask & gh->fm_mask;
+	int active = move->active_mask & gh->fm_mask;
+	int ntouch = move->num_touches;
+	if (state->active &&
+	    (!expect || ntouch < state->mintouch || ntouch > state->maxtouch)) {
+		gin_gid_end(ge, state->gid, move->center.x,
+			    move->center.y, ntouch,
+			    state->prop, state->nprop);
+		state->active = 0;
+		return 0;
+	}
+	if (!expect || ntouch > MAX_TOUCH_GESTURE)
+		return 0;
+	if (!state->active) {
+		struct gesture_head h = gh->getype[ntouch];
+		if (h.type < 0)
+			return 0;
+		state->gid = gin_gid_begin(ge, h.type, h.priority, frame);
+		state->mintouch = h.mintouch;
+		state->maxtouch = h.maxtouch;
+		state->active = 1;
+	}
+	if (!active)
+		return 0;
+	set_props(ge, state, frame);
+	gin_gid_event(ge, state->gid, move->center.x, move->center.y,
+		      ntouch, state->prop, state->nprop, 0);
+	return 1;
+}
+
+static int gru_tap_handler(struct grail *ge,
+			   struct combo_model *state,
+			   const struct utouch_frame *frame)
+{
+	const struct grail_control *ctl = ge->impl->ctl;
+	struct gesture_recognizer *gru = ge->gru;
+	struct grail_element *move = gru->move;
+	const struct gesture_handler *gh = state->handler;
+	int active = move->active_mask & gh->fm_mask;
+	int ntouch = move->num_touches;
+	if (frame->num_active && !frame->prev->num_active) {
+		state->mintouch = 0;
+		state->maxtouch = 0;
+	}
+	if (ntouch > state->maxtouch) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		state->start = frame->time;
+		state->maxtouch = ntouch;
+		set_props(ge, state, frame);
+		if (state->maxtouch <= MAX_TOUCH_GESTURE) {
+			struct gesture_head h = gh->getype[ntouch];
+			if (h.type < 0)
+				return 0;
+			state->gid = gin_gid_begin(ge, h.type, h.priority,
+						   frame);
+			state->active = 1;
+		}
+		return 0;
+	}
+	if (!state->active) {
+		state->mintouch = ntouch;
+		return 0;
+	}
+	if (active || frame->time - state->start > ctl->tap_time_ms) {
+		gin_gid_discard(ge, state->gid);
+		state->mintouch = ntouch;
+		state->maxtouch = ntouch;
+		state->active = 0;
+		return 0;
+	}
+	if (ntouch <= state->mintouch) {
+		float x = state->prop[GRAIL_PROP_TAP_X];
+		float y = state->prop[GRAIL_PROP_TAP_Y];
+		float t = frame->time - state->start;
+		state->prop[GRAIL_PROP_TAP_DT] = t;
+		gin_gid_event(ge, state->gid, x, y, state->maxtouch,
+			      state->prop, state->nprop, 1);
+		state->mintouch = ntouch;
+		state->maxtouch = ntouch;
+		state->active = 0;
+		return 1;
+	}
+	if (!ntouch)
+		return 0;
+	state->prop[GRAIL_PROP_TAP_DT] = frame->time - state->start;
+	return 0;
+}
+
+void gru_recognize(struct grail *ge,
+		   const struct grail_frame *frame,
+		   const struct utouch_frame *touch)
+{
+	struct gesture_recognizer *gru = ge->gru;
+
+	if (frame && frame->num_ongoing)
+		gru->slot = frame->ongoing[frame->num_ongoing - 1]->slot;
+
+	gru->move = frame->slots[gru->slot];
+
+	gru_touch_handler(ge, &gru->touch, touch);
+	gru_gesture_handler(ge, &gru->drag, touch);
+	gru_gesture_handler(ge, &gru->pinch, touch);
+	gru_gesture_handler(ge, &gru->rotate, touch);
+	gru_touch_handler(ge, &gru->wintouch, touch);
+	gru_gesture_handler(ge, &gru->windrag, touch);
+	gru_gesture_handler(ge, &gru->winpinch, touch);
+	gru_gesture_handler(ge, &gru->winrotate, touch);
+	gru_tap_handler(ge, &gru->tapping, touch);
 }

=== modified file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2011-04-28 16:53:57 +0000
+++ src/grail-recognizer.h	2011-05-05 13:31:23 +0000
@@ -22,10 +22,60 @@
 #ifndef _GRAIL_RECOGNIZER_H
 #define _GRAIL_RECOGNIZER_H
 
-#include "grail-gestures.h"
-
+#include "grail-inserter.h"
+
+#define PRIO_POINTER	1
+#define PRIO_PINCH	2
+#define PRIO_ROTATE	3
+#define PRIO_DRAG	3
+#define PRIO_EPINCH	4
+#define PRIO_EROTATE	5
+#define PRIO_EDRAG	5
+#define PRIO_MPINCH	6
+#define PRIO_MROTATE	7
+#define PRIO_MDRAG	7
+#define PRIO_TAP	8
+
+/*
+ * struct combo_model - gesture primitive state
+ * @start: time this primitive started
+ * @active: true if this primitive is active
+ * @gid: gesture slot used for this primitive
+ * @mintouch: number of touches below this value ends the primitive
+ * @maxtouch: number of touches above this value ends the primitive
+ * @nprop: number of properties of this primitive
+ * @handler: pointer to gesture handler for this primitive
+ *
+ * This structure keeps track of an individual gesture primitive.
+ */
+struct combo_model {
+	grail_time_t start;
+	int active, gid;
+	int mintouch, maxtouch;
+	int nprop;
+	grail_prop_t prop[DIM_GRAIL_PROP];
+	const struct gesture_handler *handler;
+};
+
+/*
+ * struct gesture_recognizer - gesture recognizer state
+ * @slot: touch slot of current touch frame
+ * @move: the grail element used for all gestures
+ * @touch: touch primitive state
+ * @drag: drag primitive state
+ * @pinch: pinch primitive state
+ * @rotate: rotate primitive state
+ * @wintouch: env/meta touch primitive state
+ * @windrag: env/meta drag primitive state
+ * @winpinch: env/meta pinch primitive state
+ * @winrotate: env/meta rotate primitive state
+ * @tapping: tapping gesture primitive state
+ *
+ * This is the state of the gesture recognizer.
+ */
 struct gesture_recognizer {
-	struct move_model move;
+	int slot;
+	struct grail_element *move;
 	struct combo_model touch;
 	struct combo_model drag;
 	struct combo_model pinch;
@@ -34,11 +84,45 @@
 	struct combo_model windrag;
 	struct combo_model winpinch;
 	struct combo_model winrotate;
-	struct tapping_model tapping;
+	struct combo_model tapping;
+};
+
+/*
+ * struct gesture_head - gesture type handler data
+ * @type: gesture type of this primitive
+ * @mintouch: minimum number of touches for this primitive
+ * @maxtouch: maximum number of touches for this primitive
+ * @priority: priority of this primitive
+ */
+struct gesture_head {
+	int type;
+	int mintouch;
+	int maxtouch;
+	int priority;
+};
+
+/*
+ * struct gesture_handler - gesture handler state
+ * @fm_mask: gesture frame expectation mask used in this handler
+ * @getype: array of gesture type data per number of touches
+ * @set_props: properties method for this handler
+ *
+ * This is the state of the gesture handler.
+ */
+struct gesture_handler {
+	int fm_mask;
+	struct gesture_head getype[DIM_TOUCH + 1];
+
+	void (*set_props)(const struct gesture_inserter *gin,
+			  struct combo_model *state,
+			  const struct grail_element *element,
+			  const struct utouch_frame *frame);
 };
 
 int gru_init(struct grail *ge);
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame);
+void gru_recognize(struct grail *ge,
+		   const struct grail_frame *frame,
+		   const struct utouch_frame *touch);
 void gru_destroy(struct grail *ge);
 
 #endif

=== modified file 'test/Makefile.am'
--- test/Makefile.am	2011-04-28 16:53:46 +0000
+++ test/Makefile.am	2011-05-05 13:31:23 +0000
@@ -10,6 +10,7 @@
 check_grail_SOURCES = \
 	check-mapping.c \
 	check-transform.c \
+	check-gestures.c \
 	check-grail.c
 
 check_grail_CFLAGS = \

=== added file 'test/check-gestures.c'
--- test/check-gestures.c	1970-01-01 00:00:00 +0000
+++ test/check-gestures.c	2011-05-05 13:31:23 +0000
@@ -0,0 +1,204 @@
+#include <check.h>
+#include <grail.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#define TEST_TIME_MS	20000
+
+struct test_data {
+	struct grail ge;
+	int fd;
+	int begin[DIM_GRAIL_TYPE];
+	int update[DIM_GRAIL_TYPE];
+	int end[DIM_GRAIL_TYPE];
+};
+
+static int tp_get_clients(struct grail *ge,
+			  struct grail_client_info *clients, int max_clients,
+			  const struct grail_coord *coords, int num_coords,
+			  const grail_mask_t *types, int type_bytes)
+{
+	memset(&clients[0], 0, sizeof(clients[0]));
+	clients[0].mask[0] = 255;
+	clients[0].mask[1] = 255;
+	clients[0].mask[2] = 255;
+	clients[0].mask[3] = 255;
+	clients[0].id.client = 345;
+	clients[0].id.root = 1;
+	clients[0].id.event = 2;
+	clients[0].id.child = 3;
+	ge = 0;
+	types = 0;
+	type_bytes = 0;
+	max_clients = 0;
+	coords = 0;
+	num_coords = 0;
+	return 1;
+}
+
+static void tp_event(struct grail *ge, const struct input_event *ev)
+{
+	ge = 0;
+	ev = 0;
+}
+
+static void tp_gesture(struct grail *ge, const struct grail_event *ev)
+{
+	struct test_data *data = ge->priv;
+
+	switch (ev->status) {
+	case GRAIL_STATUS_BEGIN:
+		data->begin[ev->type]++;
+		break;
+	case GRAIL_STATUS_UPDATE:
+		data->update[ev->type]++;
+		break;
+	case GRAIL_STATUS_END:
+		data->end[ev->type]++;
+		break;
+	}
+}
+
+static int init_test_data(struct test_data *data, const char *path)
+{
+	int ret;
+
+	memset(data, 0, sizeof(*data));
+
+	data->ge.get_clients = tp_get_clients;
+	data->ge.event = tp_event;
+	data->ge.gesture = tp_gesture;
+
+	data->fd = open(path, O_RDONLY | O_NONBLOCK);
+	ret = grail_open(&data->ge, data->fd);
+	if(ret)
+		return ret;
+	return 0;
+}
+
+static void term_test_data(struct test_data *data)
+{
+	grail_close(&data->ge, data->fd);
+	close(data->fd);
+}
+
+static void test_gesture_type(const char *name, int type,
+			      int nbegin, int nupdate, int nother)
+{
+	struct test_data data;
+	char path[1024];
+	int ntype = 0;
+	int i;
+
+	sprintf(path, "io/functional/%s", name);
+	fail_if(init_test_data(&data, path));
+
+	data.ge.priv = &data;
+	grail_pull(&data.ge, data.fd);
+
+	for (i = 0; i < DIM_GRAIL_TYPE; i++) {
+		if (data.begin[i] || data.update[i] || data.end[i]) {
+			//fprintf(stderr, "type %d %d\n", i, data.begin[i]);
+			ntype++;
+		}
+	}
+
+	fail_unless(data.begin[type] == nbegin);
+	fail_unless(data.update[type] >= nupdate);
+	fail_unless(data.end[type] == nbegin);
+	fail_unless(ntype == 1 + nother);
+
+	term_test_data(&data);
+}
+
+
+START_TEST(drag_1)
+{
+	test_gesture_type("drag-1.evemu", GRAIL_TYPE_DRAG1, 4, 4, 0);
+}
+END_TEST
+
+START_TEST(drag_2)
+{
+	test_gesture_type("drag-2.evemu", GRAIL_TYPE_DRAG2, 3, 3, 0);
+}
+END_TEST
+
+START_TEST(drag_3)
+{
+	test_gesture_type("drag-3.evemu", GRAIL_TYPE_EDRAG, 2, 2, 1);
+}
+END_TEST
+
+START_TEST(drag_4)
+{
+	test_gesture_type("drag-4.evemu", GRAIL_TYPE_MDRAG, 4, 4, 0);
+}
+END_TEST
+
+START_TEST(hold_1)
+{
+	test_gesture_type("hold-1.evemu", GRAIL_TYPE_DRAG1, 0, 0, -1);
+}
+END_TEST
+
+START_TEST(pinch_2)
+{
+	test_gesture_type("pinch-2.evemu", GRAIL_TYPE_PINCH2, 2, 2, 0);
+}
+END_TEST
+
+START_TEST(pinch_3)
+{
+	test_gesture_type("pinch-3.evemu", GRAIL_TYPE_EPINCH, 2, 2, 0);
+}
+END_TEST
+
+START_TEST(rotate_2)
+{
+	test_gesture_type("rotate-2.evemu", GRAIL_TYPE_ROTATE2, 4, 4, 0);
+}
+END_TEST
+
+START_TEST(tap_1)
+{
+	test_gesture_type("tap-1.evemu", GRAIL_TYPE_TAP1, 0, 1, 0);
+}
+END_TEST
+
+START_TEST(tap_4)
+{
+	test_gesture_type("tap-4.evemu", GRAIL_TYPE_TAP4, 0, 1, 0);
+}
+END_TEST
+
+#define ADD_TEST(suite, name)					\
+	do {							\
+		TCase *test = tcase_create(#name);		\
+		tcase_set_timeout (test, TEST_TIME_MS / 1000);	\
+		tcase_add_test(test, name);			\
+		suite_add_tcase(suite, test);			\
+	} while (0)
+
+Suite *make_gesture_suite()
+{
+	Suite *suite = suite_create("grail-gestures");
+
+	ADD_TEST(suite, drag_1);
+	ADD_TEST(suite, drag_2);
+	ADD_TEST(suite, drag_3);
+	ADD_TEST(suite, drag_4);
+	ADD_TEST(suite, hold_1);
+	ADD_TEST(suite, pinch_2);
+	ADD_TEST(suite, pinch_3);
+	ADD_TEST(suite, rotate_2);
+	ADD_TEST(suite, tap_1);
+	ADD_TEST(suite, tap_4);
+
+	return suite;
+}

=== modified file 'test/check-grail.c'
--- test/check-grail.c	2011-04-28 16:53:46 +0000
+++ test/check-grail.c	2011-05-05 13:31:23 +0000
@@ -4,6 +4,7 @@
 
 extern Suite *make_mapping_suite();
 extern Suite *make_transform_suite();
+extern Suite *make_gesture_suite();
 
 int main(int argc CK_ATTRIBUTE_UNUSED, char* argv[] CK_ATTRIBUTE_UNUSED)
 {
@@ -13,6 +14,7 @@
 
 	srunner_add_suite(sr, make_mapping_suite());
 	srunner_add_suite(sr, make_transform_suite());
+	srunner_add_suite(sr, make_gesture_suite());
 
 	srunner_set_log(sr, "check_grail.log");
 	srunner_set_xml(sr, "check_grail.xml");

=== added directory 'test/io/functional'
=== added file 'test/io/functional/drag-1.evemu'
--- test/io/functional/drag-1.evemu	1970-01-01 00:00:00 +0000
+++ test/io/functional/drag-1.evemu	2011-05-05 13:31:23 +0000
@@ -0,0 +1,3988 @@
+N: 3M-Microtouch
+I: 0003 0596 0502 0110
+P: 00 00 00 00 00 00 00 00
+B: 00 0b 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 04 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 02 00 00 00 00 00 00 00 00
+B: 03 03 00 00 00 00 80 73 02
+B: 04 00 00 00 00 00 00 00 00
+B: 05 00 00 00 00 00 00 00 00
+B: 11 00 00 00 00 00 00 00 00
+B: 12 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+A: 00 0 32767 15 0
+A: 01 0 32767 15 0
+A: 2f 0 59 0 0
+A: 30 0 32767 255 0
+A: 31 0 32767 255 0
+A: 34 0 1 0 0
+A: 35 0 32767 15 0
+A: 36 0 32767 15 0
+A: 39 0 65535 0 0
+E: 1304510649.770760 0003 002f 0
+E: 1304510649.770775 0003 0039 135
+E: 1304510649.770778 0003 0035 16448
+E: 1304510649.770779 0003 0036 6505
+E: 1304510649.770782 0003 0030 1312
+E: 1304510649.770787 0001 014a 1
+E: 1304510649.770791 0003 0000 16448
+E: 1304510649.770792 0003 0001 6505
+E: 1304510649.770794 0000 0000 0
+E: 1304510649.775755 0003 0030 1348
+E: 1304510649.775775 0000 0000 0
+E: 1304510649.801747 0003 0036 6507
+E: 1304510649.801769 0000 0000 0
+E: 1304510649.806750 0003 0036 6509
+E: 1304510649.806771 0000 0000 0
+E: 1304510649.811749 0003 0036 6521
+E: 1304510649.811769 0003 0001 6513
+E: 1304510649.811771 0000 0000 0
+E: 1304510649.816750 0003 0036 6529
+E: 1304510649.816763 0003 0030 1220
+E: 1304510649.816771 0003 0001 6521
+E: 1304510649.816773 0000 0000 0
+E: 1304510649.821749 0003 0036 6559
+E: 1304510649.821762 0003 0030 1188
+E: 1304510649.821770 0003 0001 6559
+E: 1304510649.821772 0000 0000 0
+E: 1304510649.826749 0003 0036 6570
+E: 1304510649.826769 0003 0001 6561
+E: 1304510649.826771 0000 0000 0
+E: 1304510649.831749 0003 0036 6603
+E: 1304510649.831769 0003 0001 6603
+E: 1304510649.831771 0000 0000 0
+E: 1304510649.836750 0003 0036 6617
+E: 1304510649.836770 0003 0001 6606
+E: 1304510649.836772 0000 0000 0
+E: 1304510649.841749 0003 0036 6657
+E: 1304510649.841769 0003 0001 6657
+E: 1304510649.841771 0000 0000 0
+E: 1304510649.847750 0003 0036 6671
+E: 1304510649.847763 0003 0030 1322
+E: 1304510649.847771 0003 0001 6660
+E: 1304510649.847772 0000 0000 0
+E: 1304510649.852748 0003 0036 6715
+E: 1304510649.852761 0003 0030 1355
+E: 1304510649.852769 0003 0001 6715
+E: 1304510649.852771 0000 0000 0
+E: 1304510649.857749 0003 0036 6729
+E: 1304510649.857769 0003 0001 6718
+E: 1304510649.857771 0000 0000 0
+E: 1304510649.862749 0003 0036 6771
+E: 1304510649.862769 0003 0001 6771
+E: 1304510649.862771 0000 0000 0
+E: 1304510649.867749 0003 0036 6805
+E: 1304510649.867770 0003 0001 6805
+E: 1304510649.867772 0000 0000 0
+E: 1304510649.872746 0003 0035 16445
+E: 1304510649.872758 0003 0036 6873
+E: 1304510649.872768 0003 0001 6873
+E: 1304510649.872770 0000 0000 0
+E: 1304510649.877748 0003 0035 16443
+E: 1304510649.877761 0003 0036 6887
+E: 1304510649.877771 0003 0001 6876
+E: 1304510649.877773 0000 0000 0
+E: 1304510649.882747 0003 0035 16441
+E: 1304510649.882759 0003 0036 6969
+E: 1304510649.882768 0003 0000 16446
+E: 1304510649.882770 0003 0001 6969
+E: 1304510649.882771 0000 0000 0
+E: 1304510649.887748 0003 0035 16438
+E: 1304510649.887759 0003 0036 7035
+E: 1304510649.887769 0003 0000 16444
+E: 1304510649.887770 0003 0001 7035
+E: 1304510649.887772 0000 0000 0
+E: 1304510649.892747 0003 0036 7067
+E: 1304510649.892760 0003 0030 1223
+E: 1304510649.892769 0003 0001 7067
+E: 1304510649.892770 0000 0000 0
+E: 1304510649.897747 0003 0035 16436
+E: 1304510649.897759 0003 0036 7143
+E: 1304510649.897762 0003 0030 1190
+E: 1304510649.897769 0003 0000 16442
+E: 1304510649.897771 0003 0001 7143
+E: 1304510649.897773 0000 0000 0
+E: 1304510649.903736 0003 0035 16434
+E: 1304510649.903747 0003 0036 7207
+E: 1304510649.903756 0003 0000 16440
+E: 1304510649.903758 0003 0001 7207
+E: 1304510649.903760 0000 0000 0
+E: 1304510649.908748 0003 0036 7241
+E: 1304510649.908768 0003 0001 7241
+E: 1304510649.908770 0000 0000 0
+E: 1304510649.913735 0003 0035 16431
+E: 1304510649.913746 0003 0036 7311
+E: 1304510649.913756 0003 0000 16437
+E: 1304510649.913757 0003 0001 7311
+E: 1304510649.913759 0000 0000 0
+E: 1304510649.918747 0003 0035 16428
+E: 1304510649.918759 0003 0036 7383
+E: 1304510649.918762 0003 0030 1323
+E: 1304510649.918769 0003 0000 16434
+E: 1304510649.918771 0003 0001 7383
+E: 1304510649.918773 0000 0000 0
+E: 1304510649.923734 0003 0035 16426
+E: 1304510649.923745 0003 0036 7453
+E: 1304510649.923748 0003 0030 1356
+E: 1304510649.923756 0003 0000 16432
+E: 1304510649.923757 0003 0001 7453
+E: 1304510649.923759 0000 0000 0
+E: 1304510649.928747 0003 0035 16424
+E: 1304510649.928759 0003 0036 7485
+E: 1304510649.928768 0003 0000 16430
+E: 1304510649.928770 0003 0001 7485
+E: 1304510649.928771 0000 0000 0
+E: 1304510649.933734 0003 0035 16422
+E: 1304510649.933746 0003 0036 7557
+E: 1304510649.933755 0003 0000 16428
+E: 1304510649.933757 0003 0001 7557
+E: 1304510649.933759 0000 0000 0
+E: 1304510649.938748 0003 0035 16419
+E: 1304510649.938761 0003 0036 7623
+E: 1304510649.938770 0003 0000 16425
+E: 1304510649.938772 0003 0001 7623
+E: 1304510649.938773 0000 0000 0
+E: 1304510649.943735 0003 0035 16417
+E: 1304510649.943747 0003 0036 7655
+E: 1304510649.943756 0003 0000 16423
+E: 1304510649.943758 0003 0001 7655
+E: 1304510649.943759 0000 0000 0
+E: 1304510649.948766 0003 0035 16414
+E: 1304510649.948779 0003 0036 7723
+E: 1304510649.948788 0003 0000 16420
+E: 1304510649.948790 0003 0001 7723
+E: 1304510649.948792 0000 0000 0
+E: 1304510649.953738 0003 0035 16412
+E: 1304510649.953750 0003 0036 7791
+E: 1304510649.953753 0003 0030 1224
+E: 1304510649.953760 0003 0000 16418
+E: 1304510649.953762 0003 0001 7791
+E: 1304510649.953763 0000 0000 0
+E: 1304510649.958757 0003 0036 7823
+E: 1304510649.958771 0003 0030 1191
+E: 1304510649.958779 0003 0001 7823
+E: 1304510649.958780 0000 0000 0
+E: 1304510649.964759 0003 0036 7893
+E: 1304510649.964780 0003 0001 7893
+E: 1304510649.964782 0000 0000 0
+E: 1304510649.969754 0003 0035 16410
+E: 1304510649.969765 0003 0036 7965
+E: 1304510649.969776 0003 0000 16416
+E: 1304510649.969778 0003 0001 7965
+E: 1304510649.969779 0000 0000 0
+E: 1304510649.974758 0003 0035 16408
+E: 1304510649.974770 0003 0036 8037
+E: 1304510649.974779 0003 0000 16414
+E: 1304510649.974781 0003 0001 8037
+E: 1304510649.974783 0000 0000 0
+E: 1304510649.979758 0003 0036 8105
+E: 1304510649.979771 0003 0030 1323
+E: 1304510649.979779 0003 0001 8105
+E: 1304510649.979781 0000 0000 0
+E: 1304510649.984759 0003 0036 8137
+E: 1304510649.984771 0003 0030 1356
+E: 1304510649.984780 0003 0001 8137
+E: 1304510649.984782 0000 0000 0
+E: 1304510649.989751 0003 0036 8211
+E: 1304510649.989765 0003 0001 8211
+E: 1304510649.989767 0000 0000 0
+E: 1304510649.994736 0003 0035 16406
+E: 1304510649.994744 0003 0036 8283
+E: 1304510649.994757 0003 0000 16412
+E: 1304510649.994764 0003 0001 8283
+E: 1304510649.994766 0000 0000 0
+E: 1304510649.999738 0003 0036 8355
+E: 1304510649.999759 0003 0001 8355
+E: 1304510649.999764 0000 0000 0
+E: 1304510650.004602 0003 0036 8425
+E: 1304510650.004613 0003 0001 8425
+E: 1304510650.004613 0000 0000 0
+E: 1304510650.009715 0003 0035 16404
+E: 1304510650.009719 0003 0036 8493
+E: 1304510650.009727 0003 0000 16410
+E: 1304510650.009728 0003 0001 8493
+E: 1304510650.009728 0000 0000 0
+E: 1304510650.014589 0003 0036 8525
+E: 1304510650.014592 0003 0030 1224
+E: 1304510650.014598 0003 0001 8525
+E: 1304510650.014599 0000 0000 0
+E: 1304510650.020610 0003 0035 16402
+E: 1304510650.020619 0003 0036 8597
+E: 1304510650.020620 0003 0030 1191
+E: 1304510650.020622 0003 0000 16408
+E: 1304510650.020623 0003 0001 8597
+E: 1304510650.020623 0000 0000 0
+E: 1304510650.025601 0003 0036 8671
+E: 1304510650.025612 0003 0001 8671
+E: 1304510650.025613 0000 0000 0
+E: 1304510650.030604 0003 0036 8743
+E: 1304510650.030617 0003 0001 8743
+E: 1304510650.030617 0000 0000 0
+E: 1304510650.035594 0003 0036 8815
+E: 1304510650.035601 0003 0030 1323
+E: 1304510650.035603 0003 0001 8815
+E: 1304510650.035604 0000 0000 0
+E: 1304510650.040607 0003 0036 8891
+E: 1304510650.040615 0003 0030 1356
+E: 1304510650.040619 0003 0001 8891
+E: 1304510650.040619 0000 0000 0
+E: 1304510650.045605 0003 0036 8961
+E: 1304510650.045616 0003 0001 8961
+E: 1304510650.045616 0000 0000 0
+E: 1304510650.050606 0003 0036 9031
+E: 1304510650.050614 0003 0001 9031
+E: 1304510650.050618 0000 0000 0
+E: 1304510650.055591 0003 0036 9103
+E: 1304510650.055601 0003 0001 9103
+E: 1304510650.055602 0000 0000 0
+E: 1304510650.060606 0003 0036 9135
+E: 1304510650.060617 0003 0001 9135
+E: 1304510650.060618 0000 0000 0
+E: 1304510650.065595 0003 0036 9209
+E: 1304510650.065602 0003 0001 9209
+E: 1304510650.065605 0000 0000 0
+E: 1304510650.070607 0003 0036 9279
+E: 1304510650.070615 0003 0030 1224
+E: 1304510650.070618 0003 0001 9279
+E: 1304510650.070619 0000 0000 0
+E: 1304510650.076602 0003 0036 9351
+E: 1304510650.076610 0003 0030 1191
+E: 1304510650.076613 0003 0001 9351
+E: 1304510650.076614 0000 0000 0
+E: 1304510650.081604 0003 0036 9419
+E: 1304510650.081615 0003 0001 9419
+E: 1304510650.081615 0000 0000 0
+E: 1304510650.086607 0003 0036 9493
+E: 1304510650.086617 0003 0001 9493
+E: 1304510650.086618 0000 0000 0
+E: 1304510650.091607 0003 0036 9567
+E: 1304510650.091616 0003 0030 1323
+E: 1304510650.091619 0003 0001 9567
+E: 1304510650.091619 0000 0000 0
+E: 1304510650.096607 0003 0036 9635
+E: 1304510650.096616 0003 0030 1356
+E: 1304510650.096619 0003 0001 9635
+E: 1304510650.096619 0000 0000 0
+E: 1304510650.101602 0003 0036 9701
+E: 1304510650.101614 0003 0001 9701
+E: 1304510650.101614 0000 0000 0
+E: 1304510650.106599 0003 0036 9733
+E: 1304510650.106613 0003 0001 9733
+E: 1304510650.106614 0000 0000 0
+E: 1304510650.111603 0003 0035 16400
+E: 1304510650.111607 0003 0036 9801
+E: 1304510650.111614 0003 0000 16406
+E: 1304510650.111615 0003 0001 9801
+E: 1304510650.111615 0000 0000 0
+E: 1304510650.116667 0003 0035 16398
+E: 1304510650.116671 0003 0036 9833
+E: 1304510650.116675 0003 0000 16404
+E: 1304510650.116675 0003 0001 9833
+E: 1304510650.116676 0000 0000 0
+E: 1304510650.121598 0003 0035 16396
+E: 1304510650.121604 0003 0036 9903
+E: 1304510650.121611 0003 0000 16402
+E: 1304510650.121612 0003 0001 9903
+E: 1304510650.121612 0000 0000 0
+E: 1304510650.126602 0003 0036 9935
+E: 1304510650.126613 0003 0001 9935
+E: 1304510650.126614 0000 0000 0
+E: 1304510650.131602 0003 0035 16394
+E: 1304510650.131611 0003 0036 10013
+E: 1304510650.131612 0003 0030 1224
+E: 1304510650.131615 0003 0000 16400
+E: 1304510650.131616 0003 0001 10013
+E: 1304510650.131616 0000 0000 0
+E: 1304510650.137600 0003 0035 16392
+E: 1304510650.137605 0003 0036 10085
+E: 1304510650.137605 0003 0030 1191
+E: 1304510650.137608 0003 0000 16398
+E: 1304510650.137612 0003 0001 10085
+E: 1304510650.137613 0000 0000 0
+E: 1304510650.142604 0003 0035 16390
+E: 1304510650.142607 0003 0036 10161
+E: 1304510650.142614 0003 0000 16396
+E: 1304510650.142615 0003 0001 10161
+E: 1304510650.142616 0000 0000 0
+E: 1304510650.147598 0003 0035 16388
+E: 1304510650.147602 0003 0036 10233
+E: 1304510650.147607 0003 0030 1323
+E: 1304510650.147609 0003 0000 16394
+E: 1304510650.147610 0003 0001 10233
+E: 1304510650.147610 0000 0000 0
+E: 1304510650.152604 0003 0036 10301
+E: 1304510650.152612 0003 0030 1356
+E: 1304510650.152615 0003 0001 10301
+E: 1304510650.152616 0000 0000 0
+E: 1304510650.157605 0003 0035 16386
+E: 1304510650.157616 0003 0036 10333
+E: 1304510650.157620 0003 0000 16392
+E: 1304510650.157620 0003 0001 10333
+E: 1304510650.157621 0000 0000 0
+E: 1304510650.162597 0003 0036 10401
+E: 1304510650.162610 0003 0001 10401
+E: 1304510650.162610 0000 0000 0
+E: 1304510650.167601 0003 0035 16383
+E: 1304510650.167609 0003 0036 10471
+E: 1304510650.167612 0003 0000 16389
+E: 1304510650.167613 0003 0001 10471
+E: 1304510650.167614 0000 0000 0
+E: 1304510650.172601 0003 0035 16380
+E: 1304510650.172604 0003 0036 10545
+E: 1304510650.172612 0003 0000 16386
+E: 1304510650.172612 0003 0001 10545
+E: 1304510650.172613 0000 0000 0
+E: 1304510650.177599 0003 0035 16377
+E: 1304510650.177608 0003 0036 10611
+E: 1304510650.177611 0003 0000 16383
+E: 1304510650.177612 0003 0001 10611
+E: 1304510650.177612 0000 0000 0
+E: 1304510650.182604 0003 0035 16375
+E: 1304510650.182607 0003 0036 10645
+E: 1304510650.182610 0003 0000 16381
+E: 1304510650.182611 0003 0001 10645
+E: 1304510650.182612 0000 0000 0
+E: 1304510650.187606 0003 0035 16373
+E: 1304510650.187610 0003 0036 10677
+E: 1304510650.187617 0003 0000 16379
+E: 1304510650.187618 0003 0001 10677
+E: 1304510650.187618 0000 0000 0
+E: 1304510650.193603 0003 0035 16370
+E: 1304510650.193607 0003 0036 10747
+E: 1304510650.193608 0003 0030 1224
+E: 1304510650.193610 0003 0000 16376
+E: 1304510650.193611 0003 0001 10747
+E: 1304510650.193612 0000 0000 0
+E: 1304510650.198595 0003 0035 16367
+E: 1304510650.198598 0003 0036 10813
+E: 1304510650.198603 0003 0030 1191
+E: 1304510650.198606 0003 0000 16373
+E: 1304510650.198606 0003 0001 10813
+E: 1304510650.198607 0000 0000 0
+E: 1304510650.203604 0003 0035 16364
+E: 1304510650.203607 0003 0036 10883
+E: 1304510650.203611 0003 0000 16370
+E: 1304510650.203611 0003 0001 10883
+E: 1304510650.203612 0000 0000 0
+E: 1304510650.208600 0003 0035 16362
+E: 1304510650.208604 0003 0036 10955
+E: 1304510650.208605 0003 0030 1323
+E: 1304510650.208607 0003 0000 16368
+E: 1304510650.208608 0003 0001 10955
+E: 1304510650.208608 0000 0000 0
+E: 1304510650.213594 0003 0035 16359
+E: 1304510650.213598 0003 0036 11029
+E: 1304510650.213599 0003 0030 1356
+E: 1304510650.213601 0003 0000 16365
+E: 1304510650.213605 0003 0001 11029
+E: 1304510650.213606 0000 0000 0
+E: 1304510650.218600 0003 0035 16357
+E: 1304510650.218604 0003 0036 11059
+E: 1304510650.218609 0003 0000 16363
+E: 1304510650.218613 0003 0001 11059
+E: 1304510650.218613 0000 0000 0
+E: 1304510650.223597 0003 0035 16355
+E: 1304510650.223601 0003 0036 11129
+E: 1304510650.223604 0003 0000 16361
+E: 1304510650.223605 0003 0001 11129
+E: 1304510650.223605 0000 0000 0
+E: 1304510650.228597 0003 0035 16352
+E: 1304510650.228605 0003 0036 11201
+E: 1304510650.228606 0003 0031 968
+E: 1304510650.228609 0003 0000 16358
+E: 1304510650.228609 0003 0001 11201
+E: 1304510650.228610 0000 0000 0
+E: 1304510650.233596 0003 0035 16349
+E: 1304510650.233601 0003 0036 11269
+E: 1304510650.233602 0003 0031 1008
+E: 1304510650.233604 0003 0000 16355
+E: 1304510650.233605 0003 0001 11269
+E: 1304510650.233606 0000 0000 0
+E: 1304510650.238604 0003 0035 16346
+E: 1304510650.238608 0003 0036 11299
+E: 1304510650.238615 0003 0000 16352
+E: 1304510650.238616 0003 0001 11299
+E: 1304510650.238616 0000 0000 0
+E: 1304510650.243601 0003 0035 16343
+E: 1304510650.243605 0003 0036 11369
+E: 1304510650.243608 0003 0000 16349
+E: 1304510650.243609 0003 0001 11369
+E: 1304510650.243609 0000 0000 0
+E: 1304510650.248597 0003 0035 16340
+E: 1304510650.248600 0003 0036 11447
+E: 1304510650.248605 0003 0034 1
+E: 1304510650.248605 0003 0030 1299
+E: 1304510650.248608 0003 0000 16346
+E: 1304510650.248608 0003 0001 11447
+E: 1304510650.248609 0000 0000 0
+E: 1304510650.254598 0003 0035 16337
+E: 1304510650.254601 0003 0036 11517
+E: 1304510650.254606 0003 0030 1256
+E: 1304510650.254609 0003 0000 16343
+E: 1304510650.254610 0003 0001 11517
+E: 1304510650.254610 0000 0000 0
+E: 1304510650.259599 0003 0035 16333
+E: 1304510650.259608 0003 0036 11595
+E: 1304510650.259612 0003 0000 16340
+E: 1304510650.259612 0003 0001 11595
+E: 1304510650.259613 0000 0000 0
+E: 1304510650.264599 0003 0035 16330
+E: 1304510650.264608 0003 0036 11663
+E: 1304510650.264608 0003 0034 0
+E: 1304510650.264609 0003 0030 1306
+E: 1304510650.264612 0003 0000 16337
+E: 1304510650.264612 0003 0001 11663
+E: 1304510650.264613 0000 0000 0
+E: 1304510650.269601 0003 0035 16327
+E: 1304510650.269604 0003 0036 11731
+E: 1304510650.269610 0003 0030 1343
+E: 1304510650.269612 0003 0000 16334
+E: 1304510650.269613 0003 0001 11731
+E: 1304510650.269613 0000 0000 0
+E: 1304510650.274602 0003 0035 16324
+E: 1304510650.274605 0003 0036 11803
+E: 1304510650.274613 0003 0000 16331
+E: 1304510650.274613 0003 0001 11803
+E: 1304510650.274614 0000 0000 0
+E: 1304510650.279591 0003 0036 11877
+E: 1304510650.279597 0003 0000 16329
+E: 1304510650.279597 0003 0001 11877
+E: 1304510650.279598 0000 0000 0
+E: 1304510650.284598 0003 0035 16322
+E: 1304510650.284602 0003 0036 11947
+E: 1304510650.284605 0003 0000 16327
+E: 1304510650.284605 0003 0001 11947
+E: 1304510650.284606 0000 0000 0
+E: 1304510650.289602 0003 0035 16320
+E: 1304510650.289607 0003 0036 12025
+E: 1304510650.289614 0003 0000 16325
+E: 1304510650.289615 0003 0001 12025
+E: 1304510650.289615 0000 0000 0
+E: 1304510650.294599 0003 0035 16318
+E: 1304510650.294602 0003 0036 12097
+E: 1304510650.294610 0003 0000 16323
+E: 1304510650.294610 0003 0001 12097
+E: 1304510650.294611 0000 0000 0
+E: 1304510650.299597 0003 0035 16316
+E: 1304510650.299601 0003 0036 12169
+E: 1304510650.299606 0003 0034 1
+E: 1304510650.299606 0003 0030 1289
+E: 1304510650.299609 0003 0000 16321
+E: 1304510650.299609 0003 0001 12169
+E: 1304510650.299610 0000 0000 0
+E: 1304510650.304599 0003 0036 12243
+E: 1304510650.304604 0003 0030 1249
+E: 1304510650.304607 0003 0001 12243
+E: 1304510650.304611 0000 0000 0
+E: 1304510650.310596 0003 0035 16314
+E: 1304510650.310602 0003 0036 12311
+E: 1304510650.310610 0003 0000 16319
+E: 1304510650.310610 0003 0001 12311
+E: 1304510650.310611 0000 0000 0
+E: 1304510650.315595 0003 0035 16312
+E: 1304510650.315599 0003 0036 12387
+E: 1304510650.315604 0003 0034 0
+E: 1304510650.315605 0003 0030 1300
+E: 1304510650.315607 0003 0000 16317
+E: 1304510650.315608 0003 0001 12387
+E: 1304510650.315608 0000 0000 0
+E: 1304510650.320596 0003 0036 12461
+E: 1304510650.320605 0003 0030 1339
+E: 1304510650.320608 0003 0001 12461
+E: 1304510650.320608 0000 0000 0
+E: 1304510650.325597 0003 0036 12535
+E: 1304510650.325608 0003 0001 12535
+E: 1304510650.325609 0000 0000 0
+E: 1304510650.330598 0003 0036 12607
+E: 1304510650.330609 0003 0001 12607
+E: 1304510650.330610 0000 0000 0
+E: 1304510650.335605 0003 0036 12683
+E: 1304510650.335616 0003 0001 12683
+E: 1304510650.335617 0000 0000 0
+E: 1304510650.340583 0003 0036 12761
+E: 1304510650.340588 0003 0001 12761
+E: 1304510650.340588 0000 0000 0
+E: 1304510650.345597 0003 0036 12837
+E: 1304510650.345608 0003 0001 12837
+E: 1304510650.345609 0000 0000 0
+E: 1304510650.350595 0003 0036 12907
+E: 1304510650.350603 0003 0034 1
+E: 1304510650.350604 0003 0030 1286
+E: 1304510650.350607 0003 0001 12907
+E: 1304510650.350607 0000 0000 0
+E: 1304510650.355599 0003 0036 12977
+E: 1304510650.355607 0003 0030 1247
+E: 1304510650.355611 0003 0001 12977
+E: 1304510650.355611 0000 0000 0
+E: 1304510650.360596 0003 0036 13055
+E: 1304510650.360605 0003 0034 0
+E: 1304510650.360605 0003 0030 1208
+E: 1304510650.360609 0003 0001 13055
+E: 1304510650.360610 0000 0000 0
+E: 1304510650.366588 0003 0036 13133
+E: 1304510650.366592 0003 0030 1270
+E: 1304510650.366598 0003 0001 13133
+E: 1304510650.366598 0000 0000 0
+E: 1304510650.371595 0003 0036 13207
+E: 1304510650.371603 0003 0030 1316
+E: 1304510650.371606 0003 0001 13207
+E: 1304510650.371606 0000 0000 0
+E: 1304510650.376604 0003 0035 16314
+E: 1304510650.376612 0003 0036 13281
+E: 1304510650.376614 0003 0030 1351
+E: 1304510650.376617 0003 0001 13281
+E: 1304510650.376617 0000 0000 0
+E: 1304510650.381583 0003 0035 16316
+E: 1304510650.381586 0003 0036 13359
+E: 1304510650.381592 0003 0001 13359
+E: 1304510650.381592 0000 0000 0
+E: 1304510650.386599 0003 0035 16318
+E: 1304510650.386604 0003 0036 13433
+E: 1304510650.386611 0003 0001 13433
+E: 1304510650.386612 0000 0000 0
+E: 1304510650.391587 0003 0035 16320
+E: 1304510650.391589 0003 0036 13511
+E: 1304510650.391597 0003 0001 13511
+E: 1304510650.391597 0000 0000 0
+E: 1304510650.396603 0003 0035 16323
+E: 1304510650.396606 0003 0036 13593
+E: 1304510650.396611 0003 0030 1221
+E: 1304510650.396614 0003 0001 13593
+E: 1304510650.396615 0000 0000 0
+E: 1304510650.401591 0003 0035 16325
+E: 1304510650.401595 0003 0036 13669
+E: 1304510650.401600 0003 0030 1188
+E: 1304510650.401602 0003 0000 16319
+E: 1304510650.401603 0003 0001 13669
+E: 1304510650.401604 0000 0000 0
+E: 1304510650.406597 0003 0035 16328
+E: 1304510650.406601 0003 0036 13751
+E: 1304510650.406608 0003 0000 16321
+E: 1304510650.406609 0003 0001 13751
+E: 1304510650.406609 0000 0000 0
+E: 1304510650.411595 0003 0035 16336
+E: 1304510650.411603 0003 0036 13831
+E: 1304510650.411604 0003 0030 1322
+E: 1304510650.411607 0003 0000 16328
+E: 1304510650.411607 0003 0001 13831
+E: 1304510650.411608 0000 0000 0
+E: 1304510650.416593 0003 0035 16339
+E: 1304510650.416596 0003 0036 13911
+E: 1304510650.416601 0003 0030 1355
+E: 1304510650.416603 0003 0000 16330
+E: 1304510650.416604 0003 0001 13911
+E: 1304510650.416605 0000 0000 0
+E: 1304510650.421595 0003 0035 16346
+E: 1304510650.421598 0003 0036 13995
+E: 1304510650.421605 0003 0000 16338
+E: 1304510650.421606 0003 0001 13995
+E: 1304510650.421607 0000 0000 0
+E: 1304510650.427596 0003 0035 16349
+E: 1304510650.427600 0003 0036 14073
+E: 1304510650.427608 0003 0000 16340
+E: 1304510650.427608 0003 0001 14073
+E: 1304510650.427609 0000 0000 0
+E: 1304510650.432589 0003 0035 16352
+E: 1304510650.432592 0003 0036 14151
+E: 1304510650.432599 0003 0000 16343
+E: 1304510650.432599 0003 0001 14151
+E: 1304510650.432600 0000 0000 0
+E: 1304510650.437603 0003 0035 16355
+E: 1304510650.437607 0003 0036 14233
+E: 1304510650.437614 0003 0000 16346
+E: 1304510650.437615 0003 0001 14233
+E: 1304510650.437615 0000 0000 0
+E: 1304510650.442592 0003 0035 16358
+E: 1304510650.442595 0003 0036 14315
+E: 1304510650.442600 0003 0030 1223
+E: 1304510650.442602 0003 0000 16349
+E: 1304510650.442603 0003 0001 14315
+E: 1304510650.442604 0000 0000 0
+E: 1304510650.447600 0003 0035 16366
+E: 1304510650.447604 0003 0036 14395
+E: 1304510650.447608 0003 0030 1190
+E: 1304510650.447611 0003 0000 16357
+E: 1304510650.447612 0003 0001 14395
+E: 1304510650.447612 0000 0000 0
+E: 1304510650.452590 0003 0035 16369
+E: 1304510650.452599 0003 0036 14481
+E: 1304510650.452602 0003 0000 16360
+E: 1304510650.452603 0003 0001 14481
+E: 1304510650.452603 0000 0000 0
+E: 1304510650.457599 0003 0035 16372
+E: 1304510650.457603 0003 0036 14565
+E: 1304510650.457608 0003 0030 1323
+E: 1304510650.457611 0003 0000 16363
+E: 1304510650.457611 0003 0001 14565
+E: 1304510650.457612 0000 0000 0
+E: 1304510650.462602 0003 0035 16375
+E: 1304510650.462605 0003 0036 14651
+E: 1304510650.462611 0003 0030 1356
+E: 1304510650.462613 0003 0000 16366
+E: 1304510650.462614 0003 0001 14651
+E: 1304510650.462615 0000 0000 0
+E: 1304510650.467593 0003 0035 16378
+E: 1304510650.467597 0003 0036 14741
+E: 1304510650.467605 0003 0000 16369
+E: 1304510650.467605 0003 0001 14741
+E: 1304510650.467606 0000 0000 0
+E: 1304510650.472596 0003 0035 16381
+E: 1304510650.472604 0003 0036 14823
+E: 1304510650.472607 0003 0000 16372
+E: 1304510650.472608 0003 0001 14823
+E: 1304510650.472608 0000 0000 0
+E: 1304510650.477595 0003 0035 16384
+E: 1304510650.477599 0003 0036 14909
+E: 1304510650.477606 0003 0000 16375
+E: 1304510650.477607 0003 0001 14909
+E: 1304510650.477607 0000 0000 0
+E: 1304510650.482600 0003 0035 16387
+E: 1304510650.482603 0003 0036 14993
+E: 1304510650.482609 0003 0030 1224
+E: 1304510650.482612 0003 0000 16378
+E: 1304510650.482612 0003 0001 14993
+E: 1304510650.482613 0000 0000 0
+E: 1304510650.488595 0003 0035 16389
+E: 1304510650.488599 0003 0036 15075
+E: 1304510650.488605 0003 0030 1191
+E: 1304510650.488607 0003 0000 16380
+E: 1304510650.488608 0003 0001 15075
+E: 1304510650.488608 0000 0000 0
+E: 1304510650.493594 0003 0035 16391
+E: 1304510650.493597 0003 0036 15157
+E: 1304510650.493601 0003 0000 16382
+E: 1304510650.493601 0003 0001 15157
+E: 1304510650.493602 0000 0000 0
+E: 1304510650.498600 0003 0035 16398
+E: 1304510650.498604 0003 0036 15243
+E: 1304510650.498609 0003 0030 1323
+E: 1304510650.498612 0003 0000 16390
+E: 1304510650.498613 0003 0001 15243
+E: 1304510650.498614 0000 0000 0
+E: 1304510650.503583 0003 0035 16400
+E: 1304510650.503586 0003 0036 15329
+E: 1304510650.503586 0003 0030 1356
+E: 1304510650.503589 0003 0000 16392
+E: 1304510650.503589 0003 0001 15329
+E: 1304510650.503590 0000 0000 0
+E: 1304510650.508595 0003 0035 16402
+E: 1304510650.508604 0003 0036 15413
+E: 1304510650.508607 0003 0000 16394
+E: 1304510650.508608 0003 0001 15413
+E: 1304510650.508608 0000 0000 0
+E: 1304510650.513590 0003 0035 16404
+E: 1304510650.513594 0003 0036 15497
+E: 1304510650.513597 0003 0000 16396
+E: 1304510650.513604 0003 0001 15497
+E: 1304510650.513604 0000 0000 0
+E: 1304510650.518591 0003 0035 16406
+E: 1304510650.518597 0003 0036 15583
+E: 1304510650.518604 0003 0000 16398
+E: 1304510650.518604 0003 0001 15583
+E: 1304510650.518605 0000 0000 0
+E: 1304510650.523595 0003 0035 16408
+E: 1304510650.523598 0003 0036 15663
+E: 1304510650.523602 0003 0000 16400
+E: 1304510650.523602 0003 0001 15663
+E: 1304510650.523603 0000 0000 0
+E: 1304510650.528592 0003 0035 16410
+E: 1304510650.528596 0003 0036 15739
+E: 1304510650.528601 0003 0030 1224
+E: 1304510650.528603 0003 0000 16402
+E: 1304510650.528604 0003 0001 15739
+E: 1304510650.528604 0000 0000 0
+E: 1304510650.533597 0003 0035 16412
+E: 1304510650.533601 0003 0036 15823
+E: 1304510650.533602 0003 0030 1191
+E: 1304510650.533605 0003 0000 16404
+E: 1304510650.533606 0003 0001 15823
+E: 1304510650.533606 0000 0000 0
+E: 1304510650.538595 0003 0036 15913
+E: 1304510650.538606 0003 0000 16406
+E: 1304510650.538606 0003 0001 15913
+E: 1304510650.538607 0000 0000 0
+E: 1304510650.544594 0003 0035 16414
+E: 1304510650.544602 0003 0036 15991
+E: 1304510650.544603 0003 0030 1323
+E: 1304510650.544606 0003 0000 16408
+E: 1304510650.544606 0003 0001 15991
+E: 1304510650.544607 0000 0000 0
+E: 1304510650.549590 0003 0035 16416
+E: 1304510650.549596 0003 0036 16069
+E: 1304510650.549601 0003 0030 1356
+E: 1304510650.549604 0003 0000 16410
+E: 1304510650.549604 0003 0001 16069
+E: 1304510650.549605 0000 0000 0
+E: 1304510650.554589 0003 0036 16143
+E: 1304510650.554600 0003 0001 16143
+E: 1304510650.554601 0000 0000 0
+E: 1304510650.559595 0003 0036 16219
+E: 1304510650.559606 0003 0001 16219
+E: 1304510650.559607 0000 0000 0
+E: 1304510650.564589 0003 0035 16418
+E: 1304510650.564592 0003 0036 16299
+E: 1304510650.564599 0003 0000 16412
+E: 1304510650.564600 0003 0001 16299
+E: 1304510650.564600 0000 0000 0
+E: 1304510650.569595 0003 0036 16373
+E: 1304510650.569607 0003 0001 16373
+E: 1304510650.569607 0000 0000 0
+E: 1304510650.574584 0003 0036 16445
+E: 1304510650.574595 0003 0001 16445
+E: 1304510650.574596 0000 0000 0
+E: 1304510650.579603 0003 0036 16515
+E: 1304510650.579612 0003 0030 1224
+E: 1304510650.579616 0003 0001 16515
+E: 1304510650.579616 0000 0000 0
+E: 1304510650.584585 0003 0036 16585
+E: 1304510650.584592 0003 0030 1191
+E: 1304510650.584595 0003 0001 16585
+E: 1304510650.584595 0000 0000 0
+E: 1304510650.589596 0003 0036 16651
+E: 1304510650.589607 0003 0001 16651
+E: 1304510650.589607 0000 0000 0
+E: 1304510650.594594 0003 0035 16420
+E: 1304510650.594598 0003 0036 16717
+E: 1304510650.594605 0003 0000 16414
+E: 1304510650.594606 0003 0001 16717
+E: 1304510650.594606 0000 0000 0
+E: 1304510650.599594 0003 0035 16422
+E: 1304510650.599598 0003 0036 16785
+E: 1304510650.599606 0003 0000 16416
+E: 1304510650.599606 0003 0001 16785
+E: 1304510650.599607 0000 0000 0
+E: 1304510650.605591 0003 0036 16799
+E: 1304510650.605603 0003 0001 16788
+E: 1304510650.605604 0000 0000 0
+E: 1304510650.610593 0003 0036 16847
+E: 1304510650.610602 0003 0030 1323
+E: 1304510650.610605 0003 0001 16847
+E: 1304510650.610605 0000 0000 0
+E: 1304510650.615590 0003 0035 16424
+E: 1304510650.615593 0003 0036 16877
+E: 1304510650.615598 0003 0030 1356
+E: 1304510650.615600 0003 0000 16418
+E: 1304510650.615601 0003 0001 16877
+E: 1304510650.615601 0000 0000 0
+E: 1304510650.620599 0003 0036 16907
+E: 1304510650.620610 0003 0001 16907
+E: 1304510650.620611 0000 0000 0
+E: 1304510650.625583 0003 0035 16426
+E: 1304510650.625587 0003 0036 16939
+E: 1304510650.625595 0003 0000 16420
+E: 1304510650.625595 0003 0001 16939
+E: 1304510650.625596 0000 0000 0
+E: 1304510650.630596 0003 0036 16971
+E: 1304510650.630609 0003 0001 16971
+E: 1304510650.630610 0000 0000 0
+E: 1304510650.635591 0003 0036 16985
+E: 1304510650.635602 0003 0001 16974
+E: 1304510650.635602 0000 0000 0
+E: 1304510650.640593 0003 0036 17031
+E: 1304510650.640606 0003 0001 17031
+E: 1304510650.640606 0000 0000 0
+E: 1304510650.645582 0003 0036 17061
+E: 1304510650.645592 0003 0001 17061
+E: 1304510650.645593 0000 0000 0
+E: 1304510650.650594 0003 0036 17131
+E: 1304510650.650606 0003 0001 17131
+E: 1304510650.650607 0000 0000 0
+E: 1304510650.655591 0003 0036 17144
+E: 1304510650.655601 0003 0001 17134
+E: 1304510650.655602 0000 0000 0
+E: 1304510650.661592 0003 0036 17179
+E: 1304510650.661604 0003 0001 17179
+E: 1304510650.661604 0000 0000 0
+E: 1304510650.666588 0003 0036 17190
+E: 1304510650.666598 0003 0001 17181
+E: 1304510650.666599 0000 0000 0
+E: 1304510650.671593 0003 0036 17227
+E: 1304510650.671604 0003 0001 17227
+E: 1304510650.671605 0000 0000 0
+E: 1304510650.676593 0003 0036 17238
+E: 1304510650.676606 0003 0001 17229
+E: 1304510650.676607 0000 0000 0
+E: 1304510650.681593 0003 0036 17269
+E: 1304510650.681604 0003 0001 17269
+E: 1304510650.681605 0000 0000 0
+E: 1304510650.686589 0003 0036 17279
+E: 1304510650.686601 0003 0001 17271
+E: 1304510650.686601 0000 0000 0
+E: 1304510650.691597 0003 0036 17309
+E: 1304510650.691610 0003 0001 17309
+E: 1304510650.691610 0000 0000 0
+E: 1304510650.696585 0003 0036 17319
+E: 1304510650.696595 0003 0001 17311
+E: 1304510650.696595 0000 0000 0
+E: 1304510650.701592 0003 0036 17333
+E: 1304510650.701603 0003 0001 17322
+E: 1304510650.701604 0000 0000 0
+E: 1304510650.706578 0003 0036 17363
+E: 1304510650.706587 0003 0001 17363
+E: 1304510650.706588 0000 0000 0
+E: 1304510650.711595 0003 0036 17372
+E: 1304510650.711607 0003 0001 17365
+E: 1304510650.711607 0000 0000 0
+E: 1304510650.717594 0003 0036 17375
+E: 1304510650.717601 0003 0001 17367
+E: 1304510650.717602 0000 0000 0
+E: 1304510650.722591 0003 0036 17378
+E: 1304510650.722598 0003 0001 17369
+E: 1304510650.722599 0000 0000 0
+E: 1304510650.727591 0003 0036 17386
+E: 1304510650.727602 0003 0001 17377
+E: 1304510650.727603 0000 0000 0
+E: 1304510650.732591 0003 0036 17389
+E: 1304510650.732602 0003 0001 17380
+E: 1304510650.732603 0000 0000 0
+E: 1304510650.737590 0003 0036 17392
+E: 1304510650.737601 0003 0001 17383
+E: 1304510650.737601 0000 0000 0
+E: 1304510650.742591 0003 0036 17395
+E: 1304510650.742603 0003 0001 17386
+E: 1304510650.742603 0000 0000 0
+E: 1304510650.747575 0003 0036 17398
+E: 1304510650.747583 0003 0001 17389
+E: 1304510650.747583 0000 0000 0
+E: 1304510650.752592 0003 0036 17401
+E: 1304510650.752603 0003 0001 17392
+E: 1304510650.752604 0000 0000 0
+E: 1304510650.757587 0003 0036 17404
+E: 1304510650.757598 0003 0001 17395
+E: 1304510650.757599 0000 0000 0
+E: 1304510650.762594 0003 0036 17406
+E: 1304510650.762601 0003 0001 17397
+E: 1304510650.762602 0000 0000 0
+E: 1304510650.767584 0003 0036 17408
+E: 1304510650.767591 0003 0001 17399
+E: 1304510650.767595 0000 0000 0
+E: 1304510650.772601 0003 0036 17410
+E: 1304510650.772611 0003 0001 17401
+E: 1304510650.772611 0000 0000 0
+E: 1304510650.778599 0003 0036 17413
+E: 1304510650.778607 0003 0001 17404
+E: 1304510650.778608 0000 0000 0
+E: 1304510650.783591 0003 0036 17415
+E: 1304510650.783600 0003 0001 17406
+E: 1304510650.783600 0000 0000 0
+E: 1304510650.788598 0003 0036 17417
+E: 1304510650.788607 0003 0001 17408
+E: 1304510650.788608 0000 0000 0
+E: 1304510650.793591 0003 0036 17419
+E: 1304510650.793600 0003 0001 17410
+E: 1304510650.793601 0000 0000 0
+E: 1304510650.798597 0003 0036 17421
+E: 1304510650.798606 0003 0001 17412
+E: 1304510650.798606 0000 0000 0
+E: 1304510650.803590 0003 0036 17423
+E: 1304510650.803599 0003 0001 17414
+E: 1304510650.803600 0000 0000 0
+E: 1304510650.808602 0003 0001 17416
+E: 1304510650.808609 0000 0000 0
+E: 1304510650.813591 0003 0036 17425
+E: 1304510650.813600 0003 0001 17418
+E: 1304510650.813600 0000 0000 0
+E: 1304510650.818601 0003 0001 17419
+E: 1304510650.818607 0000 0000 0
+E: 1304510650.854591 0003 0030 1224
+E: 1304510650.854596 0000 0000 0
+E: 1304510650.859598 0003 0030 1191
+E: 1304510650.859607 0000 0000 0
+E: 1304510650.864596 0003 0036 17412
+E: 1304510650.864604 0003 0001 17417
+E: 1304510650.864605 0000 0000 0
+E: 1304510650.869597 0003 0036 17377
+E: 1304510650.869606 0003 0001 17377
+E: 1304510650.869606 0000 0000 0
+E: 1304510650.874596 0003 0036 17364
+E: 1304510650.874604 0003 0001 17373
+E: 1304510650.874605 0000 0000 0
+E: 1304510650.879591 0003 0036 17323
+E: 1304510650.879600 0003 0030 1323
+E: 1304510650.879603 0003 0001 17323
+E: 1304510650.879604 0000 0000 0
+E: 1304510650.884710 0003 0036 17291
+E: 1304510650.884718 0003 0030 1356
+E: 1304510650.884729 0003 0001 17291
+E: 1304510650.884731 0000 0000 0
+E: 1304510650.889723 0003 0036 17277
+E: 1304510650.889743 0003 0001 17287
+E: 1304510650.889745 0000 0000 0
+E: 1304510650.895587 0003 0036 17195
+E: 1304510650.895599 0003 0001 17195
+E: 1304510650.895600 0000 0000 0
+E: 1304510650.900591 0003 0036 17129
+E: 1304510650.900602 0003 0001 17129
+E: 1304510650.900603 0000 0000 0
+E: 1304510650.905585 0003 0036 17059
+E: 1304510650.905599 0003 0001 17059
+E: 1304510650.905600 0000 0000 0
+E: 1304510650.910589 0003 0036 17029
+E: 1304510650.910600 0003 0030 1224
+E: 1304510650.910603 0003 0001 17029
+E: 1304510650.910603 0000 0000 0
+E: 1304510650.915584 0003 0036 16961
+E: 1304510650.915592 0003 0030 1191
+E: 1304510650.915595 0003 0001 16961
+E: 1304510650.915596 0000 0000 0
+E: 1304510650.920587 0003 0036 16891
+E: 1304510650.920597 0003 0001 16891
+E: 1304510650.920598 0000 0000 0
+E: 1304510650.925587 0003 0036 16821
+E: 1304510650.925598 0003 0001 16821
+E: 1304510650.925599 0000 0000 0
+E: 1304510650.930586 0003 0036 16755
+E: 1304510650.930597 0003 0001 16755
+E: 1304510650.930598 0000 0000 0
+E: 1304510650.935586 0003 0036 16689
+E: 1304510650.935599 0003 0001 16689
+E: 1304510650.935600 0000 0000 0
+E: 1304510650.940588 0003 0036 16621
+E: 1304510650.940596 0003 0030 1323
+E: 1304510650.940599 0003 0001 16621
+E: 1304510650.940600 0000 0000 0
+E: 1304510650.945592 0003 0036 16589
+E: 1304510650.945598 0003 0030 1356
+E: 1304510650.945601 0003 0001 16589
+E: 1304510650.945607 0000 0000 0
+E: 1304510650.951584 0003 0036 16515
+E: 1304510650.951594 0003 0001 16515
+E: 1304510650.951595 0000 0000 0
+E: 1304510650.956584 0003 0036 16445
+E: 1304510650.956595 0003 0001 16445
+E: 1304510650.956595 0000 0000 0
+E: 1304510650.961588 0003 0036 16373
+E: 1304510650.961599 0003 0001 16373
+E: 1304510650.961599 0000 0000 0
+E: 1304510650.966573 0003 0036 16303
+E: 1304510650.966577 0003 0030 1224
+E: 1304510650.966583 0003 0001 16303
+E: 1304510650.966584 0000 0000 0
+E: 1304510650.971589 0003 0036 16233
+E: 1304510650.971598 0003 0030 1191
+E: 1304510650.971602 0003 0001 16233
+E: 1304510650.971602 0000 0000 0
+E: 1304510650.976582 0003 0036 16151
+E: 1304510650.976593 0003 0001 16151
+E: 1304510650.976594 0000 0000 0
+E: 1304510650.981590 0003 0036 16071
+E: 1304510650.981602 0003 0001 16071
+E: 1304510650.981602 0000 0000 0
+E: 1304510650.986585 0003 0036 15985
+E: 1304510650.986594 0003 0030 1323
+E: 1304510650.986597 0003 0001 15985
+E: 1304510650.986597 0000 0000 0
+E: 1304510650.991582 0003 0036 15903
+E: 1304510650.991593 0003 0030 1356
+E: 1304510650.991596 0003 0001 15903
+E: 1304510650.991597 0000 0000 0
+E: 1304510650.996583 0003 0036 15819
+E: 1304510650.996594 0003 0001 15819
+E: 1304510650.996594 0000 0000 0
+E: 1304510651.001590 0003 0036 15733
+E: 1304510651.001601 0003 0001 15733
+E: 1304510651.001601 0000 0000 0
+E: 1304510651.006580 0003 0036 15647
+E: 1304510651.006589 0003 0030 1224
+E: 1304510651.006592 0003 0001 15647
+E: 1304510651.006593 0000 0000 0
+E: 1304510651.012590 0003 0036 15567
+E: 1304510651.012599 0003 0030 1191
+E: 1304510651.012602 0003 0001 15567
+E: 1304510651.012603 0000 0000 0
+E: 1304510651.017592 0003 0036 15481
+E: 1304510651.017604 0003 0001 15481
+E: 1304510651.017605 0000 0000 0
+E: 1304510651.022587 0003 0036 15397
+E: 1304510651.022598 0003 0001 15397
+E: 1304510651.022599 0000 0000 0
+E: 1304510651.027589 0003 0036 15317
+E: 1304510651.027597 0003 0030 1323
+E: 1304510651.027600 0003 0001 15317
+E: 1304510651.027600 0000 0000 0
+E: 1304510651.032586 0003 0036 15233
+E: 1304510651.032594 0003 0030 1356
+E: 1304510651.032597 0003 0001 15233
+E: 1304510651.032597 0000 0000 0
+E: 1304510651.037583 0003 0035 16424
+E: 1304510651.037589 0003 0036 15155
+E: 1304510651.037592 0003 0001 15155
+E: 1304510651.037597 0000 0000 0
+E: 1304510651.042583 0003 0035 16422
+E: 1304510651.042592 0003 0036 15081
+E: 1304510651.042596 0003 0001 15081
+E: 1304510651.042596 0000 0000 0
+E: 1304510651.047582 0003 0035 16420
+E: 1304510651.047586 0003 0036 15005
+E: 1304510651.047594 0003 0001 15005
+E: 1304510651.047594 0000 0000 0
+E: 1304510651.052592 0003 0035 16418
+E: 1304510651.052600 0003 0036 14933
+E: 1304510651.052607 0003 0001 14933
+E: 1304510651.052608 0000 0000 0
+E: 1304510651.057587 0003 0035 16416
+E: 1304510651.057595 0003 0036 14857
+E: 1304510651.057596 0003 0030 1224
+E: 1304510651.057599 0003 0001 14857
+E: 1304510651.057599 0000 0000 0
+E: 1304510651.062586 0003 0036 14785
+E: 1304510651.062590 0003 0030 1191
+E: 1304510651.062593 0003 0001 14785
+E: 1304510651.062594 0000 0000 0
+E: 1304510651.068589 0003 0036 14703
+E: 1304510651.068601 0003 0001 14703
+E: 1304510651.068602 0000 0000 0
+E: 1304510651.073586 0003 0035 16414
+E: 1304510651.073590 0003 0036 14625
+E: 1304510651.073594 0003 0001 14625
+E: 1304510651.073598 0000 0000 0
+E: 1304510651.078582 0003 0036 14543
+E: 1304510651.078592 0003 0030 1323
+E: 1304510651.078594 0003 0001 14543
+E: 1304510651.078595 0000 0000 0
+E: 1304510651.083580 0003 0035 16412
+E: 1304510651.083584 0003 0036 14455
+E: 1304510651.083585 0003 0030 1356
+E: 1304510651.083588 0003 0000 16418
+E: 1304510651.083588 0003 0001 14455
+E: 1304510651.083589 0000 0000 0
+E: 1304510651.088582 0003 0035 16410
+E: 1304510651.088586 0003 0036 14369
+E: 1304510651.088593 0003 0000 16416
+E: 1304510651.088594 0003 0001 14369
+E: 1304510651.088594 0000 0000 0
+E: 1304510651.093585 0003 0035 16407
+E: 1304510651.093589 0003 0036 14287
+E: 1304510651.093592 0003 0000 16413
+E: 1304510651.093592 0003 0001 14287
+E: 1304510651.093593 0000 0000 0
+E: 1304510651.098568 0003 0035 16404
+E: 1304510651.098571 0003 0036 14201
+E: 1304510651.098572 0003 0030 1224
+E: 1304510651.098577 0003 0000 16410
+E: 1304510651.098578 0003 0001 14201
+E: 1304510651.098578 0000 0000 0
+E: 1304510651.103585 0003 0035 16401
+E: 1304510651.103589 0003 0036 14107
+E: 1304510651.103590 0003 0030 1191
+E: 1304510651.103593 0003 0000 16407
+E: 1304510651.103593 0003 0001 14107
+E: 1304510651.103594 0000 0000 0
+E: 1304510651.108575 0003 0035 16398
+E: 1304510651.108578 0003 0036 14011
+E: 1304510651.108585 0003 0000 16404
+E: 1304510651.108586 0003 0001 14011
+E: 1304510651.108586 0000 0000 0
+E: 1304510651.113586 0003 0035 16395
+E: 1304510651.113591 0003 0036 13921
+E: 1304510651.113592 0003 0030 1323
+E: 1304510651.113595 0003 0000 16401
+E: 1304510651.113595 0003 0001 13921
+E: 1304510651.113596 0000 0000 0
+E: 1304510651.118584 0003 0035 16391
+E: 1304510651.118589 0003 0036 13831
+E: 1304510651.118590 0003 0030 1356
+E: 1304510651.118592 0003 0000 16398
+E: 1304510651.118595 0003 0001 13831
+E: 1304510651.118596 0000 0000 0
+E: 1304510651.124590 0003 0035 16383
+E: 1304510651.124594 0003 0036 13745
+E: 1304510651.124597 0003 0000 16390
+E: 1304510651.124600 0003 0001 13745
+E: 1304510651.124601 0000 0000 0
+E: 1304510651.129568 0003 0035 16380
+E: 1304510651.129571 0003 0036 13655
+E: 1304510651.129578 0003 0000 16387
+E: 1304510651.129578 0003 0001 13655
+E: 1304510651.129578 0000 0000 0
+E: 1304510651.134582 0003 0035 16376
+E: 1304510651.134586 0003 0036 13563
+E: 1304510651.134593 0003 0000 16384
+E: 1304510651.134594 0003 0001 13563
+E: 1304510651.134594 0000 0000 0
+E: 1304510651.139578 0003 0035 16368
+E: 1304510651.139583 0003 0036 13473
+E: 1304510651.139588 0003 0034 1
+E: 1304510651.139588 0003 0030 1299
+E: 1304510651.139591 0003 0000 16376
+E: 1304510651.139592 0003 0001 13473
+E: 1304510651.139593 0000 0000 0
+E: 1304510651.144581 0003 0035 16365
+E: 1304510651.144585 0003 0036 13383
+E: 1304510651.144590 0003 0030 1256
+E: 1304510651.144592 0003 0000 16373
+E: 1304510651.144593 0003 0001 13383
+E: 1304510651.144594 0000 0000 0
+E: 1304510651.149583 0003 0035 16357
+E: 1304510651.149587 0003 0036 13291
+E: 1304510651.149594 0003 0000 16365
+E: 1304510651.149595 0003 0001 13291
+E: 1304510651.149596 0000 0000 0
+E: 1304510651.154588 0003 0035 16354
+E: 1304510651.154598 0003 0036 13195
+E: 1304510651.154599 0003 0034 0
+E: 1304510651.154600 0003 0030 1306
+E: 1304510651.154603 0003 0000 16362
+E: 1304510651.154604 0003 0001 13195
+E: 1304510651.154604 0000 0000 0
+E: 1304510651.159587 0003 0035 16351
+E: 1304510651.159591 0003 0036 13107
+E: 1304510651.159596 0003 0030 1343
+E: 1304510651.159599 0003 0000 16359
+E: 1304510651.159599 0003 0001 13107
+E: 1304510651.159600 0000 0000 0
+E: 1304510651.164588 0003 0035 16348
+E: 1304510651.164593 0003 0036 13017
+E: 1304510651.164600 0003 0000 16356
+E: 1304510651.164601 0003 0001 13017
+E: 1304510651.164601 0000 0000 0
+E: 1304510651.169570 0003 0035 16344
+E: 1304510651.169577 0003 0036 12931
+E: 1304510651.169580 0003 0000 16353
+E: 1304510651.169580 0003 0001 12931
+E: 1304510651.169581 0000 0000 0
+E: 1304510651.174584 0003 0035 16340
+E: 1304510651.174592 0003 0036 12851
+E: 1304510651.174596 0003 0000 16349
+E: 1304510651.174596 0003 0001 12851
+E: 1304510651.174597 0000 0000 0
+E: 1304510651.179581 0003 0035 16336
+E: 1304510651.179585 0003 0036 12775
+E: 1304510651.179592 0003 0000 16345
+E: 1304510651.179593 0003 0001 12775
+E: 1304510651.179594 0000 0000 0
+E: 1304510651.185588 0003 0035 16328
+E: 1304510651.185592 0003 0036 12697
+E: 1304510651.185597 0003 0034 1
+E: 1304510651.185598 0003 0030 1289
+E: 1304510651.185601 0003 0000 16336
+E: 1304510651.185601 0003 0001 12697
+E: 1304510651.185602 0000 0000 0
+E: 1304510651.190567 0003 0035 16325
+E: 1304510651.190574 0003 0036 12617
+E: 1304510651.190575 0003 0030 1249
+E: 1304510651.190577 0003 0000 16333
+E: 1304510651.190577 0003 0001 12617
+E: 1304510651.190578 0000 0000 0
+E: 1304510651.195586 0003 0035 16322
+E: 1304510651.195590 0003 0036 12533
+E: 1304510651.195597 0003 0000 16330
+E: 1304510651.195598 0003 0001 12533
+E: 1304510651.195598 0000 0000 0
+E: 1304510651.200572 0003 0035 16319
+E: 1304510651.200580 0003 0036 12451
+E: 1304510651.200583 0003 0000 16327
+E: 1304510651.200583 0003 0001 12451
+E: 1304510651.200584 0000 0000 0
+E: 1304510651.205583 0003 0035 16316
+E: 1304510651.205587 0003 0036 12365
+E: 1304510651.205587 0003 0034 0
+E: 1304510651.205588 0003 0030 1300
+E: 1304510651.205591 0003 0000 16324
+E: 1304510651.205591 0003 0001 12365
+E: 1304510651.205592 0000 0000 0
+E: 1304510651.210583 0003 0035 16313
+E: 1304510651.210587 0003 0036 12283
+E: 1304510651.210593 0003 0030 1339
+E: 1304510651.210596 0003 0000 16321
+E: 1304510651.210596 0003 0001 12283
+E: 1304510651.210597 0000 0000 0
+E: 1304510651.215582 0003 0035 16310
+E: 1304510651.215586 0003 0036 12199
+E: 1304510651.215593 0003 0000 16318
+E: 1304510651.215594 0003 0001 12199
+E: 1304510651.215595 0000 0000 0
+E: 1304510651.220578 0003 0035 16302
+E: 1304510651.220581 0003 0036 12109
+E: 1304510651.220589 0003 0000 16310
+E: 1304510651.220589 0003 0001 12109
+E: 1304510651.220590 0000 0000 0
+E: 1304510651.225581 0003 0035 16293
+E: 1304510651.225585 0003 0036 12015
+E: 1304510651.225589 0003 0034 1
+E: 1304510651.225590 0003 0030 1286
+E: 1304510651.225593 0003 0000 16301
+E: 1304510651.225593 0003 0001 12015
+E: 1304510651.225594 0000 0000 0
+E: 1304510651.230574 0003 0035 16285
+E: 1304510651.230582 0003 0036 11921
+E: 1304510651.230583 0003 0030 1247
+E: 1304510651.230586 0003 0000 16293
+E: 1304510651.230587 0003 0001 11921
+E: 1304510651.230587 0000 0000 0
+E: 1304510651.235581 0003 0035 16282
+E: 1304510651.235585 0003 0036 11825
+E: 1304510651.235590 0003 0034 0
+E: 1304510651.235590 0003 0030 1299
+E: 1304510651.235593 0003 0000 16290
+E: 1304510651.235593 0003 0001 11825
+E: 1304510651.235594 0000 0000 0
+E: 1304510651.241581 0003 0035 16280
+E: 1304510651.241589 0003 0036 11723
+E: 1304510651.241590 0003 0030 1338
+E: 1304510651.241593 0003 0000 16287
+E: 1304510651.241593 0003 0001 11723
+E: 1304510651.241594 0000 0000 0
+E: 1304510651.246582 0003 0035 16278
+E: 1304510651.246586 0003 0036 11631
+E: 1304510651.246590 0003 0000 16284
+E: 1304510651.246594 0003 0001 11631
+E: 1304510651.246594 0000 0000 0
+E: 1304510651.251571 0003 0035 16238
+E: 1304510651.251574 0003 0036 11531
+E: 1304510651.251576 0003 0000 16238
+E: 1304510651.251577 0003 0001 11531
+E: 1304510651.251577 0000 0000 0
+E: 1304510651.256580 0003 0035 16204
+E: 1304510651.256584 0003 0036 11431
+E: 1304510651.256589 0003 0034 1
+E: 1304510651.256589 0003 0030 1286
+E: 1304510651.256592 0003 0000 16204
+E: 1304510651.256593 0003 0001 11431
+E: 1304510651.256593 0000 0000 0
+E: 1304510651.261582 0003 0035 16190
+E: 1304510651.261586 0003 0036 11325
+E: 1304510651.261587 0003 0030 1247
+E: 1304510651.261589 0003 0000 16200
+E: 1304510651.261590 0003 0001 11325
+E: 1304510651.261597 0000 0000 0
+E: 1304510651.266581 0003 0035 16187
+E: 1304510651.266584 0003 0036 11223
+E: 1304510651.266592 0003 0000 16196
+E: 1304510651.266592 0003 0001 11223
+E: 1304510651.266593 0000 0000 0
+E: 1304510651.271578 0003 0035 16185
+E: 1304510651.271585 0003 0036 11121
+E: 1304510651.271589 0003 0000 16193
+E: 1304510651.271589 0003 0001 11121
+E: 1304510651.271590 0000 0000 0
+E: 1304510651.276583 0003 0035 16170
+E: 1304510651.276587 0003 0036 11029
+E: 1304510651.276587 0003 0034 0
+E: 1304510651.276588 0003 0030 1299
+E: 1304510651.276591 0003 0000 16181
+E: 1304510651.276596 0003 0001 11029
+E: 1304510651.276597 0000 0000 0
+E: 1304510651.281565 0003 0036 10933
+E: 1304510651.281573 0003 0030 1338
+E: 1304510651.281574 0003 0000 16178
+E: 1304510651.281575 0003 0001 10933
+E: 1304510651.281575 0000 0000 0
+E: 1304510651.286579 0003 0035 16140
+E: 1304510651.286582 0003 0036 10831
+E: 1304510651.286590 0003 0000 16140
+E: 1304510651.286590 0003 0001 10831
+E: 1304510651.286591 0000 0000 0
+E: 1304510651.291572 0003 0035 16130
+E: 1304510651.291580 0003 0036 10735
+E: 1304510651.291583 0003 0000 16137
+E: 1304510651.291583 0003 0001 10735
+E: 1304510651.291584 0000 0000 0
+E: 1304510651.296583 0003 0035 16098
+E: 1304510651.296587 0003 0036 10639
+E: 1304510651.296591 0003 0034 1
+E: 1304510651.296592 0003 0030 1286
+E: 1304510651.296595 0003 0000 16098
+E: 1304510651.296595 0003 0001 10639
+E: 1304510651.296596 0000 0000 0
+E: 1304510651.302588 0003 0036 10535
+E: 1304510651.302593 0003 0030 1247
+E: 1304510651.302596 0003 0001 10535
+E: 1304510651.302601 0000 0000 0
+E: 1304510651.307584 0003 0035 16095
+E: 1304510651.307588 0003 0036 10431
+E: 1304510651.307596 0003 0001 10431
+E: 1304510651.307596 0000 0000 0
+E: 1304510651.312577 0003 0036 10327
+E: 1304510651.312584 0003 0034 0
+E: 1304510651.312585 0003 0030 1299
+E: 1304510651.312588 0003 0001 10327
+E: 1304510651.312588 0000 0000 0
+E: 1304510651.317584 0003 0035 16087
+E: 1304510651.317588 0003 0036 10225
+E: 1304510651.317593 0003 0030 1338
+E: 1304510651.317596 0003 0000 16095
+E: 1304510651.317596 0003 0001 10225
+E: 1304510651.317597 0000 0000 0
+E: 1304510651.322579 0003 0035 16074
+E: 1304510651.322587 0003 0036 10123
+E: 1304510651.322590 0003 0000 16084
+E: 1304510651.322591 0003 0001 10123
+E: 1304510651.322591 0000 0000 0
+E: 1304510651.327574 0003 0035 16060
+E: 1304510651.327578 0003 0036 10017
+E: 1304510651.327583 0003 0030 1276
+E: 1304510651.327583 0003 0031 843
+E: 1304510651.327586 0003 0000 16072
+E: 1304510651.327586 0003 0001 10017
+E: 1304510651.327587 0000 0000 0
+E: 1304510651.332577 0003 0036 9909
+E: 1304510651.332585 0003 0030 1230
+E: 1304510651.332586 0003 0031 801
+E: 1304510651.332588 0003 0000 16069
+E: 1304510651.332589 0003 0001 9909
+E: 1304510651.332589 0000 0000 0
+E: 1304510651.337579 0003 0035 16049
+E: 1304510651.337582 0003 0036 9803
+E: 1304510651.337588 0003 0030 1195
+E: 1304510651.337590 0003 0000 16059
+E: 1304510651.337591 0003 0001 9803
+E: 1304510651.337591 0000 0000 0
+E: 1304510651.342574 0003 0035 16036
+E: 1304510651.342578 0003 0036 9695
+E: 1304510651.342583 0003 0030 1325
+E: 1304510651.342585 0003 0000 16047
+E: 1304510651.342586 0003 0001 9695
+E: 1304510651.342586 0000 0000 0
+E: 1304510651.347579 0003 0035 16025
+E: 1304510651.347583 0003 0036 9585
+E: 1304510651.347584 0003 0030 1357
+E: 1304510651.347585 0003 0031 965
+E: 1304510651.347587 0003 0000 16036
+E: 1304510651.347588 0003 0001 9585
+E: 1304510651.347593 0000 0000 0
+E: 1304510651.352581 0003 0036 9477
+E: 1304510651.352589 0003 0031 821
+E: 1304510651.352592 0003 0000 16033
+E: 1304510651.352593 0003 0001 9477
+E: 1304510651.352593 0000 0000 0
+E: 1304510651.358582 0003 0035 16021
+E: 1304510651.358586 0003 0036 9369
+E: 1304510651.358591 0003 0031 785
+E: 1304510651.358593 0003 0000 16030
+E: 1304510651.358594 0003 0001 9369
+E: 1304510651.358594 0000 0000 0
+E: 1304510651.363574 0003 0035 16010
+E: 1304510651.363579 0003 0036 9267
+E: 1304510651.363580 0003 0030 1224
+E: 1304510651.363582 0003 0000 16020
+E: 1304510651.363583 0003 0001 9267
+E: 1304510651.363583 0000 0000 0
+E: 1304510651.368576 0003 0035 16000
+E: 1304510651.368580 0003 0036 9167
+E: 1304510651.368584 0003 0030 1191
+E: 1304510651.368587 0003 0000 16010
+E: 1304510651.368588 0003 0001 9167
+E: 1304510651.368588 0000 0000 0
+E: 1304510651.373572 0003 0035 15990
+E: 1304510651.373576 0003 0036 9067
+E: 1304510651.373579 0003 0000 16000
+E: 1304510651.373580 0003 0001 9067
+E: 1304510651.373580 0000 0000 0
+E: 1304510651.378586 0003 0035 15981
+E: 1304510651.378591 0003 0036 8957
+E: 1304510651.378596 0003 0030 1323
+E: 1304510651.378599 0003 0000 15990
+E: 1304510651.378599 0003 0001 8957
+E: 1304510651.378600 0000 0000 0
+E: 1304510651.383563 0003 0036 8855
+E: 1304510651.383566 0003 0030 1356
+E: 1304510651.383568 0003 0000 15987
+E: 1304510651.383568 0003 0001 8855
+E: 1304510651.383569 0000 0000 0
+E: 1304510651.388579 0003 0035 15990
+E: 1304510651.388583 0003 0036 8751
+E: 1304510651.388591 0003 0001 8751
+E: 1304510651.388591 0000 0000 0
+E: 1304510651.393568 0003 0035 15999
+E: 1304510651.393571 0003 0036 8647
+E: 1304510651.393574 0003 0000 15990
+E: 1304510651.393575 0003 0001 8647
+E: 1304510651.393575 0000 0000 0
+E: 1304510651.398583 0003 0035 16006
+E: 1304510651.398586 0003 0036 8547
+E: 1304510651.398591 0003 0030 1224
+E: 1304510651.398594 0003 0000 15998
+E: 1304510651.398595 0003 0001 8547
+E: 1304510651.398595 0000 0000 0
+E: 1304510651.403573 0003 0035 16004
+E: 1304510651.403577 0003 0036 8443
+E: 1304510651.403578 0003 0030 1191
+E: 1304510651.403580 0003 0001 8443
+E: 1304510651.403581 0000 0000 0
+E: 1304510651.408581 0003 0036 8337
+E: 1304510651.408593 0003 0001 8337
+E: 1304510651.408593 0000 0000 0
+E: 1304510651.414567 0003 0036 8229
+E: 1304510651.414574 0003 0030 1323
+E: 1304510651.414577 0003 0001 8229
+E: 1304510651.414577 0000 0000 0
+E: 1304510651.419580 0003 0035 16002
+E: 1304510651.419584 0003 0036 8117
+E: 1304510651.419589 0003 0030 1356
+E: 1304510651.419592 0003 0001 8117
+E: 1304510651.419593 0000 0000 0
+E: 1304510651.424575 0003 0036 8013
+E: 1304510651.424586 0003 0001 8013
+E: 1304510651.424587 0000 0000 0
+E: 1304510651.429580 0003 0035 15994
+E: 1304510651.429583 0003 0036 7909
+E: 1304510651.429591 0003 0001 7909
+E: 1304510651.429591 0000 0000 0
+E: 1304510651.434574 0003 0036 7805
+E: 1304510651.434582 0003 0030 1224
+E: 1304510651.434585 0003 0001 7805
+E: 1304510651.434586 0000 0000 0
+E: 1304510651.439578 0003 0036 7703
+E: 1304510651.439586 0003 0030 1191
+E: 1304510651.439590 0003 0001 7703
+E: 1304510651.439590 0000 0000 0
+E: 1304510651.444593 0003 0035 15991
+E: 1304510651.444600 0003 0036 7599
+E: 1304510651.444607 0003 0000 15996
+E: 1304510651.444608 0003 0001 7599
+E: 1304510651.444608 0000 0000 0
+E: 1304510651.449581 0003 0035 15980
+E: 1304510651.449585 0003 0036 7485
+E: 1304510651.449590 0003 0030 1323
+E: 1304510651.449593 0003 0000 15988
+E: 1304510651.449593 0003 0001 7485
+E: 1304510651.449594 0000 0000 0
+E: 1304510651.454564 0003 0035 15970
+E: 1304510651.454567 0003 0036 7379
+E: 1304510651.454568 0003 0030 1356
+E: 1304510651.454573 0003 0000 15979
+E: 1304510651.454574 0003 0001 7379
+E: 1304510651.454574 0000 0000 0
+E: 1304510651.459579 0003 0035 15959
+E: 1304510651.459583 0003 0036 7275
+E: 1304510651.459590 0003 0000 15969
+E: 1304510651.459591 0003 0001 7275
+E: 1304510651.459591 0000 0000 0
+E: 1304510651.464572 0003 0036 7171
+E: 1304510651.464583 0003 0000 15966
+E: 1304510651.464583 0003 0001 7171
+E: 1304510651.464584 0000 0000 0
+E: 1304510651.469578 0003 0036 7069
+E: 1304510651.469589 0003 0000 15964
+E: 1304510651.469589 0003 0001 7069
+E: 1304510651.469590 0000 0000 0
+E: 1304510651.475577 0003 0036 6965
+E: 1304510651.475586 0003 0030 1224
+E: 1304510651.475589 0003 0001 6965
+E: 1304510651.475589 0000 0000 0
+E: 1304510651.480588 0003 0036 6855
+E: 1304510651.480597 0003 0030 1191
+E: 1304510651.480600 0003 0001 6855
+E: 1304510651.480601 0000 0000 0
+E: 1304510651.485562 0003 0036 6745
+E: 1304510651.485565 0003 0030 1323
+E: 1304510651.485571 0003 0001 6745
+E: 1304510651.485571 0000 0000 0
+E: 1304510651.490575 0003 0036 6641
+E: 1304510651.490580 0003 0030 1356
+E: 1304510651.490582 0003 0001 6641
+E: 1304510651.490583 0000 0000 0
+E: 1304510651.495575 0003 0035 15949
+E: 1304510651.495581 0003 0036 6539
+E: 1304510651.495584 0003 0000 15956
+E: 1304510651.495585 0003 0001 6539
+E: 1304510651.495585 0000 0000 0
+E: 1304510651.500579 0003 0035 15941
+E: 1304510651.500582 0003 0036 6439
+E: 1304510651.500589 0003 0000 15948
+E: 1304510651.500590 0003 0001 6439
+E: 1304510651.500590 0000 0000 0
+E: 1304510651.505572 0003 0035 15937
+E: 1304510651.505580 0003 0036 6341
+E: 1304510651.505583 0003 0000 15945
+E: 1304510651.505583 0003 0001 6341
+E: 1304510651.505584 0000 0000 0
+E: 1304510651.510574 0003 0035 15926
+E: 1304510651.510579 0003 0036 6235
+E: 1304510651.510584 0003 0030 1224
+E: 1304510651.510586 0003 0000 15935
+E: 1304510651.510587 0003 0001 6235
+E: 1304510651.510587 0000 0000 0
+E: 1304510651.515574 0003 0035 15917
+E: 1304510651.515577 0003 0036 6125
+E: 1304510651.515582 0003 0030 1191
+E: 1304510651.515584 0003 0000 15926
+E: 1304510651.515585 0003 0001 6125
+E: 1304510651.515585 0000 0000 0
+E: 1304510651.520577 0003 0035 15907
+E: 1304510651.520583 0003 0036 6015
+E: 1304510651.520588 0003 0030 1323
+E: 1304510651.520591 0003 0000 15916
+E: 1304510651.520591 0003 0001 6015
+E: 1304510651.520592 0000 0000 0
+E: 1304510651.525567 0003 0035 15897
+E: 1304510651.525570 0003 0036 5909
+E: 1304510651.525575 0003 0030 1356
+E: 1304510651.525578 0003 0000 15906
+E: 1304510651.525578 0003 0001 5909
+E: 1304510651.525579 0000 0000 0
+E: 1304510651.531583 0003 0035 15885
+E: 1304510651.531588 0003 0036 5809
+E: 1304510651.531591 0003 0000 15895
+E: 1304510651.531592 0003 0001 5809
+E: 1304510651.531593 0000 0000 0
+E: 1304510651.536562 0003 0035 15870
+E: 1304510651.536564 0003 0036 5711
+E: 1304510651.536571 0003 0000 15882
+E: 1304510651.536572 0003 0001 5711
+E: 1304510651.536572 0000 0000 0
+E: 1304510651.541580 0003 0035 15840
+E: 1304510651.541584 0003 0036 5613
+E: 1304510651.541591 0003 0000 15840
+E: 1304510651.541592 0003 0001 5613
+E: 1304510651.541592 0000 0000 0
+E: 1304510651.546575 0003 0035 15831
+E: 1304510651.546579 0003 0036 5509
+E: 1304510651.546584 0003 0030 1224
+E: 1304510651.546586 0003 0000 15837
+E: 1304510651.546587 0003 0001 5509
+E: 1304510651.546587 0000 0000 0
+E: 1304510651.551575 0003 0035 15819
+E: 1304510651.551585 0003 0036 5405
+E: 1304510651.551586 0003 0030 1191
+E: 1304510651.551588 0003 0000 15828
+E: 1304510651.551589 0003 0001 5405
+E: 1304510651.551589 0000 0000 0
+E: 1304510651.556571 0003 0035 15805
+E: 1304510651.556574 0003 0036 5299
+E: 1304510651.556579 0003 0030 1323
+E: 1304510651.556582 0003 0000 15816
+E: 1304510651.556582 0003 0001 5299
+E: 1304510651.556583 0000 0000 0
+E: 1304510651.561580 0003 0035 15790
+E: 1304510651.561584 0003 0036 5197
+E: 1304510651.561585 0003 0030 1356
+E: 1304510651.561588 0003 0000 15803
+E: 1304510651.561589 0003 0001 5197
+E: 1304510651.561589 0000 0000 0
+E: 1304510651.566574 0003 0035 15777
+E: 1304510651.566577 0003 0036 5097
+E: 1304510651.566585 0003 0000 15790
+E: 1304510651.566585 0003 0001 5097
+E: 1304510651.566586 0000 0000 0
+E: 1304510651.571578 0003 0035 15740
+E: 1304510651.571586 0003 0036 5003
+E: 1304510651.571589 0003 0000 15740
+E: 1304510651.571590 0003 0001 5003
+E: 1304510651.571590 0000 0000 0
+E: 1304510651.576562 0003 0035 15730
+E: 1304510651.576565 0003 0036 4909
+E: 1304510651.576570 0003 0000 15737
+E: 1304510651.576571 0003 0001 4909
+E: 1304510651.576571 0000 0000 0
+E: 1304510651.581575 0003 0035 15716
+E: 1304510651.581584 0003 0036 4813
+E: 1304510651.581585 0003 0030 1224
+E: 1304510651.581588 0003 0000 15726
+E: 1304510651.581589 0003 0001 4813
+E: 1304510651.581589 0000 0000 0
+E: 1304510651.586564 0003 0035 15684
+E: 1304510651.586567 0003 0036 4705
+E: 1304510651.586568 0003 0030 1191
+E: 1304510651.586570 0003 0000 15684
+E: 1304510651.586571 0003 0001 4705
+E: 1304510651.586571 0000 0000 0
+E: 1304510651.592579 0003 0035 15676
+E: 1304510651.592585 0003 0036 4599
+E: 1304510651.592590 0003 0030 1323
+E: 1304510651.592593 0003 0000 15682
+E: 1304510651.592593 0003 0001 4599
+E: 1304510651.592594 0000 0000 0
+E: 1304510651.597572 0003 0035 15664
+E: 1304510651.597576 0003 0036 4493
+E: 1304510651.597580 0003 0030 1356
+E: 1304510651.597583 0003 0000 15673
+E: 1304510651.597583 0003 0001 4493
+E: 1304510651.597584 0000 0000 0
+E: 1304510651.602577 0003 0035 15626
+E: 1304510651.602585 0003 0036 4387
+E: 1304510651.602588 0003 0000 15626
+E: 1304510651.602589 0003 0001 4387
+E: 1304510651.602590 0000 0000 0
+E: 1304510651.607614 0003 0035 15616
+E: 1304510651.607617 0003 0036 4285
+E: 1304510651.607624 0003 0000 15623
+E: 1304510651.607625 0003 0001 4285
+E: 1304510651.607625 0000 0000 0
+E: 1304510651.612575 0003 0035 15584
+E: 1304510651.612579 0003 0036 4183
+E: 1304510651.612586 0003 0000 15584
+E: 1304510651.612587 0003 0001 4183
+E: 1304510651.612587 0000 0000 0
+E: 1304510651.617565 0003 0035 15573
+E: 1304510651.617569 0003 0036 4075
+E: 1304510651.617574 0003 0030 1224
+E: 1304510651.617576 0003 0000 15581
+E: 1304510651.617576 0003 0001 4075
+E: 1304510651.617577 0000 0000 0
+E: 1304510651.622577 0003 0035 15536
+E: 1304510651.622581 0003 0036 3965
+E: 1304510651.622585 0003 0030 1191
+E: 1304510651.622588 0003 0000 15536
+E: 1304510651.622589 0003 0001 3965
+E: 1304510651.622589 0000 0000 0
+E: 1304510651.627579 0003 0035 15506
+E: 1304510651.627583 0003 0036 3853
+E: 1304510651.627584 0003 0030 1323
+E: 1304510651.627586 0003 0000 15506
+E: 1304510651.627586 0003 0001 3853
+E: 1304510651.627587 0000 0000 0
+E: 1304510651.632578 0003 0035 15472
+E: 1304510651.632582 0003 0036 3739
+E: 1304510651.632583 0003 0030 1356
+E: 1304510651.632586 0003 0000 15472
+E: 1304510651.632586 0003 0001 3739
+E: 1304510651.632587 0000 0000 0
+E: 1304510651.637580 0003 0035 15438
+E: 1304510651.637584 0003 0036 3633
+E: 1304510651.637592 0003 0000 15438
+E: 1304510651.637592 0003 0001 3633
+E: 1304510651.637593 0000 0000 0
+E: 1304510651.642573 0003 0035 15404
+E: 1304510651.642581 0003 0036 3521
+E: 1304510651.642585 0003 0000 15404
+E: 1304510651.642585 0003 0001 3521
+E: 1304510651.642586 0000 0000 0
+E: 1304510651.648572 0003 0035 15370
+E: 1304510651.648576 0003 0036 3405
+E: 1304510651.648581 0003 0030 1224
+E: 1304510651.648583 0003 0000 15370
+E: 1304510651.648584 0003 0001 3405
+E: 1304510651.648585 0000 0000 0
+E: 1304510651.653572 0003 0035 15340
+E: 1304510651.653577 0003 0036 3287
+E: 1304510651.653578 0003 0030 1191
+E: 1304510651.653580 0003 0000 15340
+E: 1304510651.653581 0003 0001 3287
+E: 1304510651.653581 0000 0000 0
+E: 1304510651.658578 0003 0035 15326
+E: 1304510651.658583 0003 0036 3171
+E: 1304510651.658588 0003 0030 1323
+E: 1304510651.658591 0003 0000 15336
+E: 1304510651.658592 0003 0001 3171
+E: 1304510651.658592 0000 0000 0
+E: 1304510651.663568 0003 0035 15280
+E: 1304510651.663573 0003 0036 3049
+E: 1304510651.663574 0003 0030 1356
+E: 1304510651.663577 0003 0000 15280
+E: 1304510651.663577 0003 0001 3049
+E: 1304510651.663578 0000 0000 0
+E: 1304510651.668574 0003 0035 15248
+E: 1304510651.668583 0003 0036 2927
+E: 1304510651.668586 0003 0000 15248
+E: 1304510651.668587 0003 0001 2927
+E: 1304510651.668587 0000 0000 0
+E: 1304510651.673576 0003 0035 15216
+E: 1304510651.673580 0003 0036 2805
+E: 1304510651.673581 0003 0030 1224
+E: 1304510651.673584 0003 0000 15216
+E: 1304510651.673585 0003 0001 2805
+E: 1304510651.673585 0000 0000 0
+E: 1304510651.678565 0003 0035 15172
+E: 1304510651.678568 0003 0036 2679
+E: 1304510651.678573 0003 0030 1191
+E: 1304510651.678575 0003 0000 15172
+E: 1304510651.678576 0003 0001 2679
+E: 1304510651.678576 0000 0000 0
+E: 1304510651.683580 0003 0035 15124
+E: 1304510651.683585 0003 0036 2551
+E: 1304510651.683588 0003 0000 15124
+E: 1304510651.683589 0003 0001 2551
+E: 1304510651.683590 0000 0000 0
+E: 1304510651.688579 0003 0035 15076
+E: 1304510651.688584 0003 0036 2427
+E: 1304510651.688585 0003 0030 1323
+E: 1304510651.688588 0003 0000 15076
+E: 1304510651.688588 0003 0001 2427
+E: 1304510651.688589 0000 0000 0
+E: 1304510651.693582 0003 0035 15024
+E: 1304510651.693615 0003 0036 2309
+E: 1304510651.693616 0003 0030 1356
+E: 1304510651.693619 0003 0000 15024
+E: 1304510651.693623 0003 0001 2309
+E: 1304510651.693623 0000 0000 0
+E: 1304510651.698609 0003 0035 14968
+E: 1304510651.698615 0003 0036 2185
+E: 1304510651.698617 0003 0030 1224
+E: 1304510651.698625 0003 0000 14968
+E: 1304510651.698626 0003 0001 2185
+E: 1304510651.698627 0000 0000 0
+E: 1304510651.703613 0003 0039 -1
+E: 1304510651.703621 0001 014a 0
+E: 1304510651.703627 0000 0000 0
+E: 1304510652.695704 0003 0039 136
+E: 1304510652.695720 0003 0035 16944
+E: 1304510652.695722 0003 0036 16837
+E: 1304510652.695725 0003 0030 1282
+E: 1304510652.695727 0003 0031 957
+E: 1304510652.695730 0001 014a 1
+E: 1304510652.695734 0003 0000 16944
+E: 1304510652.695736 0003 0001 16837
+E: 1304510652.695737 0000 0000 0
+E: 1304510652.700700 0003 0030 1325
+E: 1304510652.700711 0003 0031 1000
+E: 1304510652.700720 0000 0000 0
+E: 1304510652.706696 0003 0030 1357
+E: 1304510652.706708 0003 0031 1032
+E: 1304510652.706716 0000 0000 0
+E: 1304510652.736695 0003 0036 16835
+E: 1304510652.736716 0000 0000 0
+E: 1304510652.741695 0003 0036 16833
+E: 1304510652.741716 0000 0000 0
+E: 1304510652.746694 0003 0036 16830
+E: 1304510652.746714 0003 0001 16835
+E: 1304510652.746716 0000 0000 0
+E: 1304510652.751695 0003 0036 16827
+E: 1304510652.751707 0003 0034 1
+E: 1304510652.751708 0003 0030 1300
+E: 1304510652.751716 0003 0001 16833
+E: 1304510652.751718 0000 0000 0
+E: 1304510652.756694 0003 0036 16814
+E: 1304510652.756707 0003 0030 1257
+E: 1304510652.756715 0003 0001 16823
+E: 1304510652.756717 0000 0000 0
+E: 1304510652.762696 0003 0036 16779
+E: 1304510652.762709 0003 0030 1225
+E: 1304510652.762717 0003 0001 16779
+E: 1304510652.762719 0000 0000 0
+E: 1304510652.767696 0003 0036 16769
+E: 1304510652.767719 0003 0001 16776
+E: 1304510652.767721 0000 0000 0
+E: 1304510652.772695 0003 0036 16731
+E: 1304510652.772715 0003 0001 16731
+E: 1304510652.772717 0000 0000 0
+E: 1304510652.777693 0003 0035 16946
+E: 1304510652.777705 0003 0036 16718
+E: 1304510652.777715 0003 0001 16727
+E: 1304510652.777717 0000 0000 0
+E: 1304510652.782694 0003 0036 16675
+E: 1304510652.782715 0003 0001 16675
+E: 1304510652.782717 0000 0000 0
+E: 1304510652.787694 0003 0036 16605
+E: 1304510652.787706 0003 0034 0
+E: 1304510652.787708 0003 0030 1282
+E: 1304510652.787716 0003 0001 16605
+E: 1304510652.787718 0000 0000 0
+E: 1304510652.792702 0003 0036 16575
+E: 1304510652.792714 0003 0030 1325
+E: 1304510652.792723 0003 0001 16575
+E: 1304510652.792724 0000 0000 0
+E: 1304510652.797694 0003 0035 16912
+E: 1304510652.797706 0003 0036 16495
+E: 1304510652.797709 0003 0030 1357
+E: 1304510652.797716 0003 0000 16912
+E: 1304510652.797718 0003 0001 16495
+E: 1304510652.797719 0000 0000 0
+E: 1304510652.802692 0003 0035 16878
+E: 1304510652.802704 0003 0036 16429
+E: 1304510652.802713 0003 0000 16878
+E: 1304510652.802714 0003 0001 16429
+E: 1304510652.802716 0000 0000 0
+E: 1304510652.807684 0003 0035 16874
+E: 1304510652.807691 0003 0036 16397
+E: 1304510652.807701 0003 0001 16397
+E: 1304510652.807703 0000 0000 0
+E: 1304510652.812694 0003 0035 16834
+E: 1304510652.812706 0003 0036 16327
+E: 1304510652.812715 0003 0000 16834
+E: 1304510652.812717 0003 0001 16327
+E: 1304510652.812719 0000 0000 0
+E: 1304510652.817692 0003 0035 16820
+E: 1304510652.817703 0003 0036 16243
+E: 1304510652.817705 0003 0034 1
+E: 1304510652.817707 0003 0030 1300
+E: 1304510652.817714 0003 0000 16830
+E: 1304510652.817716 0003 0001 16243
+E: 1304510652.817718 0000 0000 0
+E: 1304510652.823703 0003 0035 16786
+E: 1304510652.823715 0003 0036 16167
+E: 1304510652.823718 0003 0030 1257
+E: 1304510652.823725 0003 0000 16786
+E: 1304510652.823726 0003 0001 16167
+E: 1304510652.823728 0000 0000 0
+E: 1304510652.828691 0003 0035 16776
+E: 1304510652.828703 0003 0036 16089
+E: 1304510652.828705 0003 0034 0
+E: 1304510652.828707 0003 0030 1306
+E: 1304510652.828714 0003 0000 16783
+E: 1304510652.828715 0003 0001 16089
+E: 1304510652.828717 0000 0000 0
+E: 1304510652.833696 0003 0035 16762
+E: 1304510652.833708 0003 0036 16011
+E: 1304510652.833711 0003 0030 1343
+E: 1304510652.833718 0003 0000 16772
+E: 1304510652.833720 0003 0001 16011
+E: 1304510652.833721 0000 0000 0
+E: 1304510652.838691 0003 0035 16730
+E: 1304510652.838703 0003 0036 15923
+E: 1304510652.838712 0003 0000 16730
+E: 1304510652.838714 0003 0001 15923
+E: 1304510652.838715 0000 0000 0
+E: 1304510652.843697 0003 0035 16720
+E: 1304510652.843709 0003 0036 15839
+E: 1304510652.843713 0003 0031 1000
+E: 1304510652.843719 0003 0000 16727
+E: 1304510652.843721 0003 0001 15839
+E: 1304510652.843723 0000 0000 0
+E: 1304510652.848691 0003 0035 16706
+E: 1304510652.848703 0003 0036 15761
+E: 1304510652.848712 0003 0000 16716
+E: 1304510652.848714 0003 0001 15761
+E: 1304510652.848716 0000 0000 0
+E: 1304510652.853704 0003 0035 16692
+E: 1304510652.853716 0003 0036 15679
+E: 1304510652.853725 0003 0000 16704
+E: 1304510652.853727 0003 0001 15679
+E: 1304510652.853729 0000 0000 0
+E: 1304510652.858693 0003 0035 16678
+E: 1304510652.858705 0003 0036 15603
+E: 1304510652.858707 0003 0030 1280
+E: 1304510652.858714 0003 0000 16691
+E: 1304510652.858716 0003 0001 15603
+E: 1304510652.858718 0000 0000 0
+E: 1304510652.863708 0003 0035 16648
+E: 1304510652.863718 0003 0036 15513
+E: 1304510652.863721 0003 0030 1233
+E: 1304510652.863729 0003 0000 16648
+E: 1304510652.863733 0003 0001 15513
+E: 1304510652.863735 0000 0000 0
+E: 1304510652.868678 0003 0035 16645
+E: 1304510652.868686 0003 0036 15425
+E: 1304510652.868692 0003 0030 1288
+E: 1304510652.868700 0003 0001 15425
+E: 1304510652.868702 0000 0000 0
+E: 1304510652.873703 0003 0035 16634
+E: 1304510652.873711 0003 0036 15335
+E: 1304510652.873714 0003 0030 1330
+E: 1304510652.873721 0003 0000 16644
+E: 1304510652.873724 0003 0001 15335
+E: 1304510652.873726 0000 0000 0
+E: 1304510652.879551 0003 0035 16625
+E: 1304510652.879554 0003 0036 15251
+E: 1304510652.879562 0003 0000 16634
+E: 1304510652.879563 0003 0001 15251
+E: 1304510652.879563 0000 0000 0
+E: 1304510652.884553 0003 0035 16613
+E: 1304510652.884557 0003 0036 15161
+E: 1304510652.884561 0003 0000 16623
+E: 1304510652.884565 0003 0001 15161
+E: 1304510652.884565 0000 0000 0
+E: 1304510652.889544 0003 0035 16602
+E: 1304510652.889548 0003 0036 15071
+E: 1304510652.889556 0003 0000 16612
+E: 1304510652.889556 0003 0001 15071
+E: 1304510652.889557 0000 0000 0
+E: 1304510652.894555 0003 0035 16592
+E: 1304510652.894560 0003 0036 14989
+E: 1304510652.894563 0003 0000 16602
+E: 1304510652.894564 0003 0001 14989
+E: 1304510652.894564 0000 0000 0
+E: 1304510652.899545 0003 0035 16588
+E: 1304510652.899548 0003 0036 14901
+E: 1304510652.899552 0003 0030 1270
+E: 1304510652.899555 0003 0000 16598
+E: 1304510652.899555 0003 0001 14901
+E: 1304510652.899556 0000 0000 0
+E: 1304510652.904552 0003 0035 16580
+E: 1304510652.904557 0003 0036 14813
+E: 1304510652.904558 0003 0030 1225
+E: 1304510652.904561 0003 0000 16589
+E: 1304510652.904566 0003 0001 14813
+E: 1304510652.904567 0000 0000 0
+E: 1304510652.909555 0003 0035 16576
+E: 1304510652.909560 0003 0036 14721
+E: 1304510652.909565 0003 0030 1282
+E: 1304510652.909568 0003 0000 16585
+E: 1304510652.909568 0003 0001 14721
+E: 1304510652.909569 0000 0000 0
+E: 1304510652.914550 0003 0035 16568
+E: 1304510652.914554 0003 0036 14627
+E: 1304510652.914559 0003 0030 1325
+E: 1304510652.914561 0003 0000 16576
+E: 1304510652.914562 0003 0001 14627
+E: 1304510652.914563 0000 0000 0
+E: 1304510652.919544 0003 0035 16565
+E: 1304510652.919547 0003 0036 14531
+E: 1304510652.919552 0003 0030 1357
+E: 1304510652.919555 0003 0000 16573
+E: 1304510652.919555 0003 0001 14531
+E: 1304510652.919556 0000 0000 0
+E: 1304510652.924546 0003 0035 16557
+E: 1304510652.924550 0003 0036 14441
+E: 1304510652.924558 0003 0000 16565
+E: 1304510652.924558 0003 0001 14441
+E: 1304510652.924559 0000 0000 0
+E: 1304510652.929549 0003 0035 16553
+E: 1304510652.929555 0003 0036 14355
+E: 1304510652.929562 0003 0000 16562
+E: 1304510652.929563 0003 0001 14355
+E: 1304510652.929563 0000 0000 0
+E: 1304510652.935550 0003 0035 16550
+E: 1304510652.935554 0003 0036 14271
+E: 1304510652.935561 0003 0000 16559
+E: 1304510652.935562 0003 0001 14271
+E: 1304510652.935563 0000 0000 0
+E: 1304510652.940543 0003 0035 16547
+E: 1304510652.940551 0003 0036 14181
+E: 1304510652.940552 0003 0030 1224
+E: 1304510652.940555 0003 0000 16556
+E: 1304510652.940555 0003 0001 14181
+E: 1304510652.940556 0000 0000 0
+E: 1304510652.945554 0003 0035 16544
+E: 1304510652.945562 0003 0036 14093
+E: 1304510652.945563 0003 0030 1191
+E: 1304510652.945566 0003 0000 16553
+E: 1304510652.945567 0003 0001 14093
+E: 1304510652.945567 0000 0000 0
+E: 1304510652.950541 0003 0036 14003
+E: 1304510652.950551 0003 0000 16550
+E: 1304510652.950551 0003 0001 14003
+E: 1304510652.950552 0000 0000 0
+E: 1304510652.955555 0003 0036 13911
+E: 1304510652.955564 0003 0030 1323
+E: 1304510652.955567 0003 0001 13911
+E: 1304510652.955567 0000 0000 0
+E: 1304510652.960546 0003 0036 13823
+E: 1304510652.960554 0003 0030 1356
+E: 1304510652.960557 0003 0001 13823
+E: 1304510652.960558 0000 0000 0
+E: 1304510652.965555 0003 0035 16541
+E: 1304510652.965558 0003 0036 13733
+E: 1304510652.965565 0003 0000 16547
+E: 1304510652.965566 0003 0001 13733
+E: 1304510652.965566 0000 0000 0
+E: 1304510652.970549 0003 0035 16537
+E: 1304510652.970553 0003 0036 13635
+E: 1304510652.970560 0003 0000 16544
+E: 1304510652.970561 0003 0001 13635
+E: 1304510652.970561 0000 0000 0
+E: 1304510652.975555 0003 0035 16533
+E: 1304510652.975559 0003 0036 13543
+E: 1304510652.975566 0003 0000 16541
+E: 1304510652.975567 0003 0001 13543
+E: 1304510652.975567 0000 0000 0
+E: 1304510652.980543 0003 0035 16529
+E: 1304510652.980546 0003 0036 13447
+E: 1304510652.980551 0003 0030 1224
+E: 1304510652.980554 0003 0000 16538
+E: 1304510652.980554 0003 0001 13447
+E: 1304510652.980555 0000 0000 0
+E: 1304510652.985546 0003 0035 16526
+E: 1304510652.985555 0003 0036 13353
+E: 1304510652.985556 0003 0030 1191
+E: 1304510652.985558 0003 0000 16535
+E: 1304510652.985559 0003 0001 13353
+E: 1304510652.985560 0000 0000 0
+E: 1304510652.990544 0003 0035 16523
+E: 1304510652.990552 0003 0036 13251
+E: 1304510652.990553 0003 0030 1323
+E: 1304510652.990555 0003 0000 16532
+E: 1304510652.990556 0003 0001 13251
+E: 1304510652.990556 0000 0000 0
+E: 1304510652.996550 0003 0035 16519
+E: 1304510652.996558 0003 0036 13149
+E: 1304510652.996559 0003 0030 1356
+E: 1304510652.996561 0003 0000 16528
+E: 1304510652.996562 0003 0001 13149
+E: 1304510652.996563 0000 0000 0
+E: 1304510653.001538 0003 0035 16515
+E: 1304510653.001542 0003 0036 13049
+E: 1304510653.001545 0003 0000 16524
+E: 1304510653.001545 0003 0001 13049
+E: 1304510653.001546 0000 0000 0
+E: 1304510653.006552 0003 0035 16511
+E: 1304510653.006556 0003 0036 12953
+E: 1304510653.006563 0003 0000 16520
+E: 1304510653.006564 0003 0001 12953
+E: 1304510653.006565 0000 0000 0
+E: 1304510653.011541 0003 0035 16507
+E: 1304510653.011545 0003 0036 12855
+E: 1304510653.011550 0003 0030 1224
+E: 1304510653.011553 0003 0000 16516
+E: 1304510653.011553 0003 0001 12855
+E: 1304510653.011554 0000 0000 0
+E: 1304510653.016548 0003 0035 16504
+E: 1304510653.016551 0003 0036 12757
+E: 1304510653.016556 0003 0030 1191
+E: 1304510653.016559 0003 0000 16513
+E: 1304510653.016560 0003 0001 12757
+E: 1304510653.016560 0000 0000 0
+E: 1304510653.021544 0003 0035 16501
+E: 1304510653.021549 0003 0036 12659
+E: 1304510653.021556 0003 0000 16510
+E: 1304510653.021556 0003 0001 12659
+E: 1304510653.021557 0000 0000 0
+E: 1304510653.026552 0003 0035 16498
+E: 1304510653.026556 0003 0036 12555
+E: 1304510653.026560 0003 0030 1323
+E: 1304510653.026563 0003 0000 16507
+E: 1304510653.026564 0003 0001 12555
+E: 1304510653.026564 0000 0000 0
+E: 1304510653.031542 0003 0035 16496
+E: 1304510653.031545 0003 0036 12453
+E: 1304510653.031550 0003 0030 1356
+E: 1304510653.031553 0003 0000 16504
+E: 1304510653.031553 0003 0001 12453
+E: 1304510653.031554 0000 0000 0
+E: 1304510653.036544 0003 0035 16494
+E: 1304510653.036552 0003 0036 12345