diff --git a/helgrind/Makefile.am b/helgrind/Makefile.am
new file mode 100644
index 0000000..4a9d93d
--- /dev/null
+++ b/helgrind/Makefile.am
@@ -0,0 +1,121 @@
+include $(top_srcdir)/Makefile.tool.am
+
+noinst_PROGRAMS = 
+if VGP_X86_LINUX
+noinst_PROGRAMS += helgrind-x86-linux vgpreload_helgrind-x86-linux.so
+endif
+if VGP_AMD64_LINUX
+noinst_PROGRAMS += helgrind-amd64-linux vgpreload_helgrind-amd64-linux.so
+endif
+if VGP_PPC32_LINUX
+noinst_PROGRAMS += helgrind-ppc32-linux vgpreload_helgrind-ppc32-linux.so
+endif
+if VGP_PPC64_LINUX
+noinst_PROGRAMS += helgrind-ppc64-linux vgpreload_helgrind-ppc64-linux.so
+endif
+if VGP_PPC32_AIX5
+noinst_PROGRAMS += helgrind-ppc32-aix5 vgpreload_helgrind-ppc32-aix5.so
+endif
+if VGP_PPC64_AIX5
+noinst_PROGRAMS += helgrind-ppc64-aix5 vgpreload_helgrind-ppc64-aix5.so
+endif
+
+VGPRELOAD_HELGRIND_SOURCES_COMMON = hg_intercepts.c
+
+vgpreload_helgrind_x86_linux_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_x86_linux_so_CPPFLAGS     = $(AM_CPPFLAGS_X86_LINUX) -O -g -fno-omit-frame-pointer
+vgpreload_helgrind_x86_linux_so_CFLAGS       = $(AM_CFLAGS_X86_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_x86_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_X86_LINUX)
+vgpreload_helgrind_x86_linux_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_X86_LINUX) \
+	$(LIBREPLACEMALLOC_LDFLAGS_X86_LINUX)
+
+vgpreload_helgrind_amd64_linux_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_amd64_linux_so_CPPFLAGS     = $(AM_CPPFLAGS_AMD64_LINUX) -O -g
+vgpreload_helgrind_amd64_linux_so_CFLAGS       = $(AM_CFLAGS_AMD64_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_amd64_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_AMD64_LINUX)
+vgpreload_helgrind_amd64_linux_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_AMD64_LINUX) \
+	$(LIBREPLACEMALLOC_LDFLAGS_AMD64_LINUX)
+
+vgpreload_helgrind_ppc32_linux_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc32_linux_so_CPPFLAGS     = $(AM_CPPFLAGS_PPC32_LINUX) -O -g
+vgpreload_helgrind_ppc32_linux_so_CFLAGS       = $(AM_CFLAGS_PPC32_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc32_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC32_LINUX)
+vgpreload_helgrind_ppc32_linux_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_PPC32_LINUX) \
+	$(LIBREPLACEMALLOC_LDFLAGS_PPC32_LINUX)
+
+vgpreload_helgrind_ppc64_linux_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc64_linux_so_CPPFLAGS     = $(AM_CPPFLAGS_PPC64_LINUX) -O -g
+vgpreload_helgrind_ppc64_linux_so_CFLAGS       = $(AM_CFLAGS_PPC64_LINUX) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc64_linux_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC64_LINUX)
+vgpreload_helgrind_ppc64_linux_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_PPC64_LINUX) \
+	$(LIBREPLACEMALLOC_LDFLAGS_PPC64_LINUX)
+
+vgpreload_helgrind_ppc32_aix5_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc32_aix5_so_CPPFLAGS     = $(AM_CPPFLAGS_PPC32_AIX5) -O -g
+vgpreload_helgrind_ppc32_aix5_so_CFLAGS       = $(AM_CFLAGS_PPC32_AIX5) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc32_aix5_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC32_AIX5)
+vgpreload_helgrind_ppc32_aix5_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_PPC32_AIX5) \
+	$(LIBREPLACEMALLOC_LDFLAGS_PPC32_AIX5)
+
+vgpreload_helgrind_ppc64_aix5_so_SOURCES      = $(VGPRELOAD_HELGRIND_SOURCES_COMMON)
+vgpreload_helgrind_ppc64_aix5_so_CPPFLAGS     = $(AM_CPPFLAGS_PPC64_AIX5) -O -g
+vgpreload_helgrind_ppc64_aix5_so_CFLAGS       = $(AM_CFLAGS_PPC64_AIX5) $(AM_CFLAGS_PIC)
+vgpreload_helgrind_ppc64_aix5_so_DEPENDENCIES = $(LIBREPLACEMALLOC_PPC64_AIX5)
+vgpreload_helgrind_ppc64_aix5_so_LDFLAGS      = \
+	$(PRELOAD_LDFLAGS_PPC64_AIX5) \
+	$(LIBREPLACEMALLOC_LDFLAGS_PPC64_AIX5)
+
+HELGRIND_SOURCES_COMMON = hg_wordfm.c hg_wordset.c hg_main.c
+
+helgrind_x86_linux_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_x86_linux_CPPFLAGS     = $(AM_CPPFLAGS_X86_LINUX)
+helgrind_x86_linux_CFLAGS       = $(AM_CFLAGS_X86_LINUX) -O2
+helgrind_x86_linux_DEPENDENCIES = $(COREGRIND_LIBS_X86_LINUX)
+helgrind_x86_linux_LDADD        = $(TOOL_LDADD_X86_LINUX)
+helgrind_x86_linux_LDFLAGS      = $(TOOL_LDFLAGS_X86_LINUX)
+
+helgrind_amd64_linux_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_amd64_linux_CPPFLAGS     = $(AM_CPPFLAGS_AMD64_LINUX)
+helgrind_amd64_linux_CFLAGS       = $(AM_CFLAGS_AMD64_LINUX) -O2
+helgrind_amd64_linux_DEPENDENCIES = $(COREGRIND_LIBS_AMD64_LINUX)
+helgrind_amd64_linux_LDADD        = $(TOOL_LDADD_AMD64_LINUX)
+helgrind_amd64_linux_LDFLAGS      = $(TOOL_LDFLAGS_AMD64_LINUX)
+
+helgrind_ppc32_linux_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc32_linux_CPPFLAGS     = $(AM_CPPFLAGS_PPC32_LINUX)
+helgrind_ppc32_linux_CFLAGS       = $(AM_CFLAGS_PPC32_LINUX) -O2
+helgrind_ppc32_linux_DEPENDENCIES = $(COREGRIND_LIBS_PPC32_LINUX)
+helgrind_ppc32_linux_LDADD        = $(TOOL_LDADD_PPC32_LINUX)
+helgrind_ppc32_linux_LDFLAGS      = $(TOOL_LDFLAGS_PPC32_LINUX)
+
+helgrind_ppc64_linux_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc64_linux_CPPFLAGS     = $(AM_CPPFLAGS_PPC64_LINUX)
+helgrind_ppc64_linux_CFLAGS       = $(AM_CFLAGS_PPC64_LINUX) -O2
+helgrind_ppc64_linux_DEPENDENCIES = $(COREGRIND_LIBS_PPC64_LINUX)
+helgrind_ppc64_linux_LDADD        = $(TOOL_LDADD_PPC64_LINUX)
+helgrind_ppc64_linux_LDFLAGS      = $(TOOL_LDFLAGS_PPC64_LINUX)
+
+helgrind_ppc32_aix5_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc32_aix5_CPPFLAGS     = $(AM_CPPFLAGS_PPC32_AIX5)
+helgrind_ppc32_aix5_CFLAGS       = $(AM_CFLAGS_PPC32_AIX5) -O2
+helgrind_ppc32_aix5_DEPENDENCIES = $(COREGRIND_LIBS_PPC32_AIX5)
+helgrind_ppc32_aix5_LDADD        = $(TOOL_LDADD_PPC32_AIX5)
+helgrind_ppc32_aix5_LDFLAGS      = $(TOOL_LDFLAGS_PPC32_AIX5)
+
+helgrind_ppc64_aix5_SOURCES      = $(HELGRIND_SOURCES_COMMON)
+helgrind_ppc64_aix5_CPPFLAGS     = $(AM_CPPFLAGS_PPC64_AIX5)
+helgrind_ppc64_aix5_CFLAGS       = $(AM_CFLAGS_PPC64_AIX5) -O2
+helgrind_ppc64_aix5_DEPENDENCIES = $(COREGRIND_LIBS_PPC64_AIX5)
+helgrind_ppc64_aix5_LDADD        = $(TOOL_LDADD_PPC64_AIX5)
+helgrind_ppc64_aix5_LDFLAGS      = $(TOOL_LDFLAGS_PPC64_AIX5)
+
+hgincludedir = $(includedir)/valgrind
+
+hginclude_HEADERS = helgrind.h
+
+noinst_HEADERS = hg_wordfm.h hg_wordset.h
diff --git a/helgrind/docs/Makefile.am b/helgrind/docs/Makefile.am
new file mode 100644
index 0000000..84f630f
--- /dev/null
+++ b/helgrind/docs/Makefile.am
@@ -0,0 +1 @@
+EXTRA_DIST = hg-manual.xml
diff --git a/helgrind/docs/hg-manual.xml b/helgrind/docs/hg-manual.xml
new file mode 100644
index 0000000..5090cfc
--- /dev/null
+++ b/helgrind/docs/hg-manual.xml
@@ -0,0 +1,1311 @@
+<?xml version="1.0"?> <!-- -*- sgml -*- -->
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
+          "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
+
+
+<chapter id="tc-manual" xreflabel="Thrcheck: thread error detector">
+  <title>Thrcheck: a thread error detector</title>
+
+<para>To use this tool, you must specify
+<computeroutput>--tool=thrcheck</computeroutput> on the Valgrind
+command line.</para>
+
+
+
+
+<sect1 id="tc-manual.overview" xreflabel="Overview">
+<title>Overview</title>
+
+<para>Thrcheck is a Valgrind tool for detecting synchronisation errors
+in C, C++ and Fortran programs that use the POSIX pthreads
+threading primitives.</para>
+
+<para>The main abstractions in POSIX pthreads are: a set of threads
+sharing a common address space, thread creation, thread joinage,
+thread exit, mutexes (locks), condition variables (inter-thread event
+notifications), reader-writer locks, and semaphores.</para>
+
+<para>Thrcheck is aware of all these abstractions and tracks their
+effects as accurately as it can.  Currently it does not correctly
+handle pthread barriers and pthread spinlocks, although it will not
+object if you use them.  On x86 and amd64 platforms, it understands
+and partially handles implicit locking arising from the use of the
+LOCK instruction prefix.
+</para>
+
+<para>Thrcheck can detect three classes of errors, which are discussed
+in detail in the next three sections:</para>
+
+<orderedlist>
+ <listitem>
+  <para><link linkend="tc-manual.api-checks">
+        Misuses of the POSIX pthreads API.</link></para>
+ </listitem>
+ <listitem>
+  <para><link linkend="tc-manual.lock-orders">
+        Potential deadlocks arising from lock
+        ordering problems.</link></para>
+ </listitem>
+ <listitem>
+  <para><link linkend="tc-manual.data-races">
+        Data races -- accessing memory without adequate locking.
+        </link></para>
+ </listitem>
+</orderedlist>
+
+<para>Following those is a section containing 
+<link linkend="tc-manual.effective-use">
+hints and tips on how to get the best out of Thrcheck.</link>
+</para>
+
+<para>Then there is a
+<link linkend="tc-manual.options">summary of command-line
+options.</link>
+</para>
+
+<para>Finally, there is 
+<link linkend="tc-manual.todolist">a brief summary of areas in which Thrcheck
+could be improved.</link>
+</para>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.api-checks" xreflabel="API Checks">
+<title>Detected errors: Misuses of the POSIX pthreads API</title>
+
+<para>Thrcheck intercepts calls to many POSIX pthreads functions, and
+is therefore able to report on various common problems.  Although
+these are unglamourous errors, their presence can lead to undefined
+program behaviour and hard-to-find bugs later in execution.  The
+detected errors are:</para>
+
+<itemizedlist>
+ <listitem><para>unlocking an invalid mutex</para></listitem>
+ <listitem><para>unlocking a not-locked mutex</para></listitem>
+ <listitem><para>unlocking a mutex held by a different
+                 thread</para></listitem>
+ <listitem><para>destroying an invalid or a locked mutex</para></listitem>
+ <listitem><para>recursively locking a non-recursive mutex</para></listitem>
+ <listitem><para>deallocation of memory that contains a
+                 locked mutex</para></listitem>
+ <listitem><para>passing mutex arguments to functions expecting
+                 reader-writer lock arguments, and vice
+                 versa</para></listitem>
+ <listitem><para>when a POSIX pthread function fails with an
+                 error code that must be handled</para></listitem>
+ <listitem><para>when a thread exits whilst still holding locked
+                 locks</para></listitem>
+ <listitem><para>calling <computeroutput>pthread_cond_wait</computeroutput>
+                 with a not-locked mutex, or one locked by a different
+                 thread</para></listitem>
+</itemizedlist>
+
+<para>Checks pertaining to the validity of mutexes are generally also
+performed for reader-writer locks.</para>
+
+<para>Various kinds of this-can't-possibly-happen events are also
+reported.  These usually indicate bugs in the system threading
+library.</para>
+
+<para>Reported errors always contain a primary stack trace indicating
+where the error was detected.  They may also contain auxiliary stack
+traces giving additional information.  In particular, most errors
+relating to mutexes will also tell you where that mutex first came to
+Thrcheck's attention (the "<computeroutput>was first observed
+at</computeroutput>" part), so you have a chance of figuring out which
+mutex it is referring to.  For example:</para>
+
+<programlisting><![CDATA[
+Thread #1 unlocked a not-locked lock at 0x7FEFFFA90
+   at 0x4C2408D: pthread_mutex_unlock (tc_intercepts.c:492)
+   by 0x40073A: nearly_main (tc09_bad_unlock.c:27)
+   by 0x40079B: main (tc09_bad_unlock.c:50)
+  Lock at 0x7FEFFFA90 was first observed
+   at 0x4C25D01: pthread_mutex_init (tc_intercepts.c:326)
+   by 0x40071F: nearly_main (tc09_bad_unlock.c:23)
+   by 0x40079B: main (tc09_bad_unlock.c:50)
+]]></programlisting>
+
+<para>Thrcheck has a way of summarising thread identities, as
+evidenced here by the text "<computeroutput>Thread
+#1</computeroutput>".  This is so that it can speak about threads and
+sets of threads without overwhelming you with details.  See 
+<link linkend="tc-manual.data-races.errmsgs">below</link>
+for more information on interpreting error messages.</para>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.lock-orders" xreflabel="Lock Orders">
+<title>Detected errors: Inconsistent Lock Orderings</title>
+
+<para>In this section, and in general, to "acquire" a lock simply
+means to lock that lock, and to "release" a lock means to unlock
+it.</para>
+
+<para>Thrcheck monitors the order in which threads acquire locks.
+This allows it to detect potential deadlocks which could arise from
+the formation of cycles of locks.  Detecting such inconsistencies is
+useful because, whilst actual deadlocks are fairly obvious, potential
+deadlocks may never be discovered during testing and could later lead
+to hard-to-diagnose in-service failures.</para>
+
+<para>The simplest example of such a problem is as
+follows.</para>
+
+<itemizedlist>
+ <listitem><para>Imagine some shared resource R, which, for whatever
+  reason, is guarded by two locks, L1 and L2, which must both be held
+  when R is accessed.</para>
+ </listitem>
+ <listitem><para>Suppose a thread acquires L1, then L2, and proceeds
+  to access R.  The implication of this is that all threads in the
+  program must acquire the two locks in the order first L1 then L2.
+  Not doing so risks deadlock.</para>
+ </listitem>
+ <listitem><para>The deadlock could happen if two threads -- call them
+  T1 and T2 -- both want to access R.  Suppose T1 acquires L1 first,
+  and T2 acquires L2 first.  Then T1 tries to acquire L2, and T2 tries
+  to acquire L1, but those locks are both already held.  So T1 and T2
+  become deadlocked.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Thrcheck builds a directed graph indicating the order in which
+locks have been acquired in the past.  When a thread acquires a new
+lock, the graph is updated, and then checked to see if it now contains
+a cycle.  The presence of a cycle indicates a potential deadlock involving
+the locks in the cycle.</para>
+
+<para>In simple situations, where the cycle only contains two locks,
+Thrcheck will show where the required order was established:</para>
+
+<programlisting><![CDATA[
+Thread #1: lock order "0x7FEFFFAB0 before 0x7FEFFFA80" violated
+   at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+   by 0x40081F: main (tc13_laog1.c:24)
+  Required order was established by acquisition of lock at 0x7FEFFFAB0
+   at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+   by 0x400748: main (tc13_laog1.c:17)
+  followed by a later acquisition of lock at 0x7FEFFFA80
+   at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+   by 0x400773: main (tc13_laog1.c:18)
+]]></programlisting>
+
+<para>When there are more than two locks in the cycle, the error is
+equally serious.  However, at present Thrcheck does not show the locks
+involved, so as to avoid flooding you with information.  That could be
+fixed in future.  For example, here is a an example involving a cycle
+of five locks from a naive implementation the famous Dining
+Philosophers problem
+(see <computeroutput>thrcheck/tests/tc14_laog_dinphils.c</computeroutput>).
+In this case Thrcheck has detected that all 5 philosophers could
+simultaneously pick up their left fork and then deadlock whilst
+waiting to pick up their right forks.</para>
+
+<programlisting><![CDATA[
+Thread #6: lock order "0x6010C0 before 0x601160" violated
+   at 0x4C23C91: pthread_mutex_lock (tc_intercepts.c:388)
+   by 0x4007C0: dine (tc14_laog_dinphils.c:19)
+   by 0x4C25DF7: mythread_wrapper (tc_intercepts.c:178)
+   by 0x4E2F09D: start_thread (in /lib64/libpthread-2.5.so)
+   by 0x51054CC: clone (in /lib64/libc-2.5.so)
+]]></programlisting>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.data-races" xreflabel="Data Races">
+<title>Detected errors: Data Races</title>
+
+<para>A data race happens, or could happen, when two threads
+access a shared memory location without using suitable locks to
+ensure single-threaded access.  Such missing locking can cause
+obscure timing dependent bugs.  Ensuring programs are race-free is
+one of the central difficulties of threaded programming.</para>
+
+<para>Reliably detecting races is a difficult problem, and most
+of Thrcheck's internals are devoted to do dealing with it.  
+As a consequence this section is somewhat long and involved.
+We begin with a simple example.</para>
+
+
+<sect2 id="tc-manual.data-races.example" xreflabel="Simple Race">
+<title>A Simple Data Race</title>
+
+<para>About the simplest possible example of a race is as follows.  In
+this program, it is impossible to know what the value
+of <computeroutput>var</computeroutput> is at the end of the program.
+Is it 2 ?  Or 1 ?</para>
+
+<programlisting><![CDATA[
+#include <pthread.h>
+
+int var = 0;
+
+void* child_fn ( void* arg ) {
+   var++; /* Unprotected relative to parent */ /* this is line 6 */
+   return NULL;
+}
+
+int main ( void ) {
+   pthread_t child;
+   pthread_create(&child, NULL, child_fn, NULL);
+   var++; /* Unprotected relative to child */ /* this is line 13 */
+   pthread_join(child, NULL);
+   return 0;
+}
+]]></programlisting>
+
+<para>The problem is there is nothing to
+stop <computeroutput>var</computeroutput> being updated simultaneously
+by both threads.  A correct program would 
+protect <computeroutput>var</computeroutput> with a lock of type
+<computeroutput>pthread_mutex_t</computeroutput>, which is acquired
+before each access and released afterwards.  Thrcheck's output for
+this program is:</para>
+
+<programlisting><![CDATA[
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x510548E: clone (in /lib64/libc-2.5.so)
+   by 0x4E2F305: do_clone (in /lib64/libpthread-2.5.so)
+   by 0x4E2F7C5: pthread_create@@GLIBC_2.2.5 (in /lib64/libpthread-2.5.so)
+   by 0x4C23870: pthread_create@* (tc_intercepts.c:198)
+   by 0x4005F1: main (simple_race.c:12)
+
+Possible data race during write of size 4 at 0x601034
+   at 0x4005F2: main (simple_race.c:13)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x601034 has never been protected by any lock
+]]></programlisting>
+
+<para>This is quite a lot of detail for an apparently simple error.
+The last clause is the main error message.  It says there is a race as
+a result of a write of size 4 (bytes), at 0x601034, which is
+presumably the address of <computeroutput>var</computeroutput>,
+happening in function <computeroutput>main</computeroutput> at line 13
+in the program.</para>
+
+<para>Note that it is purely by chance that the race is
+reported for the parent thread's access.  It could equally have been
+reported instead for the child's access, at line 6.  The error will
+only be reported for one of the locations, since neither the parent
+nor child is, by itself, incorrect.  It is only when both access
+<computeroutput>var</computeroutput> without a lock that an error
+exists.</para>
+
+<para>The error message shows some other interesting details.  The
+sections below explain them.  Here we merely note their presence:</para>
+
+<itemizedlist>
+ <listitem><para>Thrcheck maintains some kind of state machine for the
+  memory location in question, hence the "<computeroutput>Old
+  state:</computeroutput>" and "<computeroutput>New
+  state:</computeroutput>" lines.</para>
+ </listitem>
+ <listitem><para>Thrcheck keeps track of which threads have accessed
+  the location: "<computeroutput>threads #1, #2</computeroutput>".
+  Before printing the main error message, it prints the creation
+  points of these two threads, so you can see which threads it is
+  referring to.</para>
+ </listitem>
+ <listitem><para>Thrcheck tries to provide an explaination of why the
+  race exists: "<computeroutput>Location 0x601034 has never been
+  protected by any lock</computeroutput>".</para>
+ </listitem>
+</itemizedlist>
+
+<para>Understanding the memory state machine is central to
+understanding Thrcheck's race-detection algorithm.  The next three
+subsections explain this.</para>
+
+</sect2>
+
+
+<sect2 id="tc-manual.data-races.memstates" xreflabel="Memory States">
+<title>Thrcheck's Memory State Machine</title>
+
+<para>Thrcheck tracks the state of every byte of memory used by your
+program.  There are a number of states, but only three are
+interesting:</para>
+
+<itemizedlist>
+ <listitem><para>Exclusive: memory in this state is regarded as owned
+  exclusively by one particular thread.  That thread may read and
+  write it without a lock.  Even in highly threaded programs, the
+  majority of locations never leave the Exclusive state, since most
+  data is thread-private.</para>
+ </listitem>
+ <listitem><para>Shared-Readonly: memory in this state is regarded as
+  shared by multiple threads.  In this state, any thread may read the
+  memory without a lock, reflecting the fact that readonly data may
+  safely be shared between threads without locking.</para>
+ </listitem>
+ <listitem><para>Shared-Modified: memory in this state is regarded as
+  shared by multiple threads, at least one of which has written to it.
+  All participating threads must hold at least one lock in common when
+  accessing the memory.  If no such lock exists, Thrcheck reports a
+  race error.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Let's review the simple example above with this in mind.  When
+the program starts, <computeroutput>var</computeroutput> is not in any
+of these states.  Either the parent or child thread gets to its
+<computeroutput>var++</computeroutput> first, and thereby
+thereby gets Exclusive ownership of the location.</para>
+
+<para>The later-running thread now arrives at
+its <computeroutput>var++</computeroutput> statement.  It first reads
+the existing value from memory.
+Because <computeroutput>var</computeroutput> is currently marked as
+owned exclusively by the other thread, its state is changed to
+shared-readonly by both threads.</para>
+
+<para>This same thread adds one to the value it has and stores it back
+in <computeroutput>var</computeroutput>.  This causes another state
+change, this time to the shared-modified state.  Because Thrcheck has
+also been tracking which threads hold which locks, it can see that
+<computeroutput>var</computeroutput> is in shared-modified state but
+no lock has been used to consistently protect it.  Hence a race is
+reported exactly at the transition from shared-readonly to
+shared-modified.</para>
+
+<para>The essence of the algorithm is this.  Thrcheck keeps track of
+each memory location that has been accessed by more than one thread.
+For each such location it incrementally infers the set of locks which
+have consistently been used to protect that location.  If the
+location's lockset becomes empty, and at some point one of the threads
+attempts to write to it, a race is then reported.</para>
+
+<para>This technique is known as "lockset inference" and was
+introduced in: "Eraser: A Dynamic Data Race Detector for Multithreaded
+Programs" (Stefan Savage, Michael Burrows, Greg Nelson, Patrick
+Sobalvarro and Thomas Anderson, ACM Transactions on Computer Systems,
+15(4):391-411, November 1997).</para>
+
+<para>Lockset inference has since been widely implemented, studied and
+extended.  Thrcheck incorporates several refinements aimed at avoiding
+the high false error rate that naive versions of the algorithm suffer
+from.  A 
+<link linkend="tc-manual.data-races.summary">summary of the complete
+algorithm used by Thrcheck</link> is presented below.  First, however,
+it is important to understand details of transitions pertaining to the
+Exclusive-ownership state.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.exclusive" xreflabel="Excl Transfers">
+<title>Transfers of Exclusive Ownership Between Threads</title>
+
+<para>As presented, the algorithm is far too strict.  It reports many
+errors in perfectly correct, widely used parallel programming
+constructions, for example, using child worker threads and worker
+thread pools.</para>
+
+<para>To avoid these false errors, we must refine the algorithm so
+that it keeps memory in an Exclusive ownership state in cases where it
+would otherwise decay into a shared-readonly or shared-modified state.
+Recall that Exclusive ownership is special in that it grants the
+owning thread the right to access memory without use of any locks.  In
+order to support worker-thread and worker-thread-pool idioms, we will
+allow threads to steal exclusive ownership of memory from other
+threads under certain circumstances.</para>
+
+<para>Here's an example.  Imagine a parent thread creates child
+threads to do units of work.  For each unit of work, the parent
+allocates a work buffer, fills it in, and creates the child thread,
+handing it a pointer to the buffer.  The child reads/writes the buffer
+and eventually exits, and the waiting parent then extracts the results
+from the buffer:</para>
+
+<programlisting><![CDATA[
+typedef ... Buffer;
+
+pthread_t child;
+Buffer    buf;
+
+/* ---- Parent ---- */                          /* ---- Child ---- */
+
+/* parent writes workload into buf */
+pthread_create( &child, child_fn, &buf );
+
+/* parent does not read */                      void child_fn ( Buffer* buf ) {
+/* or write buf */                                 /* read/write buf */
+                                                }
+
+pthread_join ( child );
+/* parent reads results from buf */
+]]></programlisting>
+
+<para>Although <computeroutput>buf</computeroutput> is accessed by
+both threads, neither uses locks, yet the program is race-free.  The
+essential observation is that the child's creation and exit create
+synchronisation events between it and the parent.  These force the
+child's accesses to <computeroutput>buf</computeroutput> to happen
+after the parent initialises <computeroutput>buf</computeroutput>, and
+before the parent reads the results
+from <computeroutput>buf</computeroutput>.</para>
+
+<para>To model this, Thrcheck allows the child to steal, from the
+parent, exclusive ownership of any memory exclusively owned by the
+parent before the pthread_create call.  Similarly, once the parent's
+pthread_join call returns, it can steal back ownership of memory
+exclusively owned by the child.  In this way ownership
+of <computeroutput>buf</computeroutput> is transferred from parent to
+child and back, so the basic algorithm does not report any races
+despite the absence of any locking.</para>
+
+<para>Note that the child may only steal memory owned by the parent
+prior to the pthread_create call.  If the child attempts to read or
+write memory which is also accessed by the parent in between the
+pthread_create and pthread_join calls, an error is still
+reported.</para>
+
+<para>This technique was introduced with the name "thread lifetime
+segments" in "Runtime Checking of Multithreaded Applications with
+Visual Threads" (Jerry J. Harrow, Jr, Proceedings of the 7th
+International SPIN Workshop on Model Checking of Software Stanford,
+California, USA, August 2000, LNCS 1885, pp331--342).  Thrcheck
+implements an extended version of it.  Specifically, Thrcheck allows
+transfer of exclusive ownership in the following situations:</para>
+
+<itemizedlist>
+ <listitem><para>At thread creation: a child can acquire ownership of
+  memory held exclusively by the parent prior to the child's
+  creation.</para>
+ </listitem>
+ <listitem><para>At thread joining: the joiner (thread not exiting)
+  can acquire ownership of memory held exclusively by the joinee
+  (thread that is exiting) at the point it exited.</para>
+ </listitem>
+ <listitem><para>At condition variable signallings and broadcasts.  A
+  thread Tw which completes a pthread_cond_wait call as a result of
+  a signal or broadcast on the same condition variable by some other
+  thread Ts, may acquire ownership of memory held exclusively by
+  Ts prior to the pthread_cond_signal/broadcast
+  call.</para>
+ </listitem>
+ <listitem><para>At semaphore posts (sem_post) calls.  A thread Tw
+  which completes a sem_wait call call as a result of a sem_post call
+  on the same semaphore by some other thread Tp, may acquire
+  ownership of memory held exclusively by Tp prior to the sem_post
+  call.</para>
+ </listitem>
+</itemizedlist>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.re-excl" xreflabel="Re-Excl Transfers">
+<title>Restoration of Exclusive Ownership</title>
+
+<para>Another common idiom is to partition the lifetime of the program
+as a whole into several distinct phases.  In some of those phases, a
+memory location may be accessed by multiple threads and so require
+locking.  In other phases only one thread exists and so can access the
+memory without locking.  For example:</para>
+
+<programlisting><![CDATA[
+int             var = 0;                         /* shared variable */
+pthread_mutex_t mx  = PTHREAD_MUTEX_INITIALIZER; /* guard for var */
+pthread_t       child;
+
+/* ---- Parent ---- */                          /* ---- Child ---- */
+
+var += 1; /* no lock used */
+
+pthread_create( &child, child_fn, NULL );
+
+                                                void child_fn ( void* uu ) {
+pthread_mutex_lock(&mx);                           pthread_mutex_lock(&mx);         
+var += 2;                                          var += 3;
+pthread_mutex_unlock(&mx);                         pthread_mutex_unlock(&mx);
+                                                }
+
+pthread_join ( child );
+
+var += 4; /* no lock used */
+]]></programlisting>
+
+<para>This program is correct, but using only the mechanisms described
+so far, Thrcheck would report an error at
+<computeroutput>var += 4</computeroutput>.  This is because, by that
+point, <computeroutput>var</computeroutput> is marked as being in the
+state "shared-modified and protected by the
+lock <computeroutput>mx</computeroutput>", but is being accessed
+without locking.  Really, what we want is
+for <computeroutput>var</computeroutput> to return to the parent
+thread's exclusive ownership after the child thread has exited.</para>
+
+<para>To make this possible, for every memory location Thrcheck also keeps
+track of all the threads that have accessed that location
+-- its threadset.  When a thread Tquitter joins back to Tstayer,
+Thrcheck examines the locksets of all memory in shared-modified or
+shared-readable state.  In each such lockset, if Tquitter is
+mentioned, it is removed and replaced by Tstayer.  If, as a result, a
+lockset becomes a singleton set containing Tstayer, then the
+location's state is changed to belongs-exclusively-to-Tstayer.</para>
+
+<para>In our example, the result is exactly as we desire:
+<computeroutput>var</computeroutput> is reacquired exclusively by the
+parent after the child exits.</para>
+
+<para>More generally, when a group of threads merges back to a single
+thread via a cascade of pthread_join calls, any memory shared by the
+group (or a subset of it) ends up being owned exclusively by the sole
+surviving thread.  This significantly enhances Thrcheck's flexibility,
+since it means that each memory location may make arbitrarily many
+transitions between exclusive and shared ownership.  Furthermore, a
+different lock may protect the location during each period of shared
+ownership.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.summary" xreflabel="Race Det Summary">
+<title>A Summary of the Race Detection Algorithm</title>
+
+<para>Thrcheck looks for memory locations which are accessed by more
+than one thread.  For each such location, Thrcheck records which of
+the program's locks were held by the accessing thread at the time of
+each access.  The hope is to discover that there is indeed at least
+one lock which is consistently used by all threads to protect that
+location.  If no such lock can be found, then there is apparently no
+consistent locking strategy being applied for that location, and so a
+possible data race might result.  Thrcheck accordingly reports an
+error.</para>
+
+<para>In practice this discipline is far too simplistic, and is
+unusable since it reports many races in some widely used and
+known-correct programming disciplines.  Thrcheck's checking therefore
+incorporates many refinements to this basic idea, and can be
+summarised as follows:</para>
+
+<para>The following thread events are intercepted and monitored:</para>
+
+<itemizedlist>
+ <listitem><para>thread creation and exiting (pthread_create,
+           pthread_join, pthread_exit)</para>
+ </listitem>
+ <listitem>
+  <para>lock acquisition and release (pthread_mutex_lock,
+        pthread_mutex_unlock, pthread_rwlock_rdlock,
+        pthread_rwlock_wrlock,
+        pthread_rwlock_unlock)</para>
+ </listitem>
+ <listitem>
+  <para>inter-thread event notifications (pthread_cond_wait,
+        pthread_cond_signal, pthread_cond_broadcast, 
+        sem_wait, sem_post)</para>
+ </listitem>
+</itemizedlist>
+
+<para>Memory allocation and deallocation events are intercepted and
+monitored:</para>
+
+<itemizedlist>
+ <listitem>
+  <para>malloc/new/free/delete and variants</para>
+ </listitem>
+ <listitem>
+  <para>stack allocation and deallocation</para>
+ </listitem>
+</itemizedlist>
+
+<para>All memory accesses are intercepted and monitored.</para>
+
+<para>By observing the above events, Thrcheck can infer certain
+aspects of the program's locking discipline.  Programs which adhere to
+the following rules are considered to be acceptable:
+</para>
+
+<itemizedlist>
+ <listitem>
+  <para>A thread may allocate memory, and write initial values into
+  it, without locking.  That thread is regarded as owning the memory
+  exclusively.</para>
+ </listitem>
+ <listitem>
+  <para>A thread may read and write memory which it owns exclusively,
+  without locking.</para>
+ </listitem>
+ <listitem>
+  <para>Memory which is owned exclusively by one thread may be read by
+  that thread and others without locking.  However, in this situation
+  no thread may do unlocked writes to the memory (except for the owner
+  thread's initializing write).</para>
+ </listitem>
+ <listitem>
+  <para>Memory which is shared between multiple threads, one or more
+  of which writes to it, must be protected by a lock which is
+  correctly acquired and released by all threads accessing the
+  memory.</para>
+ </listitem>
+</itemizedlist>
+
+<para>Any violation of this discipline will cause an error to be reported.
+However, two exemptions apply:</para>
+
+<itemizedlist>
+ <listitem>
+  <para>A thread Y can acquire exclusive ownership of memory
+  previously owned exclusively by a different thread X providing
+  X's last access and Y's first access are separated by one of the
+  following synchronization events:</para>
+  <itemizedlist>
+   <listitem><para>X creates thread Y</para></listitem>
+   <listitem><para>X joins back to Y</para></listitem>
+   <listitem><para>X uses a condition-variable to signal at Y, and Y is
+   waiting for that event</para></listitem>
+   <listitem><para>Y completes a semaphore wait as a result of X signalling 
+   on that same semaphore</para></listitem>
+  </itemizedlist>
+  <para>
+  This refinement allows Thrcheck to correctly track the ownership
+  state of inter-thread buffers used in the worker-thread and
+  worker-thread-pool concurrent programming idioms (styles).</para>
+ </listitem>
+ <listitem>
+  <para>Similarly, if thread Y joins back to thread X, memory
+  exclusively owned by Y becomes exclusively owned by X instead.
+  Also, memory that has been shared only by X and Y becomes
+  exclusively owned by X.  More generally, memory that has been shared
+  by X, Y and some arbitrary other set S of threads is re-marked as
+  shared by X and S.  Hence, under the right circumstances, memory
+  shared amongst multiple threads, all of which join into just one,
+  can revert to the exclusive ownership state.</para>
+  <para>
+  In effect, each memory location may make arbitrarily many
+  transitions between exclusive and shared ownership.  Furthermore, a
+  different lock may protect the location during each period of shared
+  ownership.  This significantly enhances the flexibility of the
+  algorithm.</para>
+ </listitem>
+</itemizedlist>
+
+<para>The ownership state, accessing thread-set and related lock-set
+for each memory location are tracked at 8-bit granularity.  This means
+the algorithm is precise even for 16- and 8-bit memory
+accesses.</para>
+
+<para>Thrcheck correctly handles reader-writer locks in this
+framework.  Locations shared between multiple threads can be protected
+during reads by locks held in either read-mode or write-mode, but can
+only be protected during writes by locks held in write-mode.  Normal
+POSIX mutexes are treated as if they are reader-writer locks which are
+only ever held in write-mode.</para>
+
+<para>Thrcheck correctly handles POSIX mutexes for which recursive
+locking is allowed.</para>
+
+<para>Thrcheck partially correctly handles x86 and amd64 memory access
+instructions preceded by a LOCK prefix.  Writes are correctly handled,
+by pretending that the LOCK prefix implies acquisition and release of
+a magic "bus hardware lock" mutex before and after the instruction.
+This unfortunately requires subsequent reads from such locations to
+also use a LOCK prefix, which is not required by the real hardware.
+Thrcheck does not offer any equivalent handling for atomic sequences
+on PowerPC/POWER platforms created by the use of lwarx/stwcx
+instructions.</para>
+
+</sect2>
+
+
+
+<sect2 id="tc-manual.data-races.errmsgs" xreflabel="Race Error Messages">
+<title>Interpreting Race Error Messages</title>
+
+<para>Thrcheck's race detection algorithm collects a lot of
+information, and tries to present it in a helpful way when a race is
+detected.  Here's an example:</para>
+
+<programlisting><![CDATA[
+Thread #2 was created
+   at 0x510548E: clone (in /lib64/libc-2.5.so)
+   by 0x4E2F305: do_clone (in /lib64/libpthread-2.5.so)
+   by 0x4E2F7C5: pthread_create@@GLIBC_2.2.5 (in /lib64/libpthread-2.5.so)
+   by 0x4C23870: pthread_create@* (tc_intercepts.c:198)
+   by 0x400CEF: main (tc17_sembar.c:195)
+
+// And the same for threads #3, #4 and #5 -- omitted for conciseness
+
+Possible data race during read of size 4 at 0x602174
+   at 0x400BE5: gomp_barrier_wait (tc17_sembar.c:122)
+   by 0x400C44: child (tc17_sembar.c:161)
+   by 0x4C25DF7: mythread_wrapper (tc_intercepts.c:178)
+   by 0x4E2F09D: start_thread (in /lib64/libpthread-2.5.so)
+   by 0x51054CC: clone (in /lib64/libc-2.5.so)
+  Old state: shared-modified by threads #2, #3, #4, #5
+  New state: shared-modified by threads #2, #3, #4, #5
+  Reason:    this thread, #2, holds no consistent locks
+  Last consistently used lock for 0x602174 was first observed
+   at 0x4C25D01: pthread_mutex_init (tc_intercepts.c:326)
+   by 0x4009E4: gomp_barrier_init (tc17_sembar.c:46)
+   by 0x400CBC: main (tc17_sembar.c:192)
+]]></programlisting>
+
+<para>Thrcheck first announces the creation points of any threads
+referenced in the error message.  This is so it can speak concisely
+about threads and sets of threads without repeatedly printing their
+creation point call stacks.  Each thread is only ever announced once,
+the first time it appears in any Thrcheck error message.</para>
+
+<para>The main error message begins at the text
+"<computeroutput>Possible data race during read</computeroutput>".
+At the start is information you would expect to see -- address and
+size of the racing access, whether a read or a write, and the call
+stack at the point it was detected.</para>
+
+<para>More interesting is the state transition caused by this access.
+This memory is already in the shared-modified state, and up to now has
+been consistently protected by at least one lock.  However, the thread
+making the access in question (thread #2, here) does not hold any
+locks in common with those held during all previous accesses to the
+location -- "no consistent locks", in other words.</para>
+
+<para>Finally, Thrcheck shows the lock which has protected this
+location in all previous accesses.  (If there is more than one, only
+one is shown).  This can be a useful hint, because it typically shows
+the lock that the programmers intended to use to protect the location,
+but in this case forgot.</para>
+
+<para>Here are some more examples of race reports.  This not an
+exhaustive list of combinations, but should give you some insight into
+how to interpret the output.</para>
+
+<programlisting><![CDATA[
+Possible data race during write ...
+  Old state: shared-readonly by threads #1, #2, #3
+  New state: shared-modified by threads #1, #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location ... has never been protected by any lock
+]]></programlisting>
+
+<para>The location is shared by 3 threads, all of which have been
+reading it without locking ("has never been protected by any lock").
+Now one of them is writing it.  Regardless of whether the writer has a
+lock or not, this is still an error, because the write races against
+the previously observed reads.</para>
+
+<programlisting><![CDATA[
+Possible data race during read ...
+  Old state: shared-modified by threads #1, #2, #3
+  New state: shared-modified by threads #1, #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Last consistently used lock for ... was first observed ...
+]]></programlisting>
+
+<para>The location is shared by 3 threads, all of which have been
+reading and writing it while (as required) holding at least one lock
+in common.  Now it is being read without that lock being held.  In the
+"Last consistently used lock" part, Thrcheck offers its best guess as
+to the identity of the lock that should have been used.</para>
+
+<programlisting><![CDATA[
+Possible data race during write ...
+  Old state: owned exclusively by thread #4
+  New state: shared-modified by threads #4, #5
+  Reason:    this thread, #5, holds no locks at all
+]]></programlisting>
+
+<para>A location that has so far been accessed exclusively by thread
+#4 has now been written by thread #5, without use of any lock.  This
+can be a sign that the programmer did not consider the possibility of
+the location being shared between threads, or, alternatively, forgot
+to use the appropriate lock.</para>
+
+<para>Note that thread #4 exclusively owns the location, and so has
+the right to access it without holding a lock.  However, this message
+does not say that thread #4 is not using a lock for this location.
+Indeed, it could be using a lock for the location because it intends
+to make it available to other threads, one of which is thread #5 --
+and thread #5 has forgotten to use the lock.</para>
+
+<para>Also, this message implies that Thrcheck did not see any
+synchronisation event between threads #4 and #5 that would have
+allowed #5 to acquire exclusive ownership from #4.  See
+<link linkend="tc-manual.data-races.exclusive">above</link>
+for a discussion of transfers of exclusive ownership states between
+threads.</para>
+
+</sect2>
+
+
+</sect1>
+
+<sect1 id="tc-manual.effective-use" xreflabel="Thrcheck Effective Use">
+<title>Hints and Tips for Effective Use of Thrcheck</title>
+
+<para>Thrcheck can be very helpful in finding and resolving
+threading-related problems.  Like all sophisticated tools, it is most
+effective when you understand how to play to its strengths.</para>
+
+<para>Thrcheck will be less effective when you merely throw an
+existing threaded program at it and try to make sense of any reported
+errors.  It will be more effective if you design threaded programs
+from the start in a way that helps Thrcheck verify correctness.  The
+same is true for finding memory errors with Memcheck, but applies more
+here, because thread checking is a harder problem.  Consequently it is
+much easier to write a correct program for which Thrcheck falsely
+reports (threading) errors than it is to write a correct program for
+which Memcheck falsely reports (memory) errors.</para>
+
+<para>With that in mind, here are some tips, listed most important first,
+for getting reliable results and avoiding false errors.  The first two
+are critical.  Any violations of them will swamp you with huge numbers
+of false data-race errors.</para>
+
+
+<orderedlist>
+
+  <listitem>
+    <para>Make sure your application, and all the libraries it uses,
+    use the POSIX threading primitives.  Thrcheck needs to be able to
+    see all events pertaining to thread creation, exit, locking and
+    other syncronisation events.  To do so it intercepts many POSIX
+    pthread_ functions.</para>
+
+    <para>Do not roll your own threading primitives (mutexes, etc)
+    from combinations of the Linux futex syscall, counters and wotnot.
+    These throw Thrcheck's internal what's-going-on models way off
+    course and will give bogus results.</para>
+
+    <para>Also, do not reimplement existing POSIX abstractions using
+    other POSIX abstractions.  For example, don't build your own
+    semaphore routines or reader-writer locks from POSIX mutexes and
+    condition variables.  Instead use POSIX reader-writer locks and
+    semaphores directly, since Thrcheck supports them directly.</para>
+
+    <para>Thrcheck directly supports the following POSIX threading
+    abstractions: mutexes, reader-writer locks, condition variables
+    (but see below), and semaphores.  Currently spinlocks and barriers
+    are not supported, although they could be in future.  A prototype
+    "safe" implementation of barriers, based on semaphores, is
+    available: please contact the Valgrind authors for details.</para>
+
+    <para>At the time of writing, the following popular Linux packages
+    are known to implement their own threading primitives:</para>
+
+    <itemizedlist>
+      <listitem><para>Qt version 4.X.  Qt 3.X is fine, but not 4.X.
+      Thrcheck contains partial direct support for Qt 4.X threading,
+      but this is not yet in a usable state.  Assistance from folks
+      knowledgeable in Qt 4 threading internals would be
+      appreciated.</para></listitem>
+
+      <listitem><para>Runtime support library for GNU OpenMP (part of
+      GCC), at least GCC versions 4.2 and 4.3.  With some minor effort
+      of modifying the GNU OpenMP runtime support sources, it is
+      possible to use Thrcheck on GNU OpenMP compiled codes.  Please
+      contact the Valgrind authors for details.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
+  <listitem>
+    <para>Avoid memory recycling.  If you can't avoid it, you must use
+    tell Thrcheck what is going on via the VALGRIND_HG_CLEAN_MEMORY
+    client request
+    (in <computeroutput>thrcheck.h</computeroutput>).</para>
+
+    <para>Thrcheck is aware of standard memory allocation and
+    deallocation that occurs via malloc/free/new/delete and from entry
+    and exit of stack frames.  In particular, when memory is
+    deallocated via free, delete, or function exit, Thrcheck considers
+    that memory clean, so when it is eventually reallocated, its
+    history is irrelevant.</para>
+
+    <para>However, it is common practice to implement memory recycling
+    schemes.  In these, memory to be freed is not handed to
+    malloc/delete, but instead put into a pool of free buffers to be
+    handed out again as required.  The problem is that Thrcheck has no
+    way to know that such memory is logically no longer in use, and
+    its history is irrelevant.  Hence you must make that explicit,
+    using the VALGRIND_HG_CLEAN_MEMORY client request to specify the
+    relevant address ranges.  It's easiest to put these requests into
+    the pool manager code, and use them either when memory is returned
+    to the pool, or is allocated from it.</para>
+  </listitem>
+
+  <listitem>
+    <para>Avoid POSIX condition variables.  If you can, use POSIX
+    semaphores (sem_t, sem_post, sem_wait) to do inter-thread event
+    signalling.  Semaphores with an initial value of zero are
+    particularly useful for this.</para>
+
+    <para>Thrcheck only partially correctly handles POSIX condition
+    variables.  This is because Thrcheck can see inter-thread
+    dependencies between a pthread_cond_wait call and a
+    pthread_cond_signal/broadcast call only if the waiting thread
+    actually gets to the rendezvous first (so that it actually calls
+    pthread_cond_wait).  It can't see dependencies between the threads
+    if the signaller arrives first.  In the latter case, POSIX
+    guidelines imply that the associated boolean condition still
+    provides an inter-thread synchronisation event, but one which is
+    invisible to Thrcheck.</para>
+
+    <para>The result of Thrcheck missing some inter-thread
+    synchronisation events is to cause it to report false positives.
+    That's because missing such events reduces the extent to which it
+    can transfer exclusive memory ownership between threads.  So
+    memory may end up in a shared-modified state when that was not
+    intended by the application programmers.</para>
+
+    <para>The root cause of this synchronisation lossage is
+    particularly hard to understand, so an example is helpful.  It was
+    discussed at length by Arndt Muehlenfeld ("Runtime Race Detection
+    in Multi-Threaded Programs", Dissertation, TU Graz, Austria).  The
+    canonical POSIX-recommended usage scheme for condition variables
+    is as follows:</para>
+
+<programlisting><![CDATA[
+b   is a Boolean condition, which is False most of the time
+cv  is a condition variable
+mx  is its associated mutex
+
+Signaller:                             Waiter:
+
+lock(mx)                               lock(mx)
+b = True                               while (b == False)
+signal(cv)                                wait(cv,mx)
+unlock(mx)                             unlock(mx)
+]]></programlisting>
+
+    <para>Assume <computeroutput>b</computeroutput> is False most of
+    the time.  If the waiter arrives at the rendezvous first, it
+    enters its while-loop, waits for the signaller to signal, and
+    eventually proceeds.  Thrcheck sees the signal, notes the
+    dependency, and all is well.</para>
+
+    <para>If the signaller arrives
+    first, <computeroutput>b</computeroutput> is set to true, and the
+    signal disappears into nowhere.  When the waiter later arrives, it
+    does not enter its while-loop and simply carries on.  But even in
+    this case, the waiter code following the while-loop cannot execute
+    until the signaller sets <computeroutput>b</computeroutput> to
+    True.  Hence there is still the same inter-thread dependency, but
+    this time it is through an arbitrary in-memory condition, and
+    Thrcheck cannot see it.</para>
+
+    <para>By comparison, Thrcheck's detection of inter-thread
+    dependencies caused by semaphore operations is believed to be
+    exactly correct.</para>
+
+    <para>As far as I know, a solution to this problem that does not
+    require source-level annotation of condition-variable wait loops
+    is beyond the current state of the art.</para>
+  </listitem>
+
+  <listitem>
+    <para>Make sure you are using a supported Linux distribution.  At
+    present, Thrcheck only properly supports x86-linux and amd64-linux
+    with glibc-2.3 or later.  The latter restriction means we only
+    support glibc's NPTL threading implementation.  The old
+    LinuxThreads implementation is not supported.</para>
+
+    <para>Unsupported targets may work to varying degrees.  In
+    particular ppc32-linux and ppc64-linux running NTPL should work,
+    but you will get false race errors because Thrcheck does not know
+    how to properly handle atomic instruction sequences created using
+    the lwarx/stwcx instructions.</para>
+  </listitem>
+
+  <listitem>
+    <para>Round up all finished threads using pthread_join.  Avoid
+    detaching threads: don't create threads in the detached state, and
+    don't call pthread_detach on existing threads.</para>
+
+    <para>Using pthread_join to round up finished threads provides a
+    clear synchronisation point that both Thrcheck and programmers can
+    see.  This synchronisation point allows Thrcheck to adjust its
+    memory ownership
+    models <link linkend="tc-manual.data-races.exclusive">as described
+    extensively above</link>, which helps Thrcheck produce more
+    accurate error reports.</para>
+
+    <para>If you don't call pthread_join on a thread, Thrcheck has no
+    way to know when it finishes, relative to any significant
+    synchronisation points for other threads in the program.  So it
+    assumes that the thread lingers indefinitely and can potentially
+    interfere indefinitely with the memory state of the program.  It
+    has every right to assume that -- after all, it might really be
+    the case that, for scheduling reasons, the exiting thread did run
+    very slowly in the last stages of its life.</para>
+  </listitem>
+
+  <listitem>
+    <para>Perform thread debugging (with Thrcheck) and memory
+    debugging (with Memcheck) together.</para>
+
+    <para>Thrcheck tracks the state of memory in detail, and memory
+    management bugs in the application are liable to cause confusion.
+    In extreme cases, applications which do many invalid reads and
+    writes (particularly to freed memory) have been known to crash
+    Thrcheck.  So, ideally, you should make your application
+    Memcheck-clean before using Thrcheck.</para>
+
+    <para>It may be impossible to make your application Memcheck-clean
+    unless you first remove threading bugs.  In particular, it may be
+    difficult to remove all reads and writes to freed memory in
+    multithreaded C++ destructor sequences at program termination.
+    So, ideally, you should make your application Thrcheck-clean
+    before using Memcheck.</para>
+
+    <para>Since this circularity is obviously unresolvable, at least
+    bear in mind that Memcheck and Thrcheck are to some extent
+    complementary, and you may need to use them together.</para>
+  </listitem>
+
+  <listitem>
+    <para>POSIX requires that implementations of standard I/O (printf,
+    fprintf, fwrite, fread, etc) are thread safe.  Unfortunately GNU
+    libc implements this by using internal locking primitives that
+    Thrcheck is unable to intercept.  Consequently Thrcheck generates
+    many false race reports when you use these functions.</para>
+
+    <para>Thrcheck attempts to hide these errors using the standard
+    Valgrind error-suppression mechanism.  So, at least for simple
+    test cases, you don't see any.  Nevertheless, some may slip
+    through.  Just something to be aware of.</para>
+  </listitem>
+
+  <listitem>
+    <para>Thrcheck's error checks do not work properly inside the
+    system threading library itself
+    (<computeroutput>libpthread.so</computeroutput>), and it usually
+    observes large numbers of (false) errors in there.  Valgrind's
+    suppression system then filters these out, so you should not see
+    them.</para>
+
+    <para>If you see any race errors reported
+    where <computeroutput>libpthread.so</computeroutput> or
+    <computeroutput>ld.so</computeroutput> is the object associated
+    with the innermost stack frame, please file a bug report at
+    http://www.valgrind.org.</para>
+  </listitem>
+
+</orderedlist>
+
+</sect1>
+
+
+
+
+<sect1 id="tc-manual.options" xreflabel="Thrcheck Options">
+<title>Thrcheck Options</title>
+
+<para>The following end-user options are available:</para>
+
+<!-- start of xi:include in the manpage -->
+<variablelist id="tc.opts.list">
+
+  <varlistentry id="opt.happens-before" xreflabel="--happens-before">
+    <term>
+      <option><![CDATA[--happens-before=none|threads|all
+      [default: all] ]]></option>
+    </term>
+    <listitem>
+      <para>Thrcheck always regards locks as the basis for
+       inter-thread synchronisation.  However, by default, before
+       reporting a race error, Thrcheck will also check whether
+       certain other kinds of inter-thread synchronisation events
+       happened.  It may be that if such events took place, then no
+       race really occurred, and so no error needs to be reported.
+       See <link linkend="tc-manual.data-races.exclusive">above</link>
+       for a discussion of transfers of exclusive ownership states
+       between threads.
+      </para>
+      <para>With <varname>--happens-before=all</varname>, the
+       following events are regarded as sources of synchronisation:
+       thread creation/joinage, condition variable
+       signal/broadcast/waits, and semaphore posts/waits.
+      </para>
+      <para>With <varname>--happens-before=threads</varname>, only
+       thread creation/joinage events are regarded as sources of
+       synchronisation.
+      </para>
+      <para>With <varname>--happens-before=none</varname>, no events
+       (apart, of course, from locking) are regarded as sources of
+       synchronisation.
+      </para>
+      <para>Changing this setting from the default will increase your
+       false-error rate but give little or no gain.  The only advantage
+       is that <option>--happens-before=threads</option> and 
+       <option>--happens-before=none</option> should make Thrcheck
+       less and less sensitive to the scheduling of threads, and hence
+       the output more and more repeatable across runs.
+      </para>
+    </listitem>
+  </varlistentry>
+
+  <varlistentry id="opt.trace-addr" xreflabel="--trace-addr">
+    <term>
+      <option><![CDATA[--trace-addr=0xXXYYZZ
+      ]]></option> and
+      <option><![CDATA[--trace-level=0|1|2 [default: 1]
+      ]]></option>
+    </term>
+    <listitem>
+      <para>Requests that Thrcheck produces a log of all state changes
+      to location 0xXXYYZZ.  This can be helpful in tracking down
+      tricky races.  <varname>--trace-level</varname> controls the
+      verbosity of the log.  At the default setting (1), a one-line
+      summary of is printed for each state change.  At level 2 a
+      complete stack trace is printed for each state change.</para>
+    </listitem>
+  </varlistentry>
+
+</variablelist>
+<!-- end of xi:include in the manpage -->
+
+<!-- start of xi:include in the manpage -->
+<para>In addition, the following debugging options are available for
+Thrcheck:</para>
+
+<variablelist id="tc.debugopts.list">
+
+  <varlistentry id="opt.trace-malloc" xreflabel="--trace-malloc">
+    <term>
+      <option><![CDATA[--trace-malloc=no|yes [no]
+      ]]></option>
+    </term>
+    <listitem>
+      <para>Show all client malloc (etc) and free (etc) requests.</para>
+    </listitem>
+  </varlistentry>
+
+  <varlistentry id="opt.gen-vcg" xreflabel="--gen-vcg">
+    <term>
+      <option><![CDATA[--gen-vcg=no|yes|yes-w-vts [no]
+      ]]></option>
+    </term>
+    <listitem>
+      <para>At exit, write to stderr a dump of the happens-before
+	graph computed by Thrcheck, in a format suitable for the VCG 
+        graph visualisation tool.  A suitable command line is:</para>
+      <para><computeroutput>valgrind --tool=thrcheck 
+        --gen-vcg=yes my_app 2&gt;&amp;1
+        | grep xxxxxx | sed "s/xxxxxx//g"
+        | xvcg -</computeroutput></para>
+      <para>With <varname>--gen-vcg=yes</varname>, the basic
+        happens-before graph is shown.  With 
+        <varname>--gen-vcg=yes-w-vts</varname>, the vector timestamp 
+        for each node is also shown.</para>
+    </listitem>
+  </varlistentry>
+
+  <varlistentry id="opt.cmp-race-err-addrs" 
+                xreflabel="--cmp-race-err-addrs">
+    <term>
+      <option><![CDATA[--cmp-race-err-addrs=no|yes [no]
+      ]]></option>
+    </term>
+    <listitem>
+      <para>Controls whether or not race (data) addresses should be
+        taken into account when removing duplicates of race errors.
+        With <varname>--cmp-race-err-addrs=no</varname>, two otherwise
+        identical race errors will be considered to be the same if
+        their race addresses differ.  With
+        With <varname>--cmp-race-err-addrs=yes</varname> they will be
+        considered different.  This is provided to help make certain
+        regression tests work reliably.</para>
+    </listitem>
+  </varlistentry>
+
+  <varlistentry id="opt.tc-sanity-flags" xreflabel="--tc-sanity-flags">
+    <term>
+      <option><![CDATA[--tc-sanity-flags=<XXXXX> (X = 0|1) [00000]
+      ]]></option>
+    </term>
+    <listitem>
+      <para>Run extensive sanity checks on Thrcheck's internal
+        data structures at events defined by the bitstring, as
+        follows:</para>
+      <para><computeroutput>10000 </computeroutput>after changes to
+        the lock order acquisition graph</para>
+      <para><computeroutput>01000 </computeroutput>after every client
+        memory access (NB: not currently used)</para>
+      <para><computeroutput>00100 </computeroutput>after every client
+        memory range permission setting of 256 bytes or greater</para>
+      <para><computeroutput>00010 </computeroutput>after every client
+        lock or unlock event</para>
+      <para><computeroutput>00001 </computeroutput>after every client
+        thread creation or joinage event</para>
+      <para>Note these will make Thrcheck run very slowly, often to
+        the point of being completely unusable.</para>
+    </listitem>
+  </varlistentry>
+
+</variablelist>
+<!-- end of xi:include in the manpage -->
+
+
+</sect1>
+
+<sect1 id="tc-manual.todolist" xreflabel="To Do List">
+<title>A To-Do List for Thrcheck</title>
+
+<para>The following is a list of loose ends which should be tidied up
+some time.</para>
+
+<itemizedlist>
+  <listitem><para>Track which mutexes are associated with which
+    condition variables, and emit a warning if this becomes
+    inconsistent.</para>
+  </listitem>
+  <listitem><para>For lock order errors, print the complete lock
+    cycle, rather than only doing for size-2 cycles as at
+    present.</para>
+  </listitem>
+  <listitem><para>Document the VALGRIND_HG_CLEAN_MEMORY client
+    request.</para>
+  </listitem>
+  <listitem><para>Possibly a client request to forcibly transfer
+    ownership of memory from one thread to another.  Requires further
+    consideration.</para>
+  </listitem>
+  <listitem><para>Add a new client request that marks an address range
+    as being "shared-modified with empty lockset" (the error state),
+    and describe how to use it.</para>
+  </listitem>
+  <listitem><para>Document races caused by gcc's thread-unsafe code
+    generation for speculative stores.  In the interim see
+    <computeroutput>http://gcc.gnu.org/ml/gcc/2007-10/msg00266.html
+    </computeroutput>
+    and <computeroutput>http://lkml.org/lkml/2007/10/24/673</computeroutput>.
+    </para>
+  </listitem>
+  <listitem><para>Don't update the lock-order graph, and don't check
+    for errors, when a "try"-style lock operation happens (eg
+    pthread_mutex_trylock).  Such calls do not add any real
+    restrictions to the locking order, since they can always fail to
+    acquire the lock, resulting in the caller going off and doing Plan
+    B (presumably it will have a Plan B).  Doing such checks could
+    generate false lock-order errors and confuse users.</para>
+  </listitem>
+  <listitem><para> Performance can be very poor.  Slowdowns on the
+    order of 100:1 are not unusual.  There is quite some scope for
+    performance improvements, though.
+    </para>
+  </listitem>
+
+</itemizedlist>
+
+</sect1>
+
+</chapter>
diff --git a/helgrind/helgrind.h b/helgrind/helgrind.h
new file mode 100644
index 0000000..b2f6ed3
--- /dev/null
+++ b/helgrind/helgrind.h
@@ -0,0 +1,109 @@
+/*
+   ----------------------------------------------------------------
+
+   Notice that the above BSD-style license applies to this one file
+   (helgrind.h) only.  The entire rest of Valgrind is licensed under
+   the terms of the GNU General Public License, version 2.  See the
+   COPYING file in the source distribution for details.
+
+   ----------------------------------------------------------------
+
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 OpenWorks LLP
+      info@open-works.co.uk
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+   2. The origin of this software must not be misrepresented; you must 
+      not claim that you wrote the original software.  If you use this 
+      software in a product, an acknowledgment in the product 
+      documentation would be appreciated but is not required.
+
+   3. Altered source versions must be plainly marked as such, and must
+      not be misrepresented as being the original software.
+
+   4. The name of the author may not be used to endorse or promote 
+      products derived from this software without specific prior written 
+      permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   ----------------------------------------------------------------
+
+   Notice that the above BSD-style license applies to this one file
+   (helgrind.h) only.  The entire rest of Valgrind is licensed under
+   the terms of the GNU General Public License, version 2.  See the
+   COPYING file in the source distribution for details.
+
+   ---------------------------------------------------------------- 
+*/
+
+#ifndef __HELGRIND_H
+#define __HELGRIND_H
+
+#include "valgrind.h"
+
+typedef
+   enum {
+      VG_USERREQ__HG_CLEAN_MEMORY = VG_USERREQ_TOOL_BASE('H','G'),
+
+      /* The rest are for Helgrind's internal use.  Not for end-user
+         use.  Do not use them unless you are a Valgrind developer. */
+
+      /* Notify the tool what this thread's pthread_t is. */
+      _VG_USERREQ__HG_SET_MY_PTHREAD_T = VG_USERREQ_TOOL_BASE('H','G') 
+                                         + 256,
+      _VG_USERREQ__HG_PTH_API_ERROR,              /* char*, int */
+      _VG_USERREQ__HG_PTHREAD_JOIN_POST,          /* pthread_t of quitter */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,    /* pth_mx_t*, long mbRec */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,  /* pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,   /* pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,  /* pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE, /* pth_mx_t*, long isTryLock */
+      _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,    /* pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE,    /* pth_cond_t* */
+      _VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE, /* pth_cond_t* */
+      _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,     /* pth_cond_t*, pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,    /* pth_cond_t*, pth_mx_t* */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,   /* pth_rwlk_t* */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE, /* pth_rwlk_t* */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,    /* pth_rwlk_t*, long isW */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,   /* pth_rwlk_t*, long isW */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,  /* pth_rwlk_t* */
+      _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST, /* pth_rwlk_t* */
+      _VG_USERREQ__HG_POSIX_SEMPOST_PRE,          /* sem_t* */
+      _VG_USERREQ__HG_POSIX_SEMWAIT_POST,         /* sem_t* */
+      _VG_USERREQ__HG_POSIX_SEM_ZAPSTACK,         /* sem_t* */
+      _VG_USERREQ__HG_GET_MY_SEGMENT              /* -> Segment* */
+   } Vg_TCheckClientRequest;
+
+/* Clean memory state.  This makes Helgrind forget everything it knew
+   about the specified memory range, and resets it to New.  This is
+   particularly useful for memory allocators that wish to recycle
+   memory. */
+#define VALGRIND_HG_CLEAN_MEMORY(_qzz_start, _qzz_len)                    \
+   do {                                                                   \
+     unsigned long _qzz_res;                                              \
+     VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, VG_USERREQ__HG_CLEAN_MEMORY, \
+                                _qzz_start, _qzz_len, 0, 0, 0);	          \
+     (void)0;                                                             \
+   } while(0)
+
+#endif /* __HELGRIND_H */
diff --git a/helgrind/hg_intercepts.c b/helgrind/hg_intercepts.c
new file mode 100644
index 0000000..10be82b
--- /dev/null
+++ b/helgrind/hg_intercepts.c
@@ -0,0 +1,1219 @@
+
+/*--------------------------------------------------------------------*/
+/*--- pthread intercepts for thread checking.                      ---*/
+/*---                                              tc_intercepts.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 OpenWorks LLP
+      info@open-works.co.uk
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+
+   Neither the names of the U.S. Department of Energy nor the
+   University of California nor the names of its contributors may be
+   used to endorse or promote products derived from this software
+   without prior written permission.
+*/
+
+/* RUNS ON SIMULATED CPU
+   Interceptors for pthread_* functions, so that tc_main can see
+   significant thread events. 
+
+   Important: when adding a function wrapper to this file, remember to
+   add a test case to tc20_verifywrap.c.  A common cause of failure is
+   for wrappers to not engage on different distros, and
+   tc20_verifywrap essentially checks that each wrapper is really
+   doing something.
+*/
+
+#include "pub_tool_basics.h"
+#include "valgrind.h"
+#include "helgrind.h"
+
+#define TRACE_PTH_FNS 0
+#define TRACE_QT4_FNS 0
+
+
+/*----------------------------------------------------------------*/
+/*---                                                          ---*/
+/*----------------------------------------------------------------*/
+
+#define PTH_FUNC(ret_ty, f, args...) \
+   ret_ty I_WRAP_SONAME_FNNAME_ZZ(libpthreadZdsoZd0,f)(args); \
+   ret_ty I_WRAP_SONAME_FNNAME_ZZ(libpthreadZdsoZd0,f)(args)
+
+// Do a client request.  This is a macro rather than a function 
+// so as to avoid having an extra function in the stack trace.
+
+#define DO_CREQ_v_W(_creqF, _ty1F,_arg1F)                \
+   do {                                                  \
+      Word _unused_res, _arg1;                           \
+      assert(sizeof(_ty1F) == sizeof(Word));             \
+      _arg1 = (Word)(_arg1F);                            \
+      VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0,         \
+                                 (_creqF),               \
+                                 _arg1, 0,0,0,0);        \
+   } while (0)
+
+#define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \
+   do {                                                  \
+      Word _unused_res, _arg1, _arg2;                    \
+      assert(sizeof(_ty1F) == sizeof(Word));             \
+      assert(sizeof(_ty2F) == sizeof(Word));             \
+      _arg1 = (Word)(_arg1F);                            \
+      _arg2 = (Word)(_arg2F);                            \
+      VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0,         \
+                                 (_creqF),               \
+                                 _arg1,_arg2,0,0,0);     \
+   } while (0)
+
+#define DO_CREQ_W_WW(_resF, _creqF, _ty1F,_arg1F, _ty2F,_arg2F)	\
+   do {                                                  \
+      Word _res, _arg1, _arg2;                           \
+      assert(sizeof(_ty1F) == sizeof(Word));             \
+      assert(sizeof(_ty2F) == sizeof(Word));             \
+      _arg1 = (Word)(_arg1F);                            \
+      _arg2 = (Word)(_arg2F);                            \
+      VALGRIND_DO_CLIENT_REQUEST(_res, 2,                \
+                                 (_creqF),               \
+                                 _arg1,_arg2,0,0,0);     \
+      _resF = _res;                                      \
+   } while (0)
+
+#define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F,              \
+		      _ty2F,_arg2F, _ty3F, _arg3F)       \
+   do {                                                  \
+      Word _unused_res, _arg1, _arg2, _arg3;             \
+      assert(sizeof(_ty1F) == sizeof(Word));             \
+      assert(sizeof(_ty2F) == sizeof(Word));             \
+      assert(sizeof(_ty3F) == sizeof(Word));             \
+      _arg1 = (Word)(_arg1F);                            \
+      _arg2 = (Word)(_arg2F);                            \
+      _arg3 = (Word)(_arg3F);                            \
+      VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0,         \
+                                 (_creqF),               \
+                                 _arg1,_arg2,_arg3,0,0); \
+   } while (0)
+
+
+#define DO_PthAPIerror(_fnnameF, _errF)                  \
+   do {                                                  \
+      char* _fnname = (char*)(_fnnameF);                 \
+      long  _err    = (long)(int)(_errF);	         \
+      char* _errstr = lame_strerror(_err);               \
+      DO_CREQ_v_WWW(_VG_USERREQ__HG_PTH_API_ERROR,       \
+                    char*,_fnname,                       \
+                    long,_err, char*,_errstr);           \
+   } while (0)
+
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+   otherwise "know" about pthread_rwlock_anything or about
+   PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+
+
+/* A lame version of strerror which doesn't use the real libc
+   strerror_r, since using the latter just generates endless more
+   threading errors (glibc goes off and does tons of crap w.r.t.
+   locales etc) */
+static char* lame_strerror ( long err )
+{   switch (err) {
+      case EPERM:       return "EPERM: Operation not permitted";
+      case ENOENT:      return "ENOENT: No such file or directory";
+      case ESRCH:       return "ESRCH: No such process";
+      case EINTR:       return "EINTR: Interrupted system call";
+      case EBADF:       return "EBADF: Bad file number";
+      case EAGAIN:      return "EAGAIN: Try again";
+      case ENOMEM:      return "ENOMEM: Out of memory";
+      case EACCES:      return "EACCES: Permission denied";
+      case EFAULT:      return "EFAULT: Bad address";
+      case EEXIST:      return "EEXIST: File exists";
+      case EINVAL:      return "EINVAL: Invalid argument";
+      case EMFILE:      return "EMFILE: Too many open files";
+      case ENOSYS:      return "ENOSYS: Function not implemented";
+      case EOVERFLOW:   return "EOVERFLOW: Value too large "
+                               "for defined data type";
+      case EBUSY:       return "EBUSY: Device or resource busy";
+      case ETIMEDOUT:   return "ETIMEDOUT: Connection timed out";
+      case EDEADLK:     return "EDEADLK: Resource deadlock would occur";
+      case EOPNOTSUPP:  return "EOPNOTSUPP: Operation not supported on "
+                               "transport endpoint"; /* honest, guv */
+      default:          return "tc_intercepts.c: lame_strerror(): "
+                               "unhandled case -- please fix me!";
+   }
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_create, pthread_join, pthread_exit               ---*/
+/*----------------------------------------------------------------*/
+
+static void* mythread_wrapper ( void* xargsV )
+{
+   volatile Word volatile* xargs = (volatile Word volatile*) xargsV;
+   void*(*fn)(void*) = (void*(*)(void*))xargs[0];
+   void* arg         = (void*)xargs[1];
+   pthread_t me = pthread_self();
+   /* Tell the tool what my pthread_t is. */
+   DO_CREQ_v_W(_VG_USERREQ__HG_SET_MY_PTHREAD_T, pthread_t,me);
+   /* allow the parent to proceed.  We can't let it proceed until
+      we're ready because (1) we need to make sure it doesn't exit and
+      hence deallocate xargs[] while we still need it, and (2) we
+      don't want either parent nor child to proceed until the tool has
+      been notified of the child's pthread_t. */
+   xargs[2] = 0;
+   /* Now we can no longer safely use xargs[]. */
+   return (void*) fn( (void*)arg );
+}
+
+// pthread_create
+PTH_FUNC(int, pthreadZucreateZAZa, // pthread_create@*
+              pthread_t *thread, const pthread_attr_t *attr,
+              void *(*start) (void *), void *arg)
+{
+   int    ret;
+   OrigFn fn;
+   volatile Word xargs[3];
+
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_create wrapper"); fflush(stderr);
+   }
+   xargs[0] = (Word)start;
+   xargs[1] = (Word)arg;
+   xargs[2] = 1; /* serves as a spinlock -- sigh */
+
+   CALL_FN_W_WWWW(ret, fn, thread,attr,mythread_wrapper,&xargs[0]);
+
+   if (ret == 0) {
+      /* we have to wait for the child to notify the tool of its
+         pthread_t before continuing */
+      while (xargs[2] != 0) {
+         // FIXME: add a yield client request
+         /* do nothing */
+      }
+   } else { 
+      DO_PthAPIerror( "pthread_create", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: pth_create -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+// pthread_join
+PTH_FUNC(int, pthreadZujoin, // pthread_join
+              pthread_t thread, void** value_pointer)
+{
+   int ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_join wrapper"); fflush(stderr);
+   }
+
+   CALL_FN_W_WW(ret, fn, thread,value_pointer);
+
+   /* At least with NPTL as the thread library, this is safe because
+      it is guaranteed (by NPTL) that the joiner will completely gone
+      before pthread_join (the original) returns.  See email below.*/
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_JOIN_POST, pthread_t,thread);
+   } else { 
+      DO_PthAPIerror( "pthread_join", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: pth_join -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+/* Behaviour of pthread_join on NPTL:
+
+Me:
+I have a question re the NPTL pthread_join implementation.
+
+  Suppose I am the thread 'stayer'.  
+
+  If I call pthread_join(quitter), is it guaranteed that the
+  thread 'quitter' has really exited before pthread_join returns?
+
+  IOW, is it guaranteed that 'quitter' will not execute any further
+  instructions after pthread_join returns?
+
+I believe this is true based on the following analysis of
+glibc-2.5 sources.  However am not 100% sure and would appreciate
+confirmation.
+
+  'quitter' will be running start_thread() in nptl/pthread_create.c
+
+  The last action of start_thread() is to exit via
+  __exit_thread_inline(0), which simply does sys_exit 
+  (nptl/pthread_create.c:403)
+
+  'stayer' meanwhile is waiting for lll_wait_tid (pd->tid) 
+  (call at nptl/pthread_join.c:89)
+
+  As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
+  lll_wait_tid will not return until kernel notifies via futex
+  wakeup that 'quitter' has terminated.
+
+  Hence pthread_join cannot return until 'quitter' really has
+  completely disappeared.
+
+Drepper:
+>   As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
+>   lll_wait_tid will not return until kernel notifies via futex
+>   wakeup that 'quitter' has terminated.
+That's the key.  The kernel resets the TID field after the thread is
+done.  No way the joiner can return before the thread is gone.
+*/
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_mutex_t functions                                ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled:   pthread_mutex_init pthread_mutex_destroy
+              pthread_mutex_lock
+              pthread_mutex_trylock pthread_mutex_timedlock
+              pthread_mutex_unlock
+
+   Unhandled: pthread_spin_init pthread_spin_destroy 
+              pthread_spin_lock
+              pthread_spin_trylock
+              pthread_spin_unlock
+*/
+
+// pthread_mutex_init
+PTH_FUNC(int, pthreadZumutexZuinit, // pthread_mutex_init
+              pthread_mutex_t *mutex,
+              pthread_mutexattr_t* attr)
+{
+   int    ret;
+   long   mbRec;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxinit %p", mutex); fflush(stderr);
+   }
+
+   mbRec = 0;
+   if (attr) {
+      int ty, zzz;
+      zzz = pthread_mutexattr_gettype(attr, &ty);
+      if (zzz == 0 && ty == PTHREAD_MUTEX_RECURSIVE)
+         mbRec = 1;
+   }
+
+   CALL_FN_W_WW(ret, fn, mutex,attr);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
+                   pthread_mutex_t*,mutex, long,mbRec);
+   } else { 
+      DO_PthAPIerror( "pthread_mutex_init", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: mxinit -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_mutex_destroy
+PTH_FUNC(int, pthreadZumutexZudestroy, // pthread_mutex_destroy
+              pthread_mutex_t *mutex)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxdestroy %p", mutex); fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,
+               pthread_mutex_t*,mutex);
+
+   CALL_FN_W_W(ret, fn, mutex);
+
+   if (ret != 0) {
+      DO_PthAPIerror( "pthread_mutex_destroy", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: mxdestroy -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_mutex_lock
+PTH_FUNC(int, pthreadZumutexZulock, // pthread_mutex_lock
+              pthread_mutex_t *mutex)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxlock %p", mutex); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+                pthread_mutex_t*,mutex, long,0/*!isTryLock*/);
+
+   CALL_FN_W_W(ret, fn, mutex);
+
+   /* There's a hole here: libpthread now knows the lock is locked,
+      but the tool doesn't, so some other thread could run and detect
+      that the lock has been acquired by someone (this thread).  Does
+      this matter?  Not sure, but I don't think so. */
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  pthread_mutex_t*,mutex);
+   } else { 
+      DO_PthAPIerror( "pthread_mutex_lock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: mxlock -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_mutex_trylock.  The handling needed here is very similar
+// to that for pthread_mutex_lock, except that we need to tell
+// the pre-lock creq that this is a trylock-style operation, and
+// therefore not to complain if the lock is nonrecursive and 
+// already locked by this thread -- because then it'll just fail
+// immediately with EBUSY.
+PTH_FUNC(int, pthreadZumutexZutrylock, // pthread_mutex_trylock
+              pthread_mutex_t *mutex)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxtrylock %p", mutex); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+                pthread_mutex_t*,mutex, long,1/*isTryLock*/);
+
+   CALL_FN_W_W(ret, fn, mutex);
+
+   /* There's a hole here: libpthread now knows the lock is locked,
+      but the tool doesn't, so some other thread could run and detect
+      that the lock has been acquired by someone (this thread).  Does
+      this matter?  Not sure, but I don't think so. */
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  pthread_mutex_t*,mutex);
+   } else { 
+      if (ret != EBUSY)
+         DO_PthAPIerror( "pthread_mutex_trylock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: mxtrylock -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_mutex_timedlock.  Identical logic to pthread_mutex_trylock.
+PTH_FUNC(int, pthreadZumutexZutimedlock, // pthread_mutex_timedlock
+	 pthread_mutex_t *mutex,
+         void* timeout)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxtimedlock %p %p", mutex, timeout); 
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+                pthread_mutex_t*,mutex, long,1/*isTryLock-ish*/);
+
+   CALL_FN_W_WW(ret, fn, mutex,timeout);
+
+   /* There's a hole here: libpthread now knows the lock is locked,
+      but the tool doesn't, so some other thread could run and detect
+      that the lock has been acquired by someone (this thread).  Does
+      this matter?  Not sure, but I don't think so. */
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  pthread_mutex_t*,mutex);
+   } else { 
+      if (ret != ETIMEDOUT)
+         DO_PthAPIerror( "pthread_mutex_timedlock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: mxtimedlock -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_mutex_unlock
+PTH_FUNC(int, pthreadZumutexZuunlock, // pthread_mutex_unlock
+              pthread_mutex_t *mutex)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_mxunlk %p", mutex); fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+               pthread_mutex_t*,mutex);
+
+   CALL_FN_W_W(ret, fn, mutex);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
+                  pthread_mutex_t*,mutex);
+   } else { 
+      DO_PthAPIerror( "pthread_mutex_unlock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " mxunlk -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_cond_t functions                                 ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled:   pthread_cond_wait pthread_cond_timedwait
+              pthread_cond_signal pthread_cond_broadcast
+
+   Unhandled: pthread_cond_init pthread_cond_destroy
+              -- are these important?
+*/
+
+// pthread_cond_wait
+PTH_FUNC(int, pthreadZucondZuwaitZAZa, // pthread_cond_wait@*
+              pthread_cond_t* cond, pthread_mutex_t* mutex)
+{
+   int ret;
+   OrigFn fn;
+   unsigned long mutex_is_valid;
+
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_cond_wait %p %p", cond, mutex);
+      fflush(stderr);
+   }
+
+   /* Tell the tool a cond-wait is about to happen, so it can check
+      for bogus argument values.  In return it tells us whether it
+      thinks the mutex is valid or not. */
+   DO_CREQ_W_WW(mutex_is_valid,
+                _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
+                pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+   assert(mutex_is_valid == 1 || mutex_is_valid == 0);
+
+   /* Tell the tool we're about to drop the mutex.  This reflects the
+      fact that in a cond_wait, we show up holding the mutex, and the
+      call atomically drops the mutex and waits for the cv to be
+      signalled. */
+   if (mutex_is_valid) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+                  pthread_mutex_t*,mutex);
+   }
+
+   CALL_FN_W_WW(ret, fn, cond,mutex);
+
+   /* these conditionals look stupid, but compare w/ same logic for
+      pthread_cond_timedwait below */
+   if (ret == 0 && mutex_is_valid) {
+      /* and now we have the mutex again */
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  pthread_mutex_t*,mutex);
+   }
+
+   if (ret == 0 && mutex_is_valid) {
+      DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
+                   pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+   }
+
+   if (ret != 0) {
+      DO_PthAPIerror( "pthread_cond_wait", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " cowait -> %d >>\n", ret);
+   }
+
+   return ret;
+}
+
+
+// pthread_cond_timedwait
+PTH_FUNC(int, pthreadZucondZutimedwaitZAZa, // pthread_cond_timedwait@*
+         pthread_cond_t* cond, pthread_mutex_t* mutex, 
+         struct timespec* abstime)
+{
+   int ret;
+   OrigFn fn;
+   unsigned long mutex_is_valid;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_cond_timedwait %p %p %p", 
+                      cond, mutex, abstime);
+      fflush(stderr);
+   }
+
+   /* Tell the tool a cond-wait is about to happen, so it can check
+      for bogus argument values.  In return it tells us whether it
+      thinks the mutex is valid or not. */
+   DO_CREQ_W_WW(mutex_is_valid,
+                _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
+                pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+   assert(mutex_is_valid == 1 || mutex_is_valid == 0);
+
+   /* Tell the tool we're about to drop the mutex.  This reflects the
+      fact that in a cond_wait, we show up holding the mutex, and the
+      call atomically drops the mutex and waits for the cv to be
+      signalled. */
+   if (mutex_is_valid) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+                  pthread_mutex_t*,mutex);
+   }
+
+   CALL_FN_W_WWW(ret, fn, cond,mutex,abstime);
+
+   if ((ret == 0 || ret == ETIMEDOUT) && mutex_is_valid) {
+      /* and now we have the mutex again */
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  pthread_mutex_t*,mutex);
+   }
+
+   if (ret == 0 && mutex_is_valid) {
+      DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
+                   pthread_cond_t*,cond, pthread_mutex_t*,mutex);
+   }
+
+   if (ret != 0 && ret != ETIMEDOUT) {
+      DO_PthAPIerror( "pthread_cond_timedwait", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " cotimedwait -> %d >>\n", ret);
+   }
+
+   return ret;
+}
+
+
+// pthread_cond_signal
+PTH_FUNC(int, pthreadZucondZusignalZAZa, // pthread_cond_signal@*
+              pthread_cond_t* cond)
+{
+   int ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_cond_signal %p", cond);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE,
+               pthread_cond_t*,cond);
+
+   CALL_FN_W_W(ret, fn, cond);
+
+   if (ret != 0) {
+      DO_PthAPIerror( "pthread_cond_signal", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " cosig -> %d >>\n", ret);
+   }
+
+   return ret;
+}
+
+
+// pthread_cond_broadcast
+// Note, this is pretty much identical, from a dependency-graph
+// point of view, with cond_signal, so the code is duplicated.
+// Maybe it should be commoned up.
+PTH_FUNC(int, pthreadZucondZubroadcastZAZa, // pthread_cond_broadcast@*
+              pthread_cond_t* cond)
+{
+   int ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_broadcast_signal %p", cond);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE,
+               pthread_cond_t*,cond);
+
+   CALL_FN_W_W(ret, fn, cond);
+
+   if (ret != 0) { 
+      DO_PthAPIerror( "pthread_cond_broadcast", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " cobro -> %d >>\n", ret);
+   }
+
+   return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- pthread_rwlock_t functions                               ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled:   pthread_rwlock_init pthread_rwlock_destroy
+              pthread_rwlock_rdlock 
+              pthread_rwlock_wrlock
+              pthread_rwlock_unlock
+
+   Unhandled: pthread_rwlock_timedrdlock
+              pthread_rwlock_tryrdlock
+
+              pthread_rwlock_timedwrlock
+              pthread_rwlock_trywrlock
+*/
+
+// pthread_rwlock_init
+PTH_FUNC(int, pthreadZurwlockZuinit, // pthread_rwlock_init
+              pthread_rwlock_t *rwl,
+              pthread_rwlockattr_t* attr)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_rwl_init %p", rwl); fflush(stderr);
+   }
+
+   CALL_FN_W_WW(ret, fn, rwl,attr);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,
+                  pthread_rwlock_t*,rwl);
+   } else { 
+      DO_PthAPIerror( "pthread_rwlock_init", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: rwl_init -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+// pthread_rwlock_destroy
+PTH_FUNC(int, pthreadZurwlockZudestroy, // pthread_rwlock_destroy
+              pthread_rwlock_t *rwl)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_rwl_destroy %p", rwl); fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE,
+               pthread_rwlock_t*,rwl);
+
+   CALL_FN_W_W(ret, fn, rwl);
+
+   if (ret != 0) {
+      DO_PthAPIerror( "pthread_rwlock_destroy", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: rwl_destroy -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZuwrlock, // pthread_rwlock_wrlock
+	 pthread_rwlock_t* rwlock)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_rwl_wlk %p", rwlock); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+                pthread_rwlock_t*,rwlock, long,1/*isW*/);
+
+   CALL_FN_W_W(ret, fn, rwlock);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+                   pthread_rwlock_t*,rwlock, long,1/*isW*/);
+   } else { 
+      DO_PthAPIerror( "pthread_rwlock_wrlock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: rwl_wlk -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZurdlock, // pthread_rwlock_rdlock
+	 pthread_rwlock_t* rwlock)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_rwl_rlk %p", rwlock); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+                pthread_rwlock_t*,rwlock, long,0/*!isW*/);
+
+   CALL_FN_W_W(ret, fn, rwlock);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+                   pthread_rwlock_t*,rwlock, long,0/*!isW*/);
+   } else { 
+      DO_PthAPIerror( "pthread_rwlock_rdlock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: rwl_rlk -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+PTH_FUNC(int, pthreadZurwlockZuunlock, // pthread_rwlock_unlock
+	 pthread_rwlock_t* rwlock)
+{
+   int    ret;
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, "<< pthread_rwl_unlk %p", rwlock); fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
+               pthread_rwlock_t*,rwlock);
+
+   CALL_FN_W_W(ret, fn, rwlock);
+
+   if (ret == 0 /*success*/) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
+                  pthread_rwlock_t*,rwlock);
+   } else { 
+      DO_PthAPIerror( "pthread_rwlock_unlock", ret );
+   }
+
+   if (TRACE_PTH_FNS) {
+      fprintf(stderr, " :: rwl_unlk -> %d >>\n", ret);
+   }
+   return ret;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- POSIX semaphores                                         ---*/
+/*----------------------------------------------------------------*/
+
+#include <semaphore.h>
+
+#define TRACE_SEM_FNS 0
+
+/* Handled: 
+     int sem_init(sem_t *sem, int pshared, unsigned value);
+     int sem_destroy(sem_t *sem);
+     int sem_wait(sem_t *sem);
+     int sem_post(sem_t *sem);
+
+   Unhandled:
+     int sem_trywait(sem_t *sem);
+     int sem_timedwait(sem_t *restrict sem,
+                       const struct timespec *restrict abs_timeout);
+*/
+
+/* glibc-2.5 has sem_init@@GLIBC_2.2.5 (amd64-linux)
+             and sem_init@@GLIBC_2.1 (x86-linux): match sem_init@* */
+PTH_FUNC(int, semZuinitZAZa, sem_t* sem, int pshared, unsigned long value)
+{
+   OrigFn fn;
+   int    ret;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, "<< sem_init(%p,%d,%lu) ", sem,pshared,value);
+      fflush(stderr);
+   }
+
+   CALL_FN_W_WWW(ret, fn, sem,pshared,value);
+
+   if (ret == 0) {
+      /* Probably overly paranoid, but still ... */
+      DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_ZAPSTACK, sem_t*,sem);
+   } else {
+      DO_PthAPIerror( "sem_init", errno );
+   }
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, " sem_init -> %d >>\n", ret);
+      fflush(stderr);
+   }
+
+   return ret;
+}
+
+
+/* glibc-2.5 has sem_destroy@@GLIBC_2.2.5 (amd64-linux)
+             and sem_destroy@@GLIBC_2.1 (x86-linux); match sem_destroy@* */
+PTH_FUNC(int, semZudestroyZAZa, sem_t* sem)
+{
+   OrigFn fn;
+   int    ret;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, "<< sem_destroy(%p) ", sem);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_ZAPSTACK, sem_t*,sem);
+
+   CALL_FN_W_W(ret, fn, sem);
+
+   if (ret != 0) {
+      DO_PthAPIerror( "sem_destroy", errno );
+   }
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, " sem_destroy -> %d >>\n", ret);
+      fflush(stderr);
+   }
+
+   return ret;
+}
+
+
+/* glibc-2.5 has sem_wait (amd64-linux); match sem_wait
+             and sem_wait@@GLIBC_2.1 (x86-linux); match sem_wait@* */
+/* wait: decrement semaphore - acquire lockage */
+static int sem_wait_WRK(sem_t* sem)
+{
+   OrigFn fn;
+   int    ret;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, "<< sem_wait(%p) ", sem);
+      fflush(stderr);
+   }
+
+   CALL_FN_W_W(ret, fn, sem);
+
+   if (ret == 0) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEMWAIT_POST, sem_t*,sem);
+   } else {
+      DO_PthAPIerror( "sem_wait", errno );
+   }
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, " sem_wait -> %d >>\n", ret);
+      fflush(stderr);
+   }
+
+   return ret;
+}
+PTH_FUNC(int, semZuwait, sem_t* sem) { /* sem_wait */
+   return sem_wait_WRK(sem);
+}
+PTH_FUNC(int, semZuwaitZAZa, sem_t* sem) { /* sem_wait@* */
+   return sem_wait_WRK(sem);
+}
+
+
+/* glibc-2.5 has sem_post (amd64-linux); match sem_post
+             and sem_post@@GLIBC_2.1 (x86-linux); match sem_post@* */
+/* post: increment semaphore - release lockage */
+static int sem_post_WRK(sem_t* sem)
+{
+   OrigFn fn;
+   int    ret;
+
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, "<< sem_post(%p) ", sem);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEMPOST_PRE, sem_t*,sem);
+
+   CALL_FN_W_W(ret, fn, sem);
+
+   if (ret != 0) {
+      DO_PthAPIerror( "sem_post", errno );
+   }
+
+   if (TRACE_SEM_FNS) {
+      fprintf(stderr, " sem_post -> %d >>\n", ret);
+      fflush(stderr);
+   }
+
+   return ret;
+}
+PTH_FUNC(int, semZupost, sem_t* sem) { /* sem_post */
+   return sem_post_WRK(sem);
+}
+PTH_FUNC(int, semZupostZAZa, sem_t* sem) { /* sem_post@* */
+   return sem_post_WRK(sem);
+}
+
+
+
+/*----------------------------------------------------------------*/
+/*--- Qt 4 threading functions (w/ GNU name mangling)          ---*/
+/*----------------------------------------------------------------*/
+
+/* Handled:   QMutex::lock()
+              QMutex::unlock()
+              QMutex::tryLock
+              QReadWriteLock::lockForRead()
+              QReadWriteLock::lockForWrite()
+              QReadWriteLock::unlock()
+
+   Unhandled: QMutex::tryLock(int)
+              QReadWriteLock::tryLockForRead(int)
+              QReadWriteLock::tryLockForRead()
+              QReadWriteLock::tryLockForWrite(int)
+              QReadWriteLock::tryLockForWrite()
+
+              maybe not the next 3; qt-4.3.1 on Unix merely
+              implements QWaitCondition using pthread_cond_t
+              QWaitCondition::wait(QMutex*, unsigned long)
+              QWaitCondition::wakeAll()
+              QWaitCondition::wakeOne()
+*/
+
+// soname is libQtCore.so.4 ; match against libQtCore.so*
+#define QT4_FUNC(ret_ty, f, args...) \
+   ret_ty I_WRAP_SONAME_FNNAME_ZZ(libQtCoreZdsoZa,f)(args); \
+   ret_ty I_WRAP_SONAME_FNNAME_ZZ(libQtCoreZdsoZa,f)(args)
+
+// QMutex::lock()
+QT4_FUNC(void, ZuZZN6QMutex4lockEv, // _ZN6QMutex4lockEv == QMutex::lock()
+               void* self)
+{
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QMutex::lock %p", self); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+                void*,self, long,0/*!isTryLock*/);
+
+   CALL_FN_v_W(fn, self);
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+               void*, self);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " :: Q::lock done >>\n");
+   }
+}
+
+// QMutex::unlock()
+QT4_FUNC(void, ZuZZN6QMutex6unlockEv, // _ZN6QMutex6unlockEv == QMutex::unlock()
+               void* self)
+{
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QMutex::unlock %p", self); fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
+               void*, self);
+
+   CALL_FN_v_W(fn, self);
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
+               void*, self);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " Q::unlock done >>\n");
+   }
+}
+
+// QMutex::tryLock
+// _ZN6QMutex7tryLockEv == bool QMutex::tryLock()
+// using 'long' to mimic C++ 'bool'
+QT4_FUNC(long, ZuZZN6QMutex7tryLockEv,
+               void* self)
+{
+   OrigFn fn;
+   long   ret;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QMutex::tryLock %p", self); fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
+                void*,self, long,1/*isTryLock*/);
+
+   CALL_FN_W_W(ret, fn, self);
+
+   // assumes that only the low 8 bits of the 'bool' are significant
+   if (ret & 0xFF) {
+      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
+                  void*, self);
+   }
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " :: Q::tryLock -> %lu >>\n", ret);
+   }
+   
+   return ret;
+}
+
+
+// QReadWriteLock::lockForRead()
+// _ZN14QReadWriteLock11lockForReadEv == QReadWriteLock::lockForRead()
+QT4_FUNC(void, ZuZZN14QReadWriteLock11lockForReadEv, 
+               // _ZN14QReadWriteLock11lockForReadEv
+               void* self)
+{
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QReadWriteLock::lockForRead %p", self);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+                void*,self, long,0/*!isW*/);
+
+   CALL_FN_v_W(fn, self);
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+                void*,self, long,0/*!isW*/);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " :: Q::lockForRead :: done >>\n");
+   }
+}
+
+// QReadWriteLock::lockForWrite()
+// _ZN14QReadWriteLock12lockForWriteEv == QReadWriteLock::lockForWrite()
+QT4_FUNC(void, ZuZZN14QReadWriteLock12lockForWriteEv, 
+               // _ZN14QReadWriteLock12lockForWriteEv
+               void* self)
+{
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QReadWriteLock::lockForWrite %p", self);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
+                void*,self, long,1/*isW*/);
+
+   CALL_FN_v_W(fn, self);
+
+   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
+                void*,self, long,1/*isW*/);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " :: Q::lockForWrite :: done >>\n");
+   }
+}
+
+// QReadWriteLock::unlock()
+// _ZN14QReadWriteLock6unlockEv == QReadWriteLock::unlock()
+QT4_FUNC(void, ZuZZN14QReadWriteLock6unlockEv,
+               // _ZN14QReadWriteLock6unlockEv
+               void* self)
+{
+   OrigFn fn;
+   VALGRIND_GET_ORIG_FN(fn);
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, "<< QReadWriteLock::unlock %p", self);
+      fflush(stderr);
+   }
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
+               void*,self);
+
+   CALL_FN_v_W(fn, self);
+
+   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
+               void*,self);
+
+   if (TRACE_QT4_FNS) {
+      fprintf(stderr, " :: Q::unlock :: done >>\n");
+   }
+}
+
+
+/*--------------------------------------------------------------------*/
+/*--- end                                          tc_intercepts.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
new file mode 100644
index 0000000..0a97571
--- /dev/null
+++ b/helgrind/hg_main.c
@@ -0,0 +1,8782 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Helgrind: a Valgrind tool for detecting errors               ---*/
+/*--- in threaded programs.                              hg_main.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 OpenWorks LLP
+      info@open-works.co.uk
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+
+   Neither the names of the U.S. Department of Energy nor the
+   University of California nor the names of its contributors may be
+   used to endorse or promote products derived from this software
+   without prior written permission.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_aspacemgr.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+#include "pub_tool_libcprint.h"
+#include "pub_tool_mallocfree.h"
+#include "pub_tool_threadstate.h"
+#include "pub_tool_tooliface.h"
+#include "pub_tool_hashtable.h"
+#include "pub_tool_replacemalloc.h"
+#include "pub_tool_machine.h"
+#include "pub_tool_options.h"
+#include "pub_tool_xarray.h"
+#include "pub_tool_stacktrace.h"
+
+#include "helgrind.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+#include "hg_wordset.h"
+
+/*----------------------------------------------------------------*/
+/*---                                                          ---*/
+/*----------------------------------------------------------------*/
+
+/* Note there are a whole bunch of ugly double casts of the form
+   (Word*)(void*)&p.  These placate gcc at -O2.  The obvious form
+   (Word*)&p causes gcc to complain that 'dereferencing a type-punned
+   pointer ill break strict-aliasing rules'.  It stops complaining
+   when the intermediate void* type is inserted.  Is this a reasonable
+   "fix"?  I don't know. */
+
+// FIXME what is supposed to happen to locks in memory which
+// is relocated as a result of client realloc?
+
+// FIXME some kind of ownership recycling problem in
+// init_thread_specific_state() for programs which use the same thread
+// slot more than once?
+
+// FIXME put referencing ThreadId into Thread and get
+// rid of the slow reverse mapping function.
+
+// FIXME accesses to NoAccess areas: change state to Excl?
+
+// FIXME report errors for accesses of NoAccess memory?
+
+// FIXME pth_cond_wait/timedwait wrappers.  Even if these fail,
+// the thread still holds the lock.
+
+/* ------------ Debug/trace options ------------ */
+
+// this is:
+// shadow_mem_make_NoAccess: 29156 SMs, 1728 scanned
+// happens_before_wrk: 1000
+// ev__post_thread_join: 3360 SMs, 29 scanned, 252 re-Excls
+#define SHOW_EXPENSIVE_STUFF 0
+
+// 0 for silent, 1 for some stuff, 2 for lots of stuff
+#define SHOW_EVENTS 0
+
+// Flags for controlling for which events sanity checking is done
+#define SCE_THREADS  (1<<0)  // Sanity check at thread create/join
+#define SCE_LOCKS    (1<<1)  // Sanity check at lock events
+#define SCE_BIGRANGE (1<<2)  // Sanity check at big mem range events
+#define SCE_ACCESS   (1<<3)  // Sanity check at mem accesses
+#define SCE_LAOG     (1<<4)  // Sanity check at significant LAOG events
+
+#define SCE_BIGRANGE_T 256  // big mem range minimum size
+
+
+/* For the shadow mem cache stuff we may want more intrusive
+   checks.  Unfortunately there's no almost-zero-cost way to make them
+   selectable at run time.  Hence set the #if 0 to #if 1 and
+   rebuild if you want them. */
+#if 0
+#  define SCE_CACHELINE 1  /* do sanity-check CacheLine stuff */
+#  define inline __attribute__((noinline))
+   /* probably want to ditch -fomit-frame-pointer too */
+#else
+#  define SCE_CACHELINE 0   /* don't sanity-check CacheLine stuff */
+#endif
+
+static void all__sanity_check ( Char* who ); /* fwds */
+
+#define HG_CLI__MALLOC_REDZONE_SZB 16 /* let's say */
+
+// 0 for none, 1 for dump at end of run
+#define SHOW_DATA_STRUCTURES 0
+
+
+/* ------------ Command line options ------------ */
+
+// 0 = no segments at all
+// 1 = segments at thread create/join
+// 2 = as 1 + segments at condition variable signal/broadcast/wait too
+static Int clo_happens_before = 2;  /* default setting */
+
+/* Generate .vcg output of the happens-before graph?
+   0: no  1: yes, without VTSs  2: yes, with VTSs */
+static Int clo_gen_vcg = 0;
+
+/* When comparing race errors for equality, should the race address be
+   taken into account?  For users, no, but for verification purposes
+   (regtesting) this is sometimes important. */
+static Bool clo_cmp_race_err_addrs = False;
+
+/* Tracing memory accesses, so we can see what's going on.
+   clo_trace_addr is the address to monitor.  clo_trace_level = 0 for
+   no tracing, 1 for summary, 2 for detailed. */
+static Addr clo_trace_addr  = 0;
+static Int  clo_trace_level = 0;
+
+/* Sanity check level.  This is an or-ing of
+   SCE_{THREADS,LOCKS,BIGRANGE,ACCESS,LAOG}. */
+static Int clo_sanity_flags = 0;
+
+/* This has to do with printing error messages.  See comments on
+   announce_threadset() and summarise_threadset().  Perhaps it
+   should be a command line option. */
+#define N_THREADS_TO_ANNOUNCE 5
+
+
+/* ------------ Misc comments ------------ */
+
+// FIXME: don't hardwire initial entries for root thread.
+// Instead, let the pre_thread_ll_create handler do this.
+
+// FIXME: when a SecMap is completely set via and address range
+// setting operation to a non-ShR/M state, clear its .mbHasShared 
+// bit
+
+/* FIXME: figure out what the real rules are for Excl->ShR/M
+   transitions w.r.t locksets.
+
+   Muelenfeld thesis Sec 2.2.1 p 8/9 says that
+
+     When another thread accesses the memory location, the lock-set
+     is initialized with all active locks and the algorithm reports
+     the next access that results in an empty lock-set.
+
+   What does "all active locks" mean?  All locks held by the accessing
+   thread, or all locks held by the system as a whole?
+
+   However: Muelenfeld's enhanced Helgrind (eraser_mem_read_word)
+   seems to use simply the set of locks held by the thread causing the
+   transition into a shared state at the time of the transition:
+
+     *sword = SW(Vge_Shar, packLockSet(thread_locks_rd[tid]));
+
+   Original Eraser paper also says "all active locks".
+*/
+
+// Major stuff to fix:
+// - reader-writer locks
+
+/* Thread async exit:
+   
+   remove the map_threads entry
+   leave the Thread object in place
+   complain if holds any locks
+   
+   unlike with Join, do not change any memory states
+
+   I _think_ this is correctly handled now.
+*/
+
+/*----------------------------------------------------------------*/
+/*--- Some very basic stuff                                    ---*/
+/*----------------------------------------------------------------*/
+
+static void* hg_zalloc ( SizeT n ) {
+   void* p;
+   tl_assert(n > 0);
+   p = VG_(malloc)( n );
+   tl_assert(p);
+   VG_(memset)(p, 0, n);
+   return p;
+}
+static void hg_free ( void* p ) {
+   tl_assert(p);
+   VG_(free)(p);
+}
+
+/* Round a up to the next multiple of N.  N must be a power of 2 */
+#define ROUNDUP(a, N)   ((a + N - 1) & ~(N-1))
+/* Round a down to the next multiple of N.  N must be a power of 2 */
+#define ROUNDDN(a, N)   ((a) & ~(N-1))
+
+#ifdef HAVE_BUILTIN_EXPECT
+#define LIKELY(cond)   __builtin_expect((cond),1)
+#define UNLIKELY(cond) __builtin_expect((cond),0)
+#else
+#define LIKELY(cond)   (cond)
+#define UNLIKELY(cond) (cond)
+#endif
+
+
+/*----------------------------------------------------------------*/
+/*--- Primary data definitions                                 ---*/
+/*----------------------------------------------------------------*/
+
+/* These are handles for thread segments.  CONSTRAINTS: Must be small
+   ints numbered from zero, since 30-bit versions of them must are
+   used to represent Exclusive shadow states.  Are used as keys in
+   WordFMs so must be castable to Words at the appropriate points. */
+typedef  UInt  SegmentID;
+
+
+/* These are handles for Word sets.  CONSTRAINTS: must be (very) small
+   ints numbered from zero, since < 30-bit versions of them are used to
+   encode thread-sets and lock-sets in 32-bit shadow words. */
+typedef  WordSet  WordSetID;
+
+
+/* Stores information about a thread.  Addresses of these also serve
+   as unique thread identifiers and so are never freed, so they should
+   be as small as possible. */
+typedef
+   struct _Thread {
+      /* ADMIN */
+      struct _Thread* admin;
+      UInt            magic;
+      /* USEFUL */
+      WordSetID locksetA; /* WordSet of Lock* currently held by thread */
+      WordSetID locksetW; /* subset of locksetA held in w-mode */
+      SegmentID csegid;  /* current thread segment for thread */
+      /* EXPOSITION */
+      /* Place where parent was when this thread was created. */
+      ExeContext* created_at;
+      Bool        announced;
+      /* Index for generating references in error messages. */
+      Int         errmsg_index;
+   }
+   Thread;
+
+
+/* Stores information about a lock's current state.  These are
+   allocated and later freed (when the containing memory becomes
+   NoAccess).  This gives a problem for the XError type, which
+   contains Lock*s.  Solution is to copy any Lock which is to be
+   incorporated into an XErrors, so as to make it independent from the
+   'normal' collection of Locks, which can come and go.  When the lock
+   is copied, its .magic is changed from LockN_Magic to
+   LockP_Magic. */
+
+/* Lock kinds. */
+typedef
+   enum {
+      LK_mbRec=1001, /* normal mutex, possibly recursive */
+      LK_nonRec,     /* normal mutex, definitely non recursive */
+      LK_rdwr        /* reader-writer lock */
+   }
+   LockKind;
+
+typedef
+   struct _Lock {
+      /* ADMIN */
+      struct _Lock* admin;
+      ULong         unique; /* used for persistence-hashing */
+      UInt          magic;  /* LockN_MAGIC or LockP_MAGIC */
+      /* EXPOSITION */
+      /* Place where lock first came to the attention of Helgrind. */
+      ExeContext*   appeared_at;
+      /* Place where the lock most recently made an unlocked->locked
+         transition. */
+      ExeContext*   acquired_at;
+      /* USEFUL-STATIC */
+      Addr          guestaddr; /* Guest address of lock */
+      LockKind      kind;      /* what kind of lock this is */
+      /* USEFUL-DYNAMIC */
+      Bool          heldW; 
+      WordBag*      heldBy; /* bag of threads that hold this lock */
+      /* .heldBy is NULL: lock is unheld, and .heldW is meaningless
+                          but arbitrarily set to False
+         .heldBy is non-NULL:
+            .heldW is True:  lock is w-held by threads in heldBy
+            .heldW is False: lock is r-held by threads in heldBy
+            Either way, heldBy may not validly be an empty Bag.
+
+         for LK_nonRec, r-holdings are not allowed, and w-holdings may
+         only have sizeTotal(heldBy) == 1
+
+         for LK_mbRec, r-holdings are not allowed, and w-holdings may
+         only have sizeUnique(heldBy) == 1
+
+         for LK_rdwr, w-holdings may only have sizeTotal(heldBy) == 1 */
+   }
+   Lock;
+
+
+/* Stores information about thread segments.  .prev can be NULL only
+   when this is the first segment for the thread.  .other is NULL
+   unless this segment depends on a message (create, join, signal)
+   from some other thread.  Segments are never freed (!) */
+typedef
+   struct _Segment {
+      /* ADMIN */
+      struct _Segment* admin;
+      UInt             magic;
+      /* USEFUL */
+      UInt             dfsver; /* Version # for depth-first searches */
+      Thread*          thr;    /* The thread that I am part of */
+      struct _Segment* prev;   /* The previous segment in this thread */
+      struct _Segment* other;  /* Possibly a segment from some other 
+                                  thread, which happened-before me */
+      XArray*          vts;    /* XArray of ScalarTS */
+      /* DEBUGGING ONLY: what does 'other' arise from?  
+         c=thread creation, j=join, s=cvsignal, S=semaphore */
+      Char other_hint;
+   }
+   Segment;
+
+
+/* ------ CacheLine ------ */
+
+#define N_LINE_BITS      5 /* must be >= 3 */
+#define N_LINE_ARANGE    (1 << N_LINE_BITS)
+#define N_LINE_TREES     (N_LINE_ARANGE >> 3)
+
+typedef
+   struct {
+      UShort descrs[N_LINE_TREES];
+      UInt   svals[N_LINE_ARANGE]; // == N_LINE_TREES * 8
+   }
+   CacheLine;
+
+#define TREE_DESCR_16_0 (1<<0)
+#define TREE_DESCR_32_0 (1<<1)
+#define TREE_DESCR_16_1 (1<<2)
+#define TREE_DESCR_64   (1<<3)
+#define TREE_DESCR_16_2 (1<<4)
+#define TREE_DESCR_32_1 (1<<5)
+#define TREE_DESCR_16_3 (1<<6)
+#define TREE_DESCR_8_0  (1<<7)
+#define TREE_DESCR_8_1  (1<<8)
+#define TREE_DESCR_8_2  (1<<9)
+#define TREE_DESCR_8_3  (1<<10)
+#define TREE_DESCR_8_4  (1<<11)
+#define TREE_DESCR_8_5  (1<<12)
+#define TREE_DESCR_8_6  (1<<13)
+#define TREE_DESCR_8_7  (1<<14)
+#define TREE_DESCR_DTY  (1<<15)
+
+typedef
+   struct {
+      UInt  dict[4]; /* can represent up to 4 diff values in the line */
+      UChar ix2s[N_LINE_ARANGE/4]; /* array of N_LINE_ARANGE 2-bit
+                                      dict indexes */
+      /* if dict[0] == 0 then dict[1] is the index of the CacheLineF
+         to use */
+   }
+   CacheLineZ; /* compressed rep for a cache line */
+
+typedef
+   struct {
+      Bool inUse;
+      UInt w32s[N_LINE_ARANGE];
+   }
+   CacheLineF; /* full rep for a cache line */
+
+
+/* Shadow memory.
+   Primary map is a WordFM Addr SecMap*.  
+   SecMaps cover some page-size-ish section of address space and hold
+     a compressed representation.
+   CacheLine-sized chunks of SecMaps are copied into a Cache, being
+   decompressed when moved into the cache and recompressed on the
+   way out.  Because of this, the cache must operate as a writeback
+   cache, not a writethrough one.
+*/
+/* See comments below on shadow_mem_make_NoAccess re performance
+   effects of N_SECMAP_BITS settings.  On a 2.4GHz Core2,
+   starting/quitting OOo (32-bit), I have these rough numbers:
+      N_SECMAP_BITS = 11    2m23
+      N_SECMAP_BITS = 12    1m58
+      N_SECMAP_BITS = 13    1m53
+
+   Each SecMap must hold a power-of-2 number of CacheLines.  Hence
+   N_SECMAP_BITS must >= N_LINE_BITS.
+*/
+#define N_SECMAP_BITS   13
+#define N_SECMAP_ARANGE (1 << N_SECMAP_BITS)
+
+// # CacheLines held by a SecMap
+#define N_SECMAP_ZLINES (N_SECMAP_ARANGE / N_LINE_ARANGE)
+typedef
+   struct {
+      UInt magic;
+      Bool mbHasLocks;  /* hint: any locks in range?  safe: True */
+      Bool mbHasShared; /* hint: any ShM/ShR states in range?  safe: True */
+      CacheLineZ  linesZ[N_SECMAP_ZLINES];
+      CacheLineF* linesF;
+      Int         linesF_size;
+   }
+   SecMap;
+
+typedef
+   struct {
+      Int line_no; /* which Z-line are we in? */
+      Int word_no; /* inside the line, which word is current? */
+   }
+   SecMapIter;
+
+static void initSecMapIter ( SecMapIter* itr ) {
+   itr->line_no = 0;
+   itr->word_no = 0;
+}
+
+/* Get the current val, and move to the next position.  This is called
+   a huge amount in some programs (eg OpenOffice).  Hence the
+   'inline'. */
+static UWord stats__secmap_iterator_steppings; /* fwds */
+
+inline
+static Bool stepSecMapIter ( /*OUT*/UInt** pVal, 
+                             /*MOD*/SecMapIter* itr, SecMap* sm )
+{
+   CacheLineZ* lineZ = NULL;
+   CacheLineF* lineF = NULL;
+   /* Either it points to a valid place, or to (-1,-1) */
+   stats__secmap_iterator_steppings++;
+   if (UNLIKELY(itr->line_no == -1)) {
+      tl_assert(itr->word_no == -1);
+      return False;
+   }
+   /* so now it must be a valid place in the SecMap. */
+   if (0) VG_(printf)("%p %d %d\n", sm, (Int)itr->line_no, (Int)itr->word_no);
+   tl_assert(itr->line_no >= 0 && itr->line_no < N_SECMAP_ZLINES);
+   lineZ = &sm->linesZ[itr->line_no];
+   if (UNLIKELY(lineZ->dict[0] == 0)) {
+      tl_assert(sm->linesF);
+      tl_assert(sm->linesF_size > 0);
+      tl_assert(lineZ->dict[1] >= 0);
+      tl_assert(lineZ->dict[1] < sm->linesF_size);
+      lineF = &sm->linesF[ lineZ->dict[1] ];
+      tl_assert(lineF->inUse);
+      tl_assert(itr->word_no >= 0 && itr->word_no < N_LINE_ARANGE);
+      *pVal = &lineF->w32s[itr->word_no];
+      itr->word_no++;
+      if (itr->word_no == N_LINE_ARANGE)
+         itr->word_no = 0;
+   } else {
+      tl_assert(itr->word_no >= 0 && itr->word_no <= 3);
+      tl_assert(lineZ->dict[itr->word_no] != 0);
+      *pVal = &lineZ->dict[itr->word_no];
+      itr->word_no++;
+      if (itr->word_no == 4 || lineZ->dict[itr->word_no] == 0)
+         itr->word_no = 0;
+   }
+
+   if (itr->word_no == 0) {
+      itr->line_no++;
+      if (itr->line_no == N_SECMAP_ZLINES) {
+         itr->line_no = -1;
+         itr->word_no = -1;
+      }
+   }
+
+   return True;
+}
+
+/* ------ Cache ------ */
+
+#define N_WAY_BITS 16
+#define N_WAY_NENT (1 << N_WAY_BITS)
+
+/* Each tag is the address of the associated CacheLine, rounded down
+   to a CacheLine address boundary.  A CacheLine size must be a power
+   of 2 and must be 8 or more.  Hence an easy way to initialise the
+   cache so it is empty is to set all the tag values to any value % 8
+   != 0, eg 1.  This means all queries in the cache initially miss.
+   It does however require us to detect and not writeback, any line
+   with a bogus tag. */
+typedef
+   struct {
+      CacheLine lyns0[N_WAY_NENT];
+      Addr      tags0[N_WAY_NENT];
+   }
+   Cache;
+
+
+/* --------- Primary data structures --------- */
+
+/* Admin linked list of Threads */
+static Thread* admin_threads = NULL;
+
+/* Admin linked list of Locks */
+static Lock* admin_locks = NULL;
+
+/* Admin linked list of Segments */
+static Segment* admin_segments = NULL;
+
+/* Shadow memory primary map */
+static WordFM* map_shmem = NULL; /* WordFM Addr SecMap* */
+static Cache   cache_shmem;
+
+/* Mapping table for core ThreadIds to Thread* */
+static Thread** map_threads = NULL; /* Array[VG_N_THREADS] of Thread* */
+
+/* Mapping table for thread segments IDs to Segment* */
+static WordFM* map_segments = NULL; /* WordFM SegmentID Segment* */
+
+/* Mapping table for lock guest addresses to Lock* */
+static WordFM* map_locks = NULL; /* WordFM LockAddr Lock* */
+
+/* The word-set universes for thread sets and lock sets. */
+static WordSetU* univ_tsets = NULL; /* sets of Thread* */
+static WordSetU* univ_lsets = NULL; /* sets of Lock* */
+static WordSetU* univ_laog  = NULL; /* sets of Lock*, for LAOG */
+
+/* never changed; we only care about its address.  Is treated as if it
+   was a standard userspace lock.  Also we have a Lock* describing it
+   so it can participate in lock sets in the usual way. */
+static Int   __bus_lock = 0;
+static Lock* __bus_lock_Lock = NULL;
+
+
+/*----------------------------------------------------------------*/
+/*--- Simple helpers for the data structures                   ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__lockN_acquires = 0;
+static UWord stats__lockN_releases = 0;
+
+static ThreadId map_threads_maybe_reverse_lookup_SLOW ( Thread* ); /*fwds*/
+
+#define Thread_MAGIC   0x504fc5e5
+#define LockN_MAGIC    0x6545b557 /* normal nonpersistent locks */
+#define LockP_MAGIC    0x755b5456 /* persistent (copied) locks */
+#define Segment_MAGIC  0x49e94d81
+#define SecMap_MAGIC   0x571e58cb
+
+static UWord stats__mk_Segment = 0;
+
+/* --------- Constructors --------- */
+
+static inline Bool is_sane_LockN ( Lock* lock ); /* fwds */
+
+static Thread* mk_Thread ( SegmentID csegid ) {
+   static Int indx      = 1;
+   Thread* thread       = hg_zalloc( sizeof(Lock) );
+   thread->locksetA     = HG_(emptyWS)( univ_lsets );
+   thread->locksetW     = HG_(emptyWS)( univ_lsets );
+   thread->csegid       = csegid;
+   thread->magic        = Thread_MAGIC;
+   thread->created_at   = NULL;
+   thread->announced    = False;
+   thread->errmsg_index = indx++;
+   thread->admin        = admin_threads;
+   admin_threads        = thread;
+   return thread;
+}
+// Make a new lock which is unlocked (hence ownerless)
+static Lock* mk_LockN ( LockKind kind, Addr guestaddr ) {
+   static ULong unique = 0;
+   Lock* lock             = hg_zalloc( sizeof(Lock) );
+   lock->admin            = admin_locks;
+   lock->unique           = unique++;
+   lock->magic            = LockN_MAGIC;
+   lock->appeared_at      = NULL;
+   lock->acquired_at      = NULL;
+   lock->guestaddr        = guestaddr;
+   lock->kind             = kind;
+   lock->heldW            = False;
+   lock->heldBy           = NULL;
+   tl_assert(is_sane_LockN(lock));
+   admin_locks            = lock;
+   return lock;
+}
+static Segment* mk_Segment ( Thread* thr, Segment* prev, Segment* other ) {
+   Segment* seg    = hg_zalloc( sizeof(Segment) );
+   seg->dfsver     = 0;
+   seg->thr        = thr;
+   seg->prev       = prev;
+   seg->other      = other;
+   seg->vts        = NULL;
+   seg->other_hint = ' ';
+   seg->magic      = Segment_MAGIC;
+   seg->admin      = admin_segments;
+   admin_segments = seg;
+   stats__mk_Segment++;
+   return seg;
+}
+
+static inline Bool is_sane_Segment ( Segment* seg ) {
+   return seg != NULL && seg->magic == Segment_MAGIC;
+}
+static inline Bool is_sane_Thread ( Thread* thr ) {
+   return thr != NULL && thr->magic == Thread_MAGIC;
+}
+
+static Bool is_sane_Bag_of_Threads ( WordBag* bag )
+{
+   Thread* thr;
+   Word    count;
+   HG_(initIterBag)( bag );
+   while (HG_(nextIterBag)( bag, (Word*)(void*)&thr, &count )) {
+      if (count < 1) return False;
+      if (!is_sane_Thread(thr)) return False;
+   }
+   HG_(doneIterBag)( bag );
+   return True;
+}
+static Bool is_sane_Lock_BASE ( Lock* lock )
+{
+   if (lock == NULL
+       || (lock->magic != LockN_MAGIC && lock->magic != LockP_MAGIC))
+      return False;
+   switch (lock->kind) { 
+      case LK_mbRec: case LK_nonRec: case LK_rdwr: break; 
+      default: return False; 
+   }
+   if (lock->heldBy == NULL) {
+      if (lock->acquired_at != NULL) return False;
+      /* Unheld.  We arbitrarily require heldW to be False. */
+      return !lock->heldW;
+   } else {
+      if (lock->acquired_at == NULL) return False;
+   }
+
+   /* If heldBy is non-NULL, we require it to contain at least one
+      thread. */
+   if (HG_(isEmptyBag)(lock->heldBy))
+      return False;
+
+   /* Lock is either r- or w-held. */
+   if (!is_sane_Bag_of_Threads(lock->heldBy)) 
+      return False;
+   if (lock->heldW) {
+      /* Held in write-mode */
+      if ((lock->kind == LK_nonRec || lock->kind == LK_rdwr)
+          && !HG_(isSingletonTotalBag)(lock->heldBy))
+         return False;
+   } else {
+      /* Held in read-mode */
+      if (lock->kind != LK_rdwr) return False;
+   }
+   return True;
+}
+static inline Bool is_sane_LockP ( Lock* lock ) {
+   return lock != NULL 
+          && lock->magic == LockP_MAGIC
+          && is_sane_Lock_BASE(lock);
+}
+static inline Bool is_sane_LockN ( Lock* lock ) {
+   return lock != NULL 
+          && lock->magic == LockN_MAGIC
+          && is_sane_Lock_BASE(lock);
+}
+static inline Bool is_sane_LockNorP ( Lock* lock ) {
+   return is_sane_Lock_BASE(lock);
+}
+
+/* Release storage for a Lock.  Also release storage in .heldBy, if
+   any. */
+static void del_LockN ( Lock* lk ) 
+{
+   tl_assert(is_sane_LockN(lk));
+   if (lk->heldBy)
+      HG_(deleteBag)( lk->heldBy );
+   VG_(memset)(lk, 0xAA, sizeof(*lk));
+   hg_free(lk);
+}
+
+/* Update 'lk' to reflect that 'thr' now has a write-acquisition of
+   it.  This is done strictly: only combinations resulting from
+   correct program and libpthread behaviour are allowed. */
+static void lockN_acquire_writer ( Lock* lk, Thread* thr ) 
+{
+   tl_assert(is_sane_LockN(lk));
+   tl_assert(is_sane_Thread(thr));
+
+   stats__lockN_acquires++;
+
+   /* EXPOSITION only */
+   /* We need to keep recording snapshots of where the lock was
+      acquired, so as to produce better lock-order error messages. */
+   if (lk->acquired_at == NULL) {
+      ThreadId tid;
+      tl_assert(lk->heldBy == NULL);
+      tid = map_threads_maybe_reverse_lookup_SLOW(thr);
+      lk->acquired_at
+         = VG_(record_ExeContext(tid, 0/*first_ip_delta*/));
+   } else {
+      tl_assert(lk->heldBy != NULL);
+   }
+   /* end EXPOSITION only */
+
+   switch (lk->kind) {
+      case LK_nonRec:
+      case_LK_nonRec:
+         tl_assert(lk->heldBy == NULL); /* can't w-lock recursively */
+         tl_assert(!lk->heldW);
+         lk->heldW  = True;
+         lk->heldBy = HG_(newBag)( hg_zalloc, hg_free );
+         HG_(addToBag)( lk->heldBy, (Word)thr );
+         break;
+      case LK_mbRec:
+         if (lk->heldBy == NULL)
+            goto case_LK_nonRec;
+         /* 2nd and subsequent locking of a lock by its owner */
+         tl_assert(lk->heldW);
+         /* assert: lk is only held by one thread .. */
+         tl_assert(HG_(sizeUniqueBag(lk->heldBy)) == 1);
+         /* assert: .. and that thread is 'thr'. */
+         tl_assert(HG_(elemBag)(lk->heldBy, (Word)thr)
+                   == HG_(sizeTotalBag)(lk->heldBy));
+         HG_(addToBag)(lk->heldBy, (Word)thr);
+         break;
+      case LK_rdwr:
+         tl_assert(lk->heldBy == NULL && !lk->heldW); /* must be unheld */
+         goto case_LK_nonRec;
+      default: 
+         tl_assert(0);
+  }
+  tl_assert(is_sane_LockN(lk));
+}
+
+static void lockN_acquire_reader ( Lock* lk, Thread* thr )
+{
+   tl_assert(is_sane_LockN(lk));
+   tl_assert(is_sane_Thread(thr));
+   /* can only add reader to a reader-writer lock. */
+   tl_assert(lk->kind == LK_rdwr);
+   /* lk must be free or already r-held. */
+   tl_assert(lk->heldBy == NULL 
+             || (lk->heldBy != NULL && !lk->heldW));
+
+   stats__lockN_acquires++;
+
+   /* EXPOSITION only */
+   /* We need to keep recording snapshots of where the lock was
+      acquired, so as to produce better lock-order error messages. */
+   if (lk->acquired_at == NULL) {
+      ThreadId tid;
+      tl_assert(lk->heldBy == NULL);
+      tid = map_threads_maybe_reverse_lookup_SLOW(thr);
+      lk->acquired_at
+         = VG_(record_ExeContext(tid, 0/*first_ip_delta*/));
+   } else {
+      tl_assert(lk->heldBy != NULL);
+   }
+   /* end EXPOSITION only */
+
+   if (lk->heldBy) {
+      HG_(addToBag)(lk->heldBy, (Word)thr);
+   } else {
+      lk->heldW  = False;
+      lk->heldBy = HG_(newBag)( hg_zalloc, hg_free );
+      HG_(addToBag)( lk->heldBy, (Word)thr );
+   }
+   tl_assert(!lk->heldW);
+   tl_assert(is_sane_LockN(lk));
+}
+
+/* Update 'lk' to reflect a release of it by 'thr'.  This is done
+   strictly: only combinations resulting from correct program and
+   libpthread behaviour are allowed. */
+
+static void lockN_release ( Lock* lk, Thread* thr )
+{
+   Bool b;
+   tl_assert(is_sane_LockN(lk));
+   tl_assert(is_sane_Thread(thr));
+   /* lock must be held by someone */
+   tl_assert(lk->heldBy);
+   stats__lockN_releases++;
+   /* Remove it from the holder set */
+   b = HG_(delFromBag)(lk->heldBy, (Word)thr);
+   /* thr must actually have been a holder of lk */
+   tl_assert(b);
+   /* normalise */
+   tl_assert(lk->acquired_at);
+   if (HG_(isEmptyBag)(lk->heldBy)) {
+      HG_(deleteBag)(lk->heldBy);
+      lk->heldBy      = NULL;
+      lk->heldW       = False;
+      lk->acquired_at = NULL;
+   }
+   tl_assert(is_sane_LockN(lk));
+}
+
+static void remove_Lock_from_locksets_of_all_owning_Threads( Lock* lk )
+{
+   Thread* thr;
+   if (!lk->heldBy) {
+      tl_assert(!lk->heldW);
+      return;
+   }
+   /* for each thread that holds this lock do ... */
+   HG_(initIterBag)( lk->heldBy );
+   while (HG_(nextIterBag)( lk->heldBy, (Word*)(void*)&thr, NULL )) {
+      tl_assert(is_sane_Thread(thr));
+      tl_assert(HG_(elemWS)( univ_lsets,
+                             thr->locksetA, (Word)lk ));
+      thr->locksetA
+         = HG_(delFromWS)( univ_lsets, thr->locksetA, (Word)lk );
+
+      if (lk->heldW) {
+         tl_assert(HG_(elemWS)( univ_lsets,
+                                thr->locksetW, (Word)lk ));
+         thr->locksetW
+            = HG_(delFromWS)( univ_lsets, thr->locksetW, (Word)lk );
+      }
+   }
+   HG_(doneIterBag)( lk->heldBy );
+}
+
+/* --------- xxxID functions --------- */
+
+/* Proposal (for debugging sanity):
+
+   SegmentIDs from 0x1000000 .. 0x1FFFFFF (16777216)
+
+   All other xxxID handles are invalid.
+*/
+static inline Bool is_sane_SegmentID ( SegmentID tseg ) {
+   return tseg >= 0x1000000 && tseg <= 0x1FFFFFF;
+}
+static inline Bool is_sane_ThreadId ( ThreadId coretid ) {
+   return coretid >= 0 && coretid < VG_N_THREADS;
+}
+static SegmentID alloc_SegmentID ( void ) {
+   static SegmentID next = 0x1000000;
+   tl_assert(is_sane_SegmentID(next));
+   return next++;
+}
+
+/* --------- Shadow memory --------- */
+
+static inline Bool is_valid_scache_tag ( Addr tag ) {
+   /* a valid tag should be naturally aligned to the start of
+      a CacheLine. */
+   return 0 == (tag & (N_LINE_ARANGE - 1));
+}
+
+static inline Bool is_sane_SecMap ( SecMap* sm ) {
+   return sm != NULL && sm->magic == SecMap_MAGIC;
+}
+
+/* Shadow value encodings:
+
+   11 WordSetID:TSID_BITS WordSetID:LSID_BITS  ShM  thread-set lock-set
+   10 WordSetID:TSID_BITS WordSetID:LSID_BITS  ShR  thread-set lock-set
+   01 TSegmentID:30                            Excl thread-segment
+   00 0--(20)--0 10 0000 0000                  New
+   00 0--(20)--0 01 0000 0000                  NoAccess
+   00 0--(20)--0 00 0000 0000                  Invalid
+
+   TSID_BITS + LSID_BITS must equal 30.
+   The elements in thread sets are Thread*, casted to Word.
+   The elements in lock sets are Lock*, casted to Word.
+*/
+
+#define N_LSID_BITS  17
+#define N_LSID_MASK  ((1 << (N_LSID_BITS)) - 1)
+#define N_LSID_SHIFT 0
+
+#define N_TSID_BITS  (30 - (N_LSID_BITS))
+#define N_TSID_MASK  ((1 << (N_TSID_BITS)) - 1)
+#define N_TSID_SHIFT (N_LSID_BITS)
+
+static inline Bool is_sane_WordSetID_LSet ( WordSetID wset ) {
+   return wset >= 0 && wset <= N_LSID_MASK;
+}
+static inline Bool is_sane_WordSetID_TSet ( WordSetID wset ) {
+   return wset >= 0 && wset <= N_TSID_MASK;
+}
+
+
+__attribute__((noinline))
+__attribute__((noreturn))
+static void mk_SHVAL_fail ( WordSetID tset, WordSetID lset, HChar* who ) {
+   VG_(printf)("\n");
+   VG_(printf)("Helgrind: Fatal internal error -- cannot continue.\n");
+   VG_(printf)("Helgrind: mk_SHVAL_ShR(tset=%d,lset=%d): FAILED\n",
+               (Int)tset, (Int)lset);
+   VG_(printf)("Helgrind: max allowed tset=%d, lset=%d\n",
+               (Int)N_TSID_MASK, (Int)N_LSID_MASK);
+   VG_(printf)("Helgrind: program has too many thread "
+              "sets or lock sets to track.\n");
+   tl_assert(0);
+}
+
+static inline UInt mk_SHVAL_ShM ( WordSetID tset, WordSetID lset ) {
+   if (LIKELY(is_sane_WordSetID_TSet(tset) 
+              && is_sane_WordSetID_LSet(lset))) {
+      return (UInt)( (3<<30) | (tset << N_TSID_SHIFT) 
+                             | (lset << N_LSID_SHIFT));
+   } else {
+      mk_SHVAL_fail(tset, lset, "mk_SHVAL_ShM");
+   }
+}
+static inline UInt mk_SHVAL_ShR ( WordSetID tset, WordSetID lset ) {
+   if (LIKELY(is_sane_WordSetID_TSet(tset) 
+              && is_sane_WordSetID_LSet(lset))) {
+      return (UInt)( (2<<30) | (tset << N_TSID_SHIFT) 
+                             | (lset << N_LSID_SHIFT) );
+   } else {
+      mk_SHVAL_fail(tset, lset, "mk_SHVAL_ShR");
+   }
+}
+static inline UInt mk_SHVAL_Excl ( SegmentID tseg ) {
+   tl_assert(is_sane_SegmentID(tseg));
+   return (UInt)( (1<<30) | tseg );
+}
+#define SHVAL_New      ((UInt)(2<<8))
+#define SHVAL_NoAccess ((UInt)(1<<8))
+#define SHVAL_Invalid  ((UInt)(0<<8))
+
+static inline Bool is_SHVAL_ShM ( UInt w32 ) { 
+   return (w32 >> 30) == 3;
+}
+static inline Bool is_SHVAL_ShR ( UInt w32 ) {
+   return (w32 >> 30) == 2;
+}
+static inline Bool is_SHVAL_Sh ( UInt w32 ) {
+   return (w32 >> 31) == 1;
+}
+static inline Bool is_SHVAL_Excl ( UInt w32 ) {
+   return (w32 >> 30) == 1; 
+}
+static inline Bool is_SHVAL_New ( UInt w32 ) {
+   return w32 == SHVAL_New;
+}
+static inline Bool is_SHVAL_NoAccess ( UInt w32 ) { 
+   return w32 == SHVAL_NoAccess;
+}
+static inline Bool is_SHVAL_valid ( UInt w32 ) {
+   return is_SHVAL_Excl(w32) || is_SHVAL_NoAccess(w32)
+          || is_SHVAL_Sh(w32) || is_SHVAL_New(w32);
+}
+
+static inline SegmentID un_SHVAL_Excl ( UInt w32 ) {
+   tl_assert(is_SHVAL_Excl(w32));
+   return w32 & ~(3<<30);
+}
+static inline WordSetID un_SHVAL_ShR_tset ( UInt w32 ) {
+   tl_assert(is_SHVAL_ShR(w32));
+   return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShR_lset ( UInt w32 ) {
+   tl_assert(is_SHVAL_ShR(w32));
+   return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShM_tset ( UInt w32 ) {
+   tl_assert(is_SHVAL_ShM(w32));
+   return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_ShM_lset ( UInt w32 ) {
+   tl_assert(is_SHVAL_ShM(w32));
+   return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+static inline WordSetID un_SHVAL_Sh_tset ( UInt w32 ) {
+   tl_assert(is_SHVAL_Sh(w32));
+   return (w32 >> N_TSID_SHIFT) & N_TSID_MASK;
+}
+static inline WordSetID un_SHVAL_Sh_lset ( UInt w32 ) {
+   tl_assert(is_SHVAL_Sh(w32));
+   return (w32 >> N_LSID_SHIFT) & N_LSID_MASK;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Print out the primary data structures                    ---*/
+/*----------------------------------------------------------------*/
+
+static WordSetID del_BHL ( WordSetID lockset ); /* fwds */
+static 
+void get_ZF_by_index ( /*OUT*/CacheLineZ** zp, /*OUT*/CacheLineF** fp,
+                       SecMap* sm, Int zix ); /* fwds */
+static 
+Segment* map_segments_maybe_lookup ( SegmentID segid ); /* fwds */
+
+#define PP_THREADS      (1<<1)
+#define PP_LOCKS        (1<<2)
+#define PP_SEGMENTS     (1<<3)
+#define PP_SHMEM_SHARED (1<<4)
+#define PP_ALL (PP_THREADS | PP_LOCKS | PP_SEGMENTS | PP_SHMEM_SHARED)
+
+
+static const Int sHOW_ADMIN = 0;
+
+static void space ( Int n )
+{
+   Int  i;
+   Char spaces[128+1];
+   tl_assert(n >= 0 && n < 128);
+   if (n == 0)
+      return;
+   for (i = 0; i < n; i++)
+      spaces[i] = ' ';
+   spaces[i] = 0;
+   tl_assert(i < 128+1);
+   VG_(printf)("%s", spaces);
+}
+
+static void pp_Thread ( Int d, Thread* t )
+{
+   space(d+0); VG_(printf)("Thread %p {\n", t);
+   if (sHOW_ADMIN) {
+   space(d+3); VG_(printf)("admin    %p\n",   t->admin);
+   space(d+3); VG_(printf)("magic    0x%x\n", (UInt)t->magic);
+   }
+   space(d+3); VG_(printf)("locksetA %d\n",   (Int)t->locksetA);
+   space(d+3); VG_(printf)("locksetW %d\n",   (Int)t->locksetW);
+   space(d+3); VG_(printf)("csegid   0x%x\n", (UInt)t->csegid);
+   space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_threads ( Int d )
+{
+   Int     i, n;
+   Thread* t;
+   for (n = 0, t = admin_threads;  t;  n++, t = t->admin) {
+      /* nothing */
+   }
+   space(d); VG_(printf)("admin_threads (%d records) {\n", n);
+   for (i = 0, t = admin_threads;  t;  i++, t = t->admin) {
+      if (0) {
+         space(n); 
+         VG_(printf)("admin_threads record %d of %d:\n", i, n);
+      }
+      pp_Thread(d+3, t);
+   }
+   space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_threads ( Int d )
+{
+   Int i, n;
+   n = 0;
+   space(d); VG_(printf)("map_threads ");
+   n = 0;
+   for (i = 0; i < VG_N_THREADS; i++) {
+      if (map_threads[i] != NULL)
+         n++;
+   }
+   VG_(printf)("(%d entries) {\n", n);
+   for (i = 0; i < VG_N_THREADS; i++) {
+      if (map_threads[i] == NULL)
+         continue;
+      space(d+3);
+      VG_(printf)("coretid %d -> Thread %p\n", i, map_threads[i]);
+   }
+   space(d); VG_(printf)("}\n");
+}
+
+static const HChar* show_LockKind ( LockKind lkk ) {
+   switch (lkk) {
+      case LK_mbRec:  return "mbRec";
+      case LK_nonRec: return "nonRec";
+      case LK_rdwr:   return "rdwr";
+      default:        tl_assert(0);
+   }
+}
+
+static void pp_Lock ( Int d, Lock* lk )
+{
+   space(d+0); VG_(printf)("Lock %p (ga %p) {\n", lk, lk->guestaddr);
+   if (sHOW_ADMIN) {
+      space(d+3); VG_(printf)("admin  %p\n",   lk->admin);
+      space(d+3); VG_(printf)("magic  0x%x\n", (UInt)lk->magic);
+   }
+   space(d+3); VG_(printf)("unique %llu\n", lk->unique);
+   space(d+3); VG_(printf)("kind   %s\n", show_LockKind(lk->kind));
+   space(d+3); VG_(printf)("heldW  %s\n", lk->heldW ? "yes" : "no");
+   space(d+3); VG_(printf)("heldBy %p", lk->heldBy);
+   if (lk->heldBy) {
+      Thread* thr;
+      Word    count;
+      VG_(printf)(" { ");
+      HG_(initIterBag)( lk->heldBy );
+      while (HG_(nextIterBag)( lk->heldBy, (Word*)(void*)&thr, &count ))
+         VG_(printf)("%lu:%p ", count, thr);
+      HG_(doneIterBag)( lk->heldBy );
+      VG_(printf)("}");
+   }
+   VG_(printf)("\n");
+   space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_locks ( Int d )
+{
+   Int   i, n;
+   Lock* lk;
+   for (n = 0, lk = admin_locks;  lk;  n++, lk = lk->admin) {
+      /* nothing */
+   }
+   space(d); VG_(printf)("admin_locks (%d records) {\n", n);
+   for (i = 0, lk = admin_locks;  lk;  i++, lk = lk->admin) {
+      if (0) {
+         space(n); 
+         VG_(printf)("admin_locks record %d of %d:\n", i, n);
+      }
+      pp_Lock(d+3, lk);
+   }
+   space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_locks ( Int d )
+{
+   void* gla;
+   Lock* lk;
+   space(d); VG_(printf)("map_locks (%d entries) {\n",
+                         (Int)HG_(sizeFM)( map_locks ));
+   HG_(initIterFM)( map_locks );
+   while (HG_(nextIterFM)( map_locks, (Word*)(void*)&gla,
+                                      (Word*)(void*)&lk )) {
+      space(d+3);
+      VG_(printf)("guest %p -> Lock %p\n", gla, lk);
+   }
+   HG_(doneIterFM)( map_locks );
+   space(d); VG_(printf)("}\n");
+}
+
+static void pp_Segment ( Int d, Segment* s )
+{
+   space(d+0); VG_(printf)("Segment %p {\n", s);
+   if (sHOW_ADMIN) {
+   space(d+3); VG_(printf)("admin  %p\n",   s->admin);
+   space(d+3); VG_(printf)("magic  0x%x\n", (UInt)s->magic);
+   }
+   space(d+3); VG_(printf)("dfsver    %u\n", s->dfsver);
+   space(d+3); VG_(printf)("thr       %p\n", s->thr);
+   space(d+3); VG_(printf)("prev      %p\n", s->prev);
+   space(d+3); VG_(printf)("other[%c] %p\n", s->other_hint, s->other);
+   space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_admin_segments ( Int d )
+{
+   Int      i, n;
+   Segment* s;
+   for (n = 0, s = admin_segments;  s;  n++, s = s->admin) {
+      /* nothing */
+   }
+   space(d); VG_(printf)("admin_segments (%d records) {\n", n);
+   for (i = 0, s = admin_segments;  s;  i++, s = s->admin) {
+      if (0) {
+         space(n); 
+         VG_(printf)("admin_segments record %d of %d:\n", i, n);
+      }
+      pp_Segment(d+3, s);
+   }
+   space(d); VG_(printf)("}\n", n);
+}
+
+static void pp_map_segments ( Int d )
+{
+   SegmentID segid;
+   Segment*  seg;
+   space(d); VG_(printf)("map_segments (%d entries) {\n", 
+                         (Int)HG_(sizeFM)( map_segments ));
+   HG_(initIterFM)( map_segments );
+   while (HG_(nextIterFM)( map_segments, (Word*)(void*)&segid,
+                                         (Word*)(void*)&seg )) {
+      space(d+3);
+      VG_(printf)("segid 0x%x -> Segment %p\n", (UInt)segid, seg);
+   }
+   HG_(doneIterFM)( map_segments );
+   space(d); VG_(printf)("}\n");
+}
+
+static void show_shadow_w32 ( /*OUT*/Char* buf, Int nBuf, UInt w32 )
+{
+   tl_assert(nBuf-1 >= 99);
+   VG_(memset)(buf, 0, nBuf);
+   if (is_SHVAL_ShM(w32)) {
+      VG_(sprintf)(buf, "ShM(%u,%u)", 
+                   un_SHVAL_ShM_tset(w32), un_SHVAL_ShM_lset(w32));
+   }
+   else
+   if (is_SHVAL_ShR(w32)) {
+      VG_(sprintf)(buf, "ShR(%u,%u)", 
+                   un_SHVAL_ShR_tset(w32), un_SHVAL_ShR_lset(w32));
+   }
+   else
+   if (is_SHVAL_Excl(w32)) {
+      VG_(sprintf)(buf, "Excl(%u)", un_SHVAL_Excl(w32));
+   }
+   else
+   if (is_SHVAL_New(w32)) {
+      VG_(sprintf)(buf, "%s", "New");
+   }
+   else
+   if (is_SHVAL_NoAccess(w32)) {
+      VG_(sprintf)(buf, "%s", "NoAccess");
+   }
+   else {
+      VG_(sprintf)(buf, "Invalid-shadow-word(%u)", w32);
+   }
+}
+
+static
+void show_shadow_w32_for_user ( /*OUT*/Char* buf, Int nBuf, UInt w32 )
+{
+   tl_assert(nBuf-1 >= 99);
+   VG_(memset)(buf, 0, nBuf);
+   if (is_SHVAL_ShM(w32)) {
+      WordSetID tset = un_SHVAL_ShM_tset(w32);
+      WordSetID lset = del_BHL( un_SHVAL_ShM_lset(w32) );
+      VG_(sprintf)(buf, "ShMod(#Tset=%d,#Lset=%d)", 
+                   HG_(cardinalityWS)(univ_tsets, tset),
+                   HG_(cardinalityWS)(univ_lsets, lset));
+   }
+   else
+   if (is_SHVAL_ShR(w32)) {
+      WordSetID tset = un_SHVAL_ShR_tset(w32);
+      WordSetID lset = del_BHL( un_SHVAL_ShR_lset(w32) );
+      VG_(sprintf)(buf, "ShRO(#Tset=%d,#Lset=%d)", 
+                   HG_(cardinalityWS)(univ_tsets, tset),
+                   HG_(cardinalityWS)(univ_lsets, lset));
+   }
+   else
+   if (is_SHVAL_Excl(w32)) {
+      SegmentID segid  = un_SHVAL_Excl(w32);
+      Segment*  mb_seg = map_segments_maybe_lookup(segid);
+      if (mb_seg && mb_seg->thr && is_sane_Thread(mb_seg->thr)) {
+         VG_(sprintf)(buf, "Exclusive(thr#%d)", mb_seg->thr->errmsg_index);
+      } else {
+         VG_(sprintf)(buf, "Exclusive(segid=%u)", un_SHVAL_Excl(w32));
+      }
+   }
+   else
+   if (is_SHVAL_New(w32)) {
+      VG_(sprintf)(buf, "%s", "New");
+   }
+   else
+   if (is_SHVAL_NoAccess(w32)) {
+      VG_(sprintf)(buf, "%s", "NoAccess");
+   }
+   else {
+      VG_(sprintf)(buf, "Invalid-shadow-word(%u)", w32);
+   }
+}
+
+static void pp_SecMap_shared ( Int d, SecMap* sm, Addr ga )
+{
+   Int  i;
+#if 0
+   Addr a;
+   UInt w32;
+   Char buf[100];
+#endif
+   CacheLineZ* lineZ;
+   CacheLineF* lineF;
+   space(d+0); VG_(printf)("SecMap %p (ga %p) {\n", sm, (void*)ga);
+
+   for (i = 0; i < N_SECMAP_ZLINES; i++) {
+      get_ZF_by_index( &lineZ, &lineF, sm, i );
+      space(d+3); VG_(printf)("// pp_SecMap_shared: not implemented\n");
+   }
+
+#if 0
+   for (i = 0; i < N_SECMAP_ARANGE; i++) {
+      w32 = sm->w32s[i];
+      a   = ga + 1 * i;
+      if (! (is_SHVAL_ShM(w32) || is_SHVAL_ShR(w32)))
+         continue;
+      space(d+3); VG_(printf)("%p -> 0x%08x ", (void*)a, w32);
+      show_shadow_w32(buf, sizeof(buf), w32);
+      VG_(printf)("%s\n", buf);
+   }
+#endif
+
+   space(d+0); VG_(printf)("}\n");
+}
+
+static void pp_map_shmem_shared ( Int d )
+{
+   Addr    ga;
+   SecMap* sm;
+   space(d); VG_(printf)("map_shmem_ShR_and_ShM_only {\n");
+   HG_(initIterFM)( map_shmem );
+   while (HG_(nextIterFM)( map_shmem, (Word*)(void*)&ga,
+                                      (Word*)(void*)&sm )) {
+      pp_SecMap_shared( d+3, sm, ga );
+   }
+   HG_(doneIterFM) ( map_shmem );
+   space(d); VG_(printf)("}\n");
+}
+
+static void pp_everything ( Int flags, Char* caller )
+{
+   Int d = 0;
+   VG_(printf)("\n");
+   VG_(printf)("All_Data_Structures (caller = \"%s\") {\n", caller);
+   if (flags & PP_THREADS) {
+      VG_(printf)("\n");
+      pp_admin_threads(d+3);
+      VG_(printf)("\n");
+      pp_map_threads(d+3);
+   }
+   if (flags & PP_LOCKS) {
+      VG_(printf)("\n");
+      pp_admin_locks(d+3);
+      VG_(printf)("\n");
+      pp_map_locks(d+3);
+   }
+   if (flags & PP_SEGMENTS) {
+      VG_(printf)("\n");
+      pp_admin_segments(d+3);
+      VG_(printf)("\n");
+      pp_map_segments(d+3);
+   }
+   if (flags & PP_SHMEM_SHARED) {
+      VG_(printf)("\n");
+      pp_map_shmem_shared( d+3 );
+   }
+
+   VG_(printf)("\n");
+   VG_(printf)("}\n");
+   VG_(printf)("\n");
+}
+
+#undef SHOW_ADMIN
+
+
+/*----------------------------------------------------------------*/
+/*--- Initialise the primary data structures                   ---*/
+/*----------------------------------------------------------------*/
+
+/* fwds */
+static void map_segments_add ( SegmentID segid, Segment* seg );
+static void shmem__invalidate_scache ( void );
+static void hbefore__invalidate_cache ( void );
+static void shmem__set_mbHasLocks ( Addr a, Bool b );
+static Bool shmem__get_mbHasLocks ( Addr a );
+static void shadow_mem_set8 ( Thread* uu_thr_acc, Addr a, UInt svNew );
+static XArray* singleton_VTS ( Thread* thr, UWord tym );
+
+static void initialise_data_structures ( void )
+{
+   SegmentID segid;
+   Segment*  seg;
+   Thread*   thr;
+
+   /* Get everything initialised and zeroed. */
+   tl_assert(admin_threads == NULL);
+   tl_assert(admin_locks == NULL);
+   tl_assert(admin_segments == NULL);
+
+   tl_assert(sizeof(Addr) == sizeof(Word));
+   tl_assert(map_shmem == NULL);
+   map_shmem = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+   tl_assert(map_shmem != NULL);
+   shmem__invalidate_scache();
+
+   tl_assert(map_threads == NULL);
+   map_threads = hg_zalloc( VG_N_THREADS * sizeof(Thread*) );
+   tl_assert(map_threads != NULL);
+
+   /* re <=: < on 64-bit platforms, == on 32-bit ones */
+   tl_assert(sizeof(SegmentID) <= sizeof(Word));
+   tl_assert(sizeof(Segment*) == sizeof(Word));
+   tl_assert(map_segments == NULL);
+   map_segments = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+   tl_assert(map_segments != NULL);
+   hbefore__invalidate_cache();
+
+   tl_assert(sizeof(Addr) == sizeof(Word));
+   tl_assert(map_locks == NULL);
+   map_locks = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxed Word cmp*/);
+   tl_assert(map_locks != NULL);
+
+   __bus_lock_Lock = mk_LockN( LK_nonRec, (Addr)&__bus_lock );
+   tl_assert(is_sane_LockN(__bus_lock_Lock));
+   HG_(addToFM)( map_locks, (Word)&__bus_lock, (Word)__bus_lock_Lock );
+
+   tl_assert(univ_tsets == NULL);
+   univ_tsets = HG_(newWordSetU)( hg_zalloc, hg_free, 8/*cacheSize*/ );
+   tl_assert(univ_tsets != NULL);
+
+   tl_assert(univ_lsets == NULL);
+   univ_lsets = HG_(newWordSetU)( hg_zalloc, hg_free, 8/*cacheSize*/ );
+   tl_assert(univ_lsets != NULL);
+
+   tl_assert(univ_laog == NULL);
+   univ_laog = HG_(newWordSetU)( hg_zalloc, hg_free, 24/*cacheSize*/ );
+   tl_assert(univ_laog != NULL);
+
+   /* Set up entries for the root thread */
+   // FIXME: this assumes that the first real ThreadId is 1
+
+   /* a segment for the new thread ... */
+   // FIXME: code duplication in ev__post_thread_create
+   segid = alloc_SegmentID();
+   seg   = mk_Segment( NULL, NULL, NULL );
+   map_segments_add( segid, seg );
+
+   /* a Thread for the new thread ... */
+   thr = mk_Thread( segid );
+   seg->thr = thr;
+
+   /* Give the thread a starting-off vector timestamp. */
+   seg->vts = singleton_VTS( seg->thr, 1 );
+
+   /* and bind it in the thread-map table.
+      FIXME: assumes root ThreadId == 1. */
+   map_threads[1] = thr;
+
+   tl_assert(VG_INVALID_THREADID == 0);
+
+   /* Mark the new bus lock correctly (to stop the sanity checks
+      complaining) */
+   tl_assert( sizeof(__bus_lock) == 4 );
+   shadow_mem_set8( NULL/*unused*/, __bus_lock_Lock->guestaddr, 
+                                    mk_SHVAL_Excl(segid) );
+   shmem__set_mbHasLocks( __bus_lock_Lock->guestaddr, True );
+
+   all__sanity_check("initialise_data_structures");
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_threads :: WordFM core-ThreadId Thread*              ---*/
+/*----------------------------------------------------------------*/
+
+/* Doesn't assert if the relevant map_threads entry is NULL. */
+static Thread* map_threads_maybe_lookup ( ThreadId coretid )
+{
+   Thread* thr;
+   tl_assert( is_sane_ThreadId(coretid) );
+   thr = map_threads[coretid];
+   return thr;
+}
+
+/* Asserts if the relevant map_threads entry is NULL. */
+static inline Thread* map_threads_lookup ( ThreadId coretid )
+{
+   Thread* thr;
+   tl_assert( is_sane_ThreadId(coretid) );
+   thr = map_threads[coretid];
+   tl_assert(thr);
+   return thr;
+}
+
+/* Do a reverse lookup.  Warning: POTENTIALLY SLOW.  Does not assert
+   if 'thr' is not found in map_threads. */
+static ThreadId map_threads_maybe_reverse_lookup_SLOW ( Thread* thr )
+{
+   Int i;
+   tl_assert(is_sane_Thread(thr));
+   /* Check nobody used the invalid-threadid slot */
+   tl_assert(VG_INVALID_THREADID >= 0 && VG_INVALID_THREADID < VG_N_THREADS);
+   tl_assert(map_threads[VG_INVALID_THREADID] == NULL);
+   for (i = 0; i < VG_N_THREADS; i++) {
+      if (i != VG_INVALID_THREADID && map_threads[i] == thr)
+         return (ThreadId)i;
+   }
+   return VG_INVALID_THREADID;
+}
+
+/* Do a reverse lookup.  Warning: POTENTIALLY SLOW.  Asserts if 'thr'
+   is not found in map_threads. */
+static ThreadId map_threads_reverse_lookup_SLOW ( Thread* thr )
+{
+   ThreadId tid = map_threads_maybe_reverse_lookup_SLOW( thr );
+   tl_assert(tid != VG_INVALID_THREADID);
+   return tid;
+}
+
+static void map_threads_delete ( ThreadId coretid )
+{
+   Thread* thr;
+   tl_assert(coretid != 0);
+   tl_assert( is_sane_ThreadId(coretid) );
+   thr = map_threads[coretid];
+   tl_assert(thr);
+   map_threads[coretid] = NULL;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_locks :: WordFM guest-Addr-of-lock Lock*             ---*/
+/*----------------------------------------------------------------*/
+
+/* Make sure there is a lock table entry for the given (lock) guest
+   address.  If not, create one of the stated 'kind' in unheld state.
+   In any case, return the address of the existing or new Lock. */
+static 
+Lock* map_locks_lookup_or_create ( LockKind lkk, Addr ga, ThreadId tid )
+{
+   Bool  found;
+   Lock* oldlock = NULL;
+   tl_assert(is_sane_ThreadId(tid));
+   found = HG_(lookupFM)( map_locks, 
+                          NULL, (Word*)(void*)&oldlock, (Word)ga );
+   if (!found) {
+      Lock* lock = mk_LockN(lkk, ga);
+      lock->appeared_at = VG_(record_ExeContext)( tid, 0 );
+      tl_assert(is_sane_LockN(lock));
+      HG_(addToFM)( map_locks, (Word)ga, (Word)lock );
+      tl_assert(oldlock == NULL);
+      // mark the relevant secondary map has .mbHasLocks
+      shmem__set_mbHasLocks( ga, True );
+      return lock;
+   } else {
+      tl_assert(oldlock != NULL);
+      tl_assert(is_sane_LockN(oldlock));
+      tl_assert(oldlock->guestaddr == ga);
+      // check the relevant secondary map has .mbHasLocks?
+      tl_assert(shmem__get_mbHasLocks(ga) == True);
+      return oldlock;
+   }
+}
+
+static Lock* map_locks_maybe_lookup ( Addr ga )
+{
+   Bool  found;
+   Lock* lk = NULL;
+   found = HG_(lookupFM)( map_locks, NULL, (Word*)(void*)&lk, (Word)ga );
+   tl_assert(found  ?  lk != NULL  :  lk == NULL);
+   if (found) {
+      // check the relevant secondary map has .mbHasLocks?
+      tl_assert(shmem__get_mbHasLocks(ga) == True);
+   }
+   return lk;
+}
+
+static void map_locks_delete ( Addr ga )
+{
+   Addr  ga2 = 0;
+   Lock* lk  = NULL;
+   HG_(delFromFM)( map_locks,
+                   (Word*)(void*)&ga2, (Word*)(void*)&lk, (Word)ga );
+   /* delFromFM produces the val which is being deleted, if it is
+      found.  So assert it is non-null; that in effect asserts that we
+      are deleting a (ga, Lock) pair which actually exists. */
+   tl_assert(lk != NULL);
+   tl_assert(ga2 == ga);
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_segments :: WordFM SegmentID Segment*                ---*/
+/*--- the DAG of thread segments                               ---*/
+/*----------------------------------------------------------------*/
+
+static void segments__generate_vcg ( void ); /* fwds */
+
+/*--------------- SegmentID to Segment* maps ---------------*/
+
+static Segment* map_segments_lookup ( SegmentID segid )
+{
+   Bool     found;
+   Segment* seg = NULL;
+   tl_assert( is_sane_SegmentID(segid) );
+   found = HG_(lookupFM)( map_segments,
+                          NULL, (Word*)(void*)&seg, (Word)segid );
+   tl_assert(found);
+   tl_assert(seg != NULL);
+   return seg;
+}
+
+static Segment* map_segments_maybe_lookup ( SegmentID segid )
+{
+   Bool     found;
+   Segment* seg = NULL;
+   tl_assert( is_sane_SegmentID(segid) );
+   found = HG_(lookupFM)( map_segments,
+                          NULL, (Word*)(void*)&seg, (Word)segid );
+   if (!found) tl_assert(seg == NULL);
+   return seg;
+}
+
+static void map_segments_add ( SegmentID segid, Segment* seg )
+{
+   /* This is a bit inefficient.  Oh well. */
+   tl_assert( !HG_(lookupFM)( map_segments, NULL, NULL, segid ));
+   HG_(addToFM)( map_segments, (Word)segid, (Word)seg );
+}
+
+/*--------------- to do with Vector Timestamps ---------------*/
+
+/* Scalar Timestamp */
+typedef
+   struct {
+      Thread* thr;
+      UWord   tym;
+   }
+   ScalarTS;
+
+/* Vector Timestamp = XArray* ScalarTS */
+
+static Bool is_sane_VTS ( XArray* vts )
+{
+   UWord     i, n;
+   ScalarTS  *st1, *st2;
+   n = VG_(sizeXA)( vts );
+   if (n >= 2) {
+      for (i = 0; i < n-1; i++) {
+         st1 = VG_(indexXA)( vts, i );
+         st2 = VG_(indexXA)( vts, i+1 );
+         if (st1->thr >= st2->thr)
+            return False;
+         if (st1->tym == 0 || st2->tym == 0)
+            return False;
+      }
+   }
+   return True;
+}
+
+static XArray* new_VTS ( void ) {
+   return VG_(newXA)( hg_zalloc, hg_free, sizeof(ScalarTS) );
+}
+static XArray* singleton_VTS ( Thread* thr, UWord tym ) {
+   ScalarTS st;
+   XArray*  vts;
+   tl_assert(thr);
+   tl_assert(tym >= 1);
+   vts = new_VTS();
+   tl_assert(vts);
+   st.thr = thr;
+   st.tym = tym;
+   VG_(addToXA)( vts, &st );
+   return vts;
+}
+
+
+static Bool cmpGEQ_VTS ( XArray* a, XArray* b )
+{
+   Word     ia, ib, useda, usedb;
+   UWord    tyma, tymb;
+   Thread*  thr;
+   ScalarTS *tmpa, *tmpb;
+
+   Bool all_leq = True;
+   Bool all_geq = True;
+
+   tl_assert(a);
+   tl_assert(b);
+   useda = VG_(sizeXA)( a );
+   usedb = VG_(sizeXA)( b );
+
+   ia = ib = 0;
+
+   while (1) {
+
+      /* This logic is to enumerate triples (thr, tyma, tymb) drawn
+         from a and b in order, where thr is the next Thread*
+         occurring in either a or b, and tyma/b are the relevant
+         scalar timestamps, taking into account implicit zeroes. */
+      tl_assert(ia >= 0 && ia <= useda);
+      tl_assert(ib >= 0 && ib <= usedb);
+      tmpa = tmpb = NULL;
+
+      if (ia == useda && ib == usedb) {
+         /* both empty - done */
+         break;
+      }
+      else
+      if (ia == useda && ib != usedb) {
+         /* a empty, use up b */
+         tmpb = VG_(indexXA)( b, ib );
+         thr  = tmpb->thr;
+         tyma = 0;
+         tymb = tmpb->tym;
+         ib++;
+      }
+      else
+      if (ia != useda && ib == usedb) {
+         /* b empty, use up a */
+         tmpa = VG_(indexXA)( a, ia );
+         thr  = tmpa->thr;
+         tyma = tmpa->tym;
+         tymb = 0;
+         ia++;
+      }
+      else {
+         /* both not empty; extract lowest-Thread*'d triple */
+         tmpa = VG_(indexXA)( a, ia );
+         tmpb = VG_(indexXA)( b, ib );
+         if (tmpa->thr < tmpb->thr) {
+            /* a has the lowest unconsidered Thread* */
+            thr  = tmpa->thr;
+            tyma = tmpa->tym;
+            tymb = 0;
+            ia++;
+         }
+         else
+         if (tmpa->thr > tmpb->thr) {
+            /* b has the lowest unconsidered Thread* */
+            thr  = tmpb->thr;
+            tyma = 0;
+            tymb = tmpb->tym;
+            ib++;
+         } else {
+            /* they both next mention the same Thread* */
+            tl_assert(tmpa->thr == tmpb->thr);
+            thr  = tmpa->thr; /* == tmpb->thr */
+            tyma = tmpa->tym;
+            tymb = tmpb->tym;
+            ia++;
+            ib++;
+         }
+      }
+
+      /* having laboriously determined (thr, tyma, tymb), do something
+         useful with it. */
+      if (tyma < tymb)
+         all_geq = False;
+      if (tyma > tymb)
+         all_leq = False;
+   }
+
+   if (all_leq && all_geq)
+      return True; /* PordEQ */
+   /* now we know they aren't equal, so either all_leq or all_geq or
+      both are false. */
+   if (all_leq)
+      return False; /* PordLT */
+   if (all_geq)
+      return True; /* PordGT */
+   /* hmm, neither all_geq or all_leq.  This means unordered. */
+   return False; /* PordUN */
+}
+
+
+/* Compute max((tick(thra,a),b) into a new XArray.  a and b are
+   unchanged.  If neither a nor b supply a value for 'thra',
+   assert. */
+static
+XArray* tickL_and_joinR_VTS ( Thread* thra, XArray* a, XArray* b )
+{
+   Word     ia, ib, useda, usedb, ticks_found;
+   UWord    tyma, tymb, tymMax;
+   Thread*  thr;
+   XArray*  res;
+   ScalarTS *tmpa, *tmpb;
+
+   tl_assert(a);
+   tl_assert(b);
+   tl_assert(thra);
+   useda = VG_(sizeXA)( a );
+   usedb = VG_(sizeXA)( b );
+
+   res = new_VTS();
+   ia = ib = ticks_found = 0;
+
+   while (1) {
+
+      /* This logic is to enumerate triples (thr, tyma, tymb) drawn
+         from a and b in order, where thr is the next Thread*
+         occurring in either a or b, and tyma/b are the relevant
+         scalar timestamps, taking into account implicit zeroes. */
+      tl_assert(ia >= 0 && ia <= useda);
+      tl_assert(ib >= 0 && ib <= usedb);
+      tmpa = tmpb = NULL;
+
+      if (ia == useda && ib == usedb) {
+         /* both empty - done */
+         break;
+      }
+      else
+      if (ia == useda && ib != usedb) {
+         /* a empty, use up b */
+         tmpb = VG_(indexXA)( b, ib );
+         thr  = tmpb->thr;
+         tyma = 0;
+         tymb = tmpb->tym;
+         ib++;
+      }
+      else
+      if (ia != useda && ib == usedb) {
+         /* b empty, use up a */
+         tmpa = VG_(indexXA)( a, ia );
+         thr  = tmpa->thr;
+         tyma = tmpa->tym;
+         tymb = 0;
+         ia++;
+      }
+      else {
+         /* both not empty; extract lowest-Thread*'d triple */
+         tmpa = VG_(indexXA)( a, ia );
+         tmpb = VG_(indexXA)( b, ib );
+         if (tmpa->thr < tmpb->thr) {
+            /* a has the lowest unconsidered Thread* */
+            thr  = tmpa->thr;
+            tyma = tmpa->tym;
+            tymb = 0;
+            ia++;
+         }
+         else
+         if (tmpa->thr > tmpb->thr) {
+            /* b has the lowest unconsidered Thread* */
+            thr  = tmpb->thr;
+            tyma = 0;
+            tymb = tmpb->tym;
+            ib++;
+         } else {
+            /* they both next mention the same Thread* */
+            tl_assert(tmpa->thr == tmpb->thr);
+            thr  = tmpa->thr; /* == tmpb->thr */
+            tyma = tmpa->tym;
+            tymb = tmpb->tym;
+            ia++;
+            ib++;
+         }
+      }
+
+      /* having laboriously determined (thr, tyma, tymb), do something
+         useful with it. */
+      if (thr == thra) {
+         if (tyma > 0) {
+            /* VTS 'a' actually supplied this value; it is not a
+               default zero.  Do the required 'tick' action. */
+            tyma++;
+            ticks_found++;
+         } else {
+            /* 'a' didn't supply this value, so 'b' must have. */
+            tl_assert(tymb > 0);
+         }
+      }
+      tymMax = tyma > tymb ? tyma : tymb;
+      if (tymMax > 0) {
+         ScalarTS st;
+         st.thr = thr;
+         st.tym = tymMax;
+         VG_(addToXA)( res, &st );
+      }
+
+   }
+
+   tl_assert(is_sane_VTS( res ));
+
+   if (thra != NULL) {
+      tl_assert(ticks_found == 1);
+   } else {
+      tl_assert(ticks_found == 0);
+   }
+
+   return res;
+}
+
+
+/* Do 'vts[me]++', so to speak.  If 'me' does not have an entry in
+   'vts', set it to 1 in the returned VTS. */
+
+static XArray* tick_VTS ( Thread* me, XArray* vts ) {
+   ScalarTS* here = NULL;
+   ScalarTS  tmp;
+   XArray*   res;
+   Word      i, n; 
+   tl_assert(me);
+   tl_assert(is_sane_VTS(vts));
+   if (0) VG_(printf)("tick vts thrno %ld szin %d\n",
+                      (Word)me->errmsg_index, (Int)VG_(sizeXA)(vts) );
+   res = new_VTS();
+   n = VG_(sizeXA)( vts );
+   for (i = 0; i < n; i++) {
+      here = VG_(indexXA)( vts, i );
+      if (me < here->thr) {
+         /* We just went past 'me', without seeing it. */
+         tmp.thr = me;
+         tmp.tym = 1;
+         VG_(addToXA)( res, &tmp );
+         tmp = *here;
+         VG_(addToXA)( res, &tmp );
+         i++;
+         break;
+      } 
+      else if (me == here->thr) {
+         tmp = *here;
+         tmp.tym++;
+         VG_(addToXA)( res, &tmp );
+         i++;
+         break;
+      }
+      else /* me > here->thr */ {
+         tmp = *here;
+         VG_(addToXA)( res, &tmp );
+      }
+   }
+   tl_assert(i >= 0 && i <= n);
+   if (i == n && here && here->thr < me) {
+      tmp.thr = me;
+      tmp.tym = 1;
+      VG_(addToXA)( res, &tmp );
+   } else {
+      for (/*keepgoing*/; i < n; i++) {
+         here = VG_(indexXA)( vts, i );
+         tmp = *here;
+         VG_(addToXA)( res, &tmp );
+      }
+   }
+   tl_assert(is_sane_VTS(res));
+   if (0) VG_(printf)("tick vts thrno %ld szou %d\n",
+                      (Word)me->errmsg_index, (Int)VG_(sizeXA)(res) );
+   return res;
+}
+
+static void show_VTS ( HChar* buf, Int nBuf, XArray* vts ) {
+   ScalarTS* st;
+   HChar     unit[64];
+   Word      i, n;
+   Int       avail = nBuf;
+   tl_assert(avail > 16);
+   buf[0] = '[';
+   buf[1] = 0;
+   n = VG_(sizeXA)( vts );
+   for (i = 0; i < n; i++) {
+      tl_assert(avail >= 10);
+      st = VG_(indexXA)( vts, i );
+      VG_(memset)(unit, 0, sizeof(unit));
+      VG_(sprintf)(unit, i < n-1 ? "%ld:%ld " : "%ld:%ld",
+                         (Word)st->thr->errmsg_index, st->tym);
+      if (avail < VG_(strlen)(unit) + 10/*let's say*/) {
+         VG_(strcat)(buf, " ...]");
+         return;
+      }
+      VG_(strcat)(buf, unit);
+      avail -= VG_(strlen)(unit);
+   }
+   VG_(strcat)(buf, "]");
+}
+
+
+/*------------ searching the happens-before graph ------------*/
+
+static UWord stats__hbefore_queries   = 0; // total # queries
+static UWord stats__hbefore_cache0s   = 0; // hits at cache[0]
+static UWord stats__hbefore_cacheNs   = 0; // hits at cache[> 0]
+static UWord stats__hbefore_probes    = 0; // # checks in cache
+static UWord stats__hbefore_gsearches = 0; // # searches in graph
+static UWord stats__hbefore_gsearchFs = 0; // # fast searches in graph
+static UWord stats__hbefore_invals    = 0; // # cache invals
+static UWord stats__hbefore_stk_hwm   = 0; // stack high water mark
+
+/* Running marker for depth-first searches */
+/* NOTE: global variable */
+static UInt dfsver_current = 0;
+
+/* A stack of possibly-unexplored nodes used in the depth first search */
+/* NOTE: global variable */
+static XArray* dfsver_stack = NULL;
+
+// FIXME: check this - is it really correct?
+__attribute__((noinline))
+static Bool happens_before_do_dfs_from_to ( Segment* src, Segment* dst )
+{
+   Segment* here;
+   Word     ssz;
+
+   /* begin SPEEDUP HACK -- the following can safely be omitted */
+   /* fast track common case, without favouring either the
+      ->prev or ->other links */
+   tl_assert(src);
+   tl_assert(dst);
+   if ((src->prev && src->prev == dst)
+       || (src->other && src->other == dst)) {
+      stats__hbefore_gsearchFs++;
+      return True;
+   }
+   /* end SPEEDUP HACK */
+
+   /* empty out the stack */
+   tl_assert(dfsver_stack);
+   VG_(dropTailXA)( dfsver_stack, VG_(sizeXA)( dfsver_stack ));
+   tl_assert(VG_(sizeXA)( dfsver_stack ) == 0);
+
+   /* push starting point */
+   (void) VG_(addToXA)( dfsver_stack, &src );
+
+   while (True) {
+      /* While the stack is not empty, pop the next node off it and
+         consider. */
+      ssz = VG_(sizeXA)( dfsver_stack );
+      tl_assert(ssz >= 0);
+      if (ssz == 0)
+         return False; /* stack empty ==> no path from src to dst */
+
+      if (UNLIKELY( ((UWord)ssz) > stats__hbefore_stk_hwm ))
+         stats__hbefore_stk_hwm = (UWord)ssz;
+
+      /* here = pop(stack) */
+      here = *(Segment**) VG_(indexXA)( dfsver_stack, ssz-1 );
+      VG_(dropTailXA)( dfsver_stack, 1 );
+
+     again:
+      /* consider the node 'here' */
+      if (here == dst)
+         return True; /* found a path from src and dst */
+
+      /* have we been to 'here' before? */
+      tl_assert(here->dfsver <= dfsver_current);
+      if (here->dfsver == dfsver_current)
+         continue; /* We've been 'here' before - node is not interesting*/
+
+      /* Mark that we've been here */
+      here->dfsver = dfsver_current;
+
+      /* Now push both children on the stack */
+
+      /* begin SPEEDUP hack -- the following can safely be omitted */
+      /* idea is, if there is exactly one child, avoid the overhead of
+         pushing it on the stack and immediately popping it off again.
+         Kinda like doing a tail-call. */
+      if (here->prev && !here->other) {
+         here = here->prev;
+         goto again;
+      }
+      if (here->other && !here->prev) {
+         here = here->other;
+         goto again;
+      }
+      /* end of SPEEDUP HACK */
+
+      /* Push all available children on stack.  From some quick
+         experimentation it seems like exploring ->other first leads
+         to lower maximum stack use, although getting repeatable
+         results is difficult. */
+      if (here->prev)
+         (void) VG_(addToXA)( dfsver_stack, &(here->prev) );
+      if (here->other)
+         (void) VG_(addToXA)( dfsver_stack, &(here->other) );
+   }
+}
+
+__attribute__((noinline))
+static Bool happens_before_wrk ( Segment* seg1, Segment* seg2 )
+{
+   Bool reachable;
+
+   { static Int nnn = 0;
+     if (SHOW_EXPENSIVE_STUFF && (nnn++ % 1000) == 0)
+        VG_(printf)("happens_before_wrk: %d\n", nnn);
+   }
+
+   /* Now the question is, is there a chain of pointers through the
+      .prev and .other fields, that leads from seg2 back to seg1 ? */
+   tl_assert(dfsver_current < 0xFFFFFFFF);
+   dfsver_current++;
+   
+   if (dfsver_stack == NULL) {
+     dfsver_stack = VG_(newXA)( hg_zalloc, hg_free, sizeof(Segment*) );
+     tl_assert(dfsver_stack);
+   }
+
+   reachable = happens_before_do_dfs_from_to( seg2, seg1 );
+
+   return reachable;
+}
+
+/*--------------- the happens_before cache ---------------*/
+
+#define HBEFORE__N_CACHE 64
+typedef 
+   struct { SegmentID segid1; SegmentID segid2; Bool result; } 
+   HBeforeCacheEnt;
+
+static HBeforeCacheEnt hbefore__cache[HBEFORE__N_CACHE];
+
+static void hbefore__invalidate_cache ( void ) 
+{
+   Int i;
+   SegmentID bogus = 0;
+   tl_assert(!is_sane_SegmentID(bogus));
+   stats__hbefore_invals++;
+   for (i = 0; i < HBEFORE__N_CACHE; i++) {
+      hbefore__cache[i].segid1 = bogus;
+      hbefore__cache[i].segid2 = bogus;
+      hbefore__cache[i].result = False;
+   }
+}
+
+static Bool happens_before ( SegmentID segid1, SegmentID segid2 )
+{
+   Bool    hbG, hbV;
+   Int     i, j, iNSERT_POINT;
+   Segment *seg1, *seg2;
+   tl_assert(is_sane_SegmentID(segid1));
+   tl_assert(is_sane_SegmentID(segid2));
+   tl_assert(segid1 != segid2);
+   stats__hbefore_queries++;
+   stats__hbefore_probes++;
+   if (segid1 == hbefore__cache[0].segid1 
+       && segid2 == hbefore__cache[0].segid2) {
+      stats__hbefore_cache0s++;
+      return hbefore__cache[0].result;
+   }
+   for (i = 1; i < HBEFORE__N_CACHE; i++) {
+      stats__hbefore_probes++;
+      if (segid1 == hbefore__cache[i].segid1 
+          && segid2 == hbefore__cache[i].segid2) {
+         /* Found it.  Move it 1 step closer to the front. */
+         HBeforeCacheEnt tmp = hbefore__cache[i];
+         hbefore__cache[i]   = hbefore__cache[i-1];
+         hbefore__cache[i-1] = tmp;
+         stats__hbefore_cacheNs++;
+         return tmp.result;
+      }
+   }
+   /* Not found.  Search the graph and add an entry to the cache. */
+   stats__hbefore_gsearches++;
+
+   seg1 = map_segments_lookup(segid1);
+   seg2 = map_segments_lookup(segid2);
+   tl_assert(is_sane_Segment(seg1));
+   tl_assert(is_sane_Segment(seg2));
+   tl_assert(seg1 != seg2);
+   tl_assert(seg1->vts);
+   tl_assert(seg2->vts);
+
+   hbV = cmpGEQ_VTS( seg2->vts, seg1->vts );
+   if (0) {
+      /* Crosscheck the vector-timestamp comparison result against that
+         obtained from the explicit graph approach.  Can be very
+         slow. */
+      hbG = happens_before_wrk( seg1, seg2 );
+   } else {
+      /* Assume the vector-timestamp comparison result is correct, and
+         use it as-is. */
+      hbG = hbV;
+   }
+
+   if (hbV != hbG) {
+      VG_(printf)("seg1 %p  seg2 %p  hbV %d  hbG %d\n", 
+                  seg1,seg2,(Int)hbV,(Int)hbG);
+      segments__generate_vcg();
+   }
+   tl_assert(hbV == hbG);
+
+   iNSERT_POINT = (1*HBEFORE__N_CACHE)/4 - 1;
+   /* if (iNSERT_POINT > 4) iNSERT_POINT = 4; */
+
+   for (j = HBEFORE__N_CACHE-1; j > iNSERT_POINT; j--) {
+      hbefore__cache[j] = hbefore__cache[j-1];
+   }
+   hbefore__cache[iNSERT_POINT].segid1 = segid1;
+   hbefore__cache[iNSERT_POINT].segid2 = segid2;
+   hbefore__cache[iNSERT_POINT].result = hbG;
+
+   if (0)
+   VG_(printf)("hb %d %d\n", (Int)segid1-(1<<24), (Int)segid2-(1<<24));
+   return hbG;
+}
+
+/*--------------- generating .vcg output ---------------*/
+
+static void segments__generate_vcg ( void )
+{
+#define PFX "xxxxxx"
+   /* Edge colours:
+         Black  -- the chain of .prev links
+         Green  -- thread creation, link to parent
+         Red    -- thread exit, link to exiting thread
+         Yellow -- signal edge
+         Pink   -- semaphore-up edge
+   */
+   Segment* seg;
+   HChar vtsstr[128];
+   VG_(printf)(PFX "graph: { title: \"Segments\"\n");
+   VG_(printf)(PFX "orientation: top_to_bottom\n");
+   VG_(printf)(PFX "height: 900\n");
+   VG_(printf)(PFX "width: 500\n");
+   VG_(printf)(PFX "x: 20\n");
+   VG_(printf)(PFX "y: 20\n");
+   VG_(printf)(PFX "color: lightgrey\n");
+   for (seg = admin_segments; seg; seg=seg->admin) {
+
+      VG_(printf)(PFX "node: { title: \"%p\" color: lightcyan "
+                  "textcolor: darkgreen label: \"Seg %p\\n", 
+                  seg, seg);
+      if (seg->thr->errmsg_index == 1) {
+         VG_(printf)("ROOT_THREAD");
+      } else {
+         VG_(printf)("Thr# %d", seg->thr->errmsg_index);
+      }
+
+      if (clo_gen_vcg >= 2) {
+         show_VTS( vtsstr, sizeof(vtsstr)-1, seg->vts );
+         vtsstr[sizeof(vtsstr)-1] = 0;
+         VG_(printf)("\\n%s", vtsstr);
+      }
+
+      VG_(printf)("\" }\n", vtsstr);
+
+      if (seg->prev)
+         VG_(printf)(PFX "edge: { sourcename: \"%p\" targetname: \"%p\""
+                     "color: black }\n", seg->prev, seg );
+      if (seg->other) {
+         HChar* colour = "orange";
+         switch (seg->other_hint) {
+            case 'c': colour = "darkgreen";  break; /* creation */
+            case 'j': colour = "red";        break; /* join (exit) */
+            case 's': colour = "orange";     break; /* signal */
+            case 'S': colour = "pink";       break; /* sem_post->wait */
+            case 'u': colour = "cyan";       break; /* unlock */
+            default: tl_assert(0);
+         }
+         VG_(printf)(PFX "edge: { sourcename: \"%p\" targetname: \"%p\""
+                     " color: %s }\n", seg->other, seg, colour );
+      }
+   }
+   VG_(printf)(PFX "}\n");
+#undef PFX
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- map_shmem :: WordFM Addr SecMap                          ---*/
+/*--- shadow memory (low level handlers) (shmem__* fns)        ---*/
+/*----------------------------------------------------------------*/
+
+
+static UWord stats__secmaps_allocd       = 0; // # SecMaps issued
+static UWord stats__secmap_ga_space_covered = 0; // # ga bytes covered
+static UWord stats__secmap_linesZ_allocd = 0; // # CacheLineZ's issued
+static UWord stats__secmap_linesZ_bytes  = 0; // .. using this much storage
+static UWord stats__secmap_linesF_allocd = 0; // # CacheLineF's issued
+static UWord stats__secmap_linesF_bytes  = 0; //  .. using this much storage
+static UWord stats__secmap_iterator_steppings = 0; // # calls to stepSMIter
+static UWord stats__cache_Z_fetches      = 0; // # Z lines fetched
+static UWord stats__cache_Z_wbacks       = 0; // # Z lines written back
+static UWord stats__cache_F_fetches      = 0; // # F lines fetched
+static UWord stats__cache_F_wbacks       = 0; // # F lines written back
+static UWord stats__cache_invals         = 0; // # cache invals
+static UWord stats__cache_flushes        = 0; // # cache flushes
+static UWord stats__cache_totrefs        = 0; // # total accesses
+static UWord stats__cache_totmisses      = 0; // # misses
+static UWord stats__cline_normalises     = 0; // # calls to cacheline_normalise
+static UWord stats__cline_read64s        = 0; // # calls to s_m_read64
+static UWord stats__cline_read32s        = 0; // # calls to s_m_read32
+static UWord stats__cline_read16s        = 0; // # calls to s_m_read16
+static UWord stats__cline_read8s         = 0; // # calls to s_m_read8
+static UWord stats__cline_write64s       = 0; // # calls to s_m_write64
+static UWord stats__cline_write32s       = 0; // # calls to s_m_write32
+static UWord stats__cline_write16s       = 0; // # calls to s_m_write16
+static UWord stats__cline_write8s        = 0; // # calls to s_m_write8
+static UWord stats__cline_set64s         = 0; // # calls to s_m_set64
+static UWord stats__cline_set32s         = 0; // # calls to s_m_set32
+static UWord stats__cline_set16s         = 0; // # calls to s_m_set16
+static UWord stats__cline_set8s          = 0; // # calls to s_m_set8
+static UWord stats__cline_get8s          = 0; // # calls to s_m_get8
+static UWord stats__cline_copy8s         = 0; // # calls to s_m_copy8
+static UWord stats__cline_64to32splits   = 0; // # 64-bit accesses split
+static UWord stats__cline_32to16splits   = 0; // # 32-bit accesses split
+static UWord stats__cline_16to8splits    = 0; // # 16-bit accesses split
+static UWord stats__cline_64to32pulldown = 0; // # calls to pulldown_to_32
+static UWord stats__cline_32to16pulldown = 0; // # calls to pulldown_to_16
+static UWord stats__cline_16to8pulldown  = 0; // # calls to pulldown_to_8
+
+
+static UInt shadow_mem_get8 ( Addr a ); /* fwds */
+
+static inline Addr shmem__round_to_SecMap_base ( Addr a ) {
+   return a & ~(N_SECMAP_ARANGE - 1);
+}
+static inline UWord shmem__get_SecMap_offset ( Addr a ) {
+   return a & (N_SECMAP_ARANGE - 1);
+}
+
+/*--------------- SecMap allocation --------------- */
+
+static HChar* shmem__bigchunk_next = NULL;
+static HChar* shmem__bigchunk_end1 = NULL;
+
+static void* shmem__bigchunk_alloc ( SizeT n )
+{
+   const SizeT sHMEM__BIGCHUNK_SIZE = 4096 * 256;
+   tl_assert(n > 0);
+   n = ROUNDUP(n, 16);
+   tl_assert(shmem__bigchunk_next <= shmem__bigchunk_end1);
+   tl_assert(shmem__bigchunk_end1 - shmem__bigchunk_next
+             <= (SSizeT)sHMEM__BIGCHUNK_SIZE);
+   if (shmem__bigchunk_next + n > shmem__bigchunk_end1) {
+      if (0)
+      VG_(printf)("XXXXX bigchunk: abandoning %d bytes\n", 
+                  (Int)(shmem__bigchunk_end1 - shmem__bigchunk_next));
+      shmem__bigchunk_next = VG_(am_shadow_alloc)( sHMEM__BIGCHUNK_SIZE );
+      shmem__bigchunk_end1 = shmem__bigchunk_next + sHMEM__BIGCHUNK_SIZE;
+   }
+   tl_assert(shmem__bigchunk_next);
+   tl_assert( 0 == (((Addr)shmem__bigchunk_next) & (16-1)) );
+   tl_assert(shmem__bigchunk_next + n <= shmem__bigchunk_end1);
+   shmem__bigchunk_next += n;
+   return shmem__bigchunk_next - n;
+}
+
+static SecMap* shmem__alloc_SecMap ( void )
+{
+   Word    i, j;
+   SecMap* sm = shmem__bigchunk_alloc( sizeof(SecMap) );
+   if (0) VG_(printf)("alloc_SecMap %p\n",sm);
+   tl_assert(sm);
+   sm->magic       = SecMap_MAGIC;
+   sm->mbHasLocks  = False; /* dangerous */
+   sm->mbHasShared = False; /* dangerous */
+   for (i = 0; i < N_SECMAP_ZLINES; i++) {
+      sm->linesZ[i].dict[0] = SHVAL_NoAccess;
+      sm->linesZ[i].dict[1] = 0; /* completely invalid SHVAL */
+      sm->linesZ[i].dict[2] = 0;
+      sm->linesZ[i].dict[3] = 0;
+      for (j = 0; j < N_LINE_ARANGE/4; j++)
+         sm->linesZ[i].ix2s[j] = 0; /* all reference dict[0] */
+   }
+   sm->linesF      = NULL;
+   sm->linesF_size = 0;
+   stats__secmaps_allocd++;
+   stats__secmap_ga_space_covered += N_SECMAP_ARANGE;
+   stats__secmap_linesZ_allocd += N_SECMAP_ZLINES;
+   stats__secmap_linesZ_bytes += N_SECMAP_ZLINES * sizeof(CacheLineZ);
+   return sm;
+}
+
+static SecMap* shmem__find_or_alloc_SecMap ( Addr ga )
+{
+   SecMap* sm    = NULL;
+   Addr    gaKey = shmem__round_to_SecMap_base(ga);
+   if (HG_(lookupFM)( map_shmem,
+                      NULL/*keyP*/, (Word*)(void*)&sm, (Word)gaKey )) {
+      /* Found; address of SecMap is in sm */
+      tl_assert(sm);
+   } else {
+      /* create a new one */
+      sm = shmem__alloc_SecMap();
+      tl_assert(sm);
+      HG_(addToFM)( map_shmem, (Word)gaKey, (Word)sm );
+   }
+   return sm;
+}
+
+
+/*--------------- cache management/lookup --------------- */
+
+/*--------------- misc --------------- */
+
+static Bool shmem__get_mbHasLocks ( Addr a )
+{
+   SecMap* sm;
+   Addr aKey = shmem__round_to_SecMap_base(a);
+   if (HG_(lookupFM)( map_shmem,
+                      NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+      /* Found */
+      return sm->mbHasLocks;
+   } else {
+      return False;
+   }
+}
+
+static void shmem__set_mbHasLocks ( Addr a, Bool b )
+{
+   SecMap* sm;
+   Addr aKey = shmem__round_to_SecMap_base(a);
+   tl_assert(b == False || b == True);
+   if (HG_(lookupFM)( map_shmem,
+                      NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+      /* Found; address of SecMap is in sm */
+   } else {
+      /* create a new one */
+      sm = shmem__alloc_SecMap();
+      tl_assert(sm);
+      HG_(addToFM)( map_shmem, (Word)aKey, (Word)sm );
+   }
+   sm->mbHasLocks = b;
+}
+
+static void shmem__set_mbHasShared ( Addr a, Bool b )
+{
+   SecMap* sm;
+   Addr aKey = shmem__round_to_SecMap_base(a);
+   tl_assert(b == False || b == True);
+   if (HG_(lookupFM)( map_shmem,
+                      NULL/*keyP*/, (Word*)(void*)&sm, (Word)aKey )) {
+      /* Found; address of SecMap is in sm */
+   } else {
+      /* create a new one */
+      sm = shmem__alloc_SecMap();
+      tl_assert(sm);
+      HG_(addToFM)( map_shmem, (Word)aKey, (Word)sm );
+   }
+   sm->mbHasShared = b;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Sanity checking the data structures                      ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__sanity_checks = 0;
+
+static Bool is_sane_CacheLine ( CacheLine* cl ); /* fwds */
+static Bool cmpGEQ_VTS ( XArray* a, XArray* b ); /* fwds */
+static void laog__sanity_check ( Char* who ); /* fwds */
+
+/* REQUIRED INVARIANTS:
+
+   Thread vs Segment/Lock/SecMaps
+
+      for each t in Threads {
+
+         // Thread.lockset: each element is really a valid Lock
+
+         // Thread.lockset: each Lock in set is actually held by that thread
+         for lk in Thread.lockset 
+            lk == LockedBy(t)
+
+         // Thread.csegid is a valid SegmentID
+         // and the associated Segment has .thr == t
+
+      }
+
+      all thread Locksets are pairwise empty under intersection
+      (that is, no lock is claimed to be held by more than one thread)
+      -- this is guaranteed if all locks in locksets point back to their
+      owner threads
+
+   Lock vs Thread/Segment/SecMaps
+
+      for each entry (gla, la) in map_locks
+         gla == la->guest_addr
+
+      for each lk in Locks {
+
+         lk->tag is valid
+         lk->guest_addr does not have shadow state NoAccess
+         if lk == LockedBy(t), then t->lockset contains lk
+         if lk == UnlockedBy(segid) then segid is valid SegmentID
+             and can be mapped to a valid Segment(seg)
+             and seg->thr->lockset does not contain lk
+         if lk == UnlockedNew then (no lockset contains lk)
+
+         secmaps for lk has .mbHasLocks == True
+
+      }
+
+   Segment vs Thread/Lock/SecMaps
+
+      the Segment graph is a dag (no cycles)
+      all of the Segment graph must be reachable from the segids
+         mentioned in the Threads
+
+      for seg in Segments {
+
+         seg->thr is a sane Thread
+
+      }
+
+   SecMaps vs Segment/Thread/Lock
+
+      for sm in SecMaps {
+
+         sm properly aligned
+         if any shadow word is ShR or ShM then .mbHasShared == True
+
+         for each Excl(segid) state
+            map_segments_lookup maps to a sane Segment(seg)
+         for each ShM/ShR(tsetid,lsetid) state
+            each lk in lset is a valid Lock
+            each thr in tset is a valid thread, which is non-dead
+
+      }
+*/
+
+
+/* Return True iff 'thr' holds 'lk' in some mode. */
+static Bool thread_is_a_holder_of_Lock ( Thread* thr, Lock* lk )
+{
+   if (lk->heldBy)
+      return HG_(elemBag)( lk->heldBy, (Word)thr ) > 0;
+   else
+      return False;
+}
+
+/* Sanity check Threads, as far as possible */
+__attribute__((noinline))
+static void threads__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+   Char*     how = "no error";
+   Thread*   thr;
+   WordSetID wsA, wsW;
+   Word*     ls_words;
+   Word      ls_size, i;
+   Lock*     lk;
+   Segment*  seg;
+   for (thr = admin_threads; thr; thr = thr->admin) {
+      if (!is_sane_Thread(thr)) BAD("1");
+      wsA = thr->locksetA;
+      wsW = thr->locksetW;
+      // locks held in W mode are a subset of all locks held
+      if (!HG_(isSubsetOf)( univ_lsets, wsW, wsA )) BAD("7");
+      HG_(getPayloadWS)( &ls_words, &ls_size, univ_lsets, wsA );
+      for (i = 0; i < ls_size; i++) {
+         lk = (Lock*)ls_words[i];
+         // Thread.lockset: each element is really a valid Lock
+         if (!is_sane_LockN(lk)) BAD("2");
+         // Thread.lockset: each Lock in set is actually held by that
+         // thread
+         if (!thread_is_a_holder_of_Lock(thr,lk)) BAD("3");
+         // Thread.csegid is a valid SegmentID
+         if (!is_sane_SegmentID(thr->csegid)) BAD("4");
+         // and the associated Segment has .thr == t
+         seg = map_segments_maybe_lookup(thr->csegid);
+         if (!is_sane_Segment(seg)) BAD("5");
+         if (seg->thr != thr) BAD("6");
+      }
+   }
+   return;
+  bad:
+   VG_(printf)("threads__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+   tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check Locks, as far as possible */
+__attribute__((noinline))
+static void locks__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+   Char*     how = "no error";
+   Addr      gla;
+   Lock*     lk;
+   Int       i;
+   // # entries in admin_locks == # entries in map_locks
+   for (i = 0, lk = admin_locks;  lk;  i++, lk = lk->admin)
+      ;
+   if (i != HG_(sizeFM)(map_locks)) BAD("1");
+   // for each entry (gla, lk) in map_locks
+   //      gla == lk->guest_addr
+   HG_(initIterFM)( map_locks );
+   while (HG_(nextIterFM)( map_locks,
+                           (Word*)(void*)&gla, (Word*)(void*)&lk )) {
+      if (lk->guestaddr != gla) BAD("2");
+   }
+   HG_(doneIterFM)( map_locks );
+   // scan through admin_locks ...
+   for (lk = admin_locks; lk; lk = lk->admin) {
+      // lock is sane.  Quite comprehensive, also checks that
+      // referenced (holder) threads are sane.
+      if (!is_sane_LockN(lk)) BAD("3");
+      // map_locks binds guest address back to this lock
+      if (lk != map_locks_maybe_lookup(lk->guestaddr)) BAD("4");
+      // lk->guest_addr does not have shadow state NoAccess
+      // FIXME: this could legitimately arise from a buggy guest
+      // that attempts to lock in (eg) freed memory.  Detect this
+      // and warn about it in the pre/post-mutex-lock event handler.
+      if (is_SHVAL_NoAccess(shadow_mem_get8(lk->guestaddr))) BAD("5");
+      // look at all threads mentioned as holders of this lock.  Ensure
+      // this lock is mentioned in their locksets.
+      if (lk->heldBy) {
+         Thread* thr;
+         Word    count;
+         HG_(initIterBag)( lk->heldBy );
+         while (HG_(nextIterBag)( lk->heldBy, 
+                                  (Word*)(void*)&thr, &count )) {
+            // is_sane_LockN above ensures these
+            tl_assert(count >= 1);
+            tl_assert(is_sane_Thread(thr));
+            if (!HG_(elemWS)(univ_lsets, thr->locksetA, (Word)lk)) 
+               BAD("6");
+            // also check the w-only lockset
+            if (lk->heldW 
+                && !HG_(elemWS)(univ_lsets, thr->locksetW, (Word)lk)) 
+               BAD("7");
+            if ((!lk->heldW)
+                && HG_(elemWS)(univ_lsets, thr->locksetW, (Word)lk)) 
+               BAD("8");
+         }
+         HG_(doneIterBag)( lk->heldBy );
+      } else {
+         /* lock not held by anybody */
+         if (lk->heldW) BAD("9"); /* should be False if !heldBy */
+         // since lk is unheld, then (no lockset contains lk)
+         // hmm, this is really too expensive to check.  Hmm.
+      }
+      // secmaps for lk has .mbHasLocks == True
+      if (!shmem__get_mbHasLocks(lk->guestaddr)) BAD("10");
+   }
+
+   return;
+  bad:
+   VG_(printf)("locks__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+   tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check Segments, as far as possible */
+__attribute__((noinline))
+static void segments__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+   Char*    how = "no error";
+   Int      i;
+   Segment* seg;
+   // FIXME
+   //   the Segment graph is a dag (no cycles)
+   //   all of the Segment graph must be reachable from the segids
+   //      mentioned in the Threads
+   // # entries in admin_segments == # entries in map_segments
+   for (i = 0, seg = admin_segments;  seg;  i++, seg = seg->admin)
+      ;
+   if (i != HG_(sizeFM)(map_segments)) BAD("1");
+   // for seg in Segments {
+   for (seg = admin_segments; seg; seg = seg->admin) {
+      if (!is_sane_Segment(seg)) BAD("2");
+      if (!is_sane_Thread(seg->thr)) BAD("3");
+      if (!seg->vts) BAD("4");
+      if (seg->prev && seg->prev->vts
+          && !cmpGEQ_VTS(seg->vts, seg->prev->vts))
+         BAD("5");
+      if (seg->other && seg->other->vts
+          && !cmpGEQ_VTS(seg->vts, seg->other->vts))
+         BAD("6");
+   }
+   return;
+  bad:
+   VG_(printf)("segments__sanity_check: who=\"%s\", bad=\"%s\"\n", 
+               who, how);
+   tl_assert(0);
+#undef BAD
+}
+
+
+/* Sanity check shadow memory, as far as possible */
+static Int cmp_Addr_for_ssort ( void* p1, void* p2 ) {
+   Addr a1 = *(Addr*)p1;
+   Addr a2 = *(Addr*)p2;
+   if (a1 < a2) return -1;
+   if (a1 > a2) return 1;
+   return 0;
+}
+__attribute__((noinline))
+static void shmem__sanity_check ( Char* who )
+{
+#define BAD(_str) do { how = (_str); goto bad; } while (0)
+   Char*   how = "no error";
+   Word    smga;
+   SecMap* sm;
+   Word    i, j, ws_size, n_valid_tags;
+   Word*   ws_words;
+   Addr*   valid_tags;
+   HG_(initIterFM)( map_shmem );
+   // for sm in SecMaps {
+   while (HG_(nextIterFM)( map_shmem,
+                           (Word*)(void*)&smga, (Word*)(void*)&sm )) {
+      SecMapIter itr;
+      UInt*      w32p;
+      Bool       mbHasShared = False;
+      Bool       allNoAccess = True;
+      if (!is_sane_SecMap(sm)) BAD("1");
+      // sm properly aligned
+      if (smga != shmem__round_to_SecMap_base(smga)) BAD("2");
+      // if any shadow word is ShR or ShM then .mbHasShared == True
+      initSecMapIter( &itr );
+      while (stepSecMapIter( &w32p, &itr, sm )) {
+         UInt w32 = *w32p;
+         if (is_SHVAL_Sh(w32)) 
+            mbHasShared = True;
+         if (!is_SHVAL_NoAccess(w32))
+            allNoAccess = False;
+         if (is_SHVAL_Excl(w32)) {
+            // for each Excl(segid) state
+            // map_segments_lookup maps to a sane Segment(seg)
+            Segment*  seg;
+            SegmentID segid = un_SHVAL_Excl(w32);
+            if (!is_sane_SegmentID(segid)) BAD("3");
+            seg = map_segments_maybe_lookup(segid);
+            if (!is_sane_Segment(seg)) BAD("4");
+         } 
+         else if (is_SHVAL_Sh(w32)) {
+            WordSetID tset = un_SHVAL_Sh_tset(w32);
+            WordSetID lset = un_SHVAL_Sh_lset(w32);
+            if (!HG_(plausibleWS)( univ_tsets, tset )) BAD("5");
+            if (!HG_(saneWS_SLOW)( univ_tsets, tset )) BAD("6");
+            if (HG_(cardinalityWS)( univ_tsets, tset ) < 2) BAD("7");
+            if (!HG_(plausibleWS)( univ_lsets, lset )) BAD("8");
+            if (!HG_(saneWS_SLOW)( univ_lsets, lset )) BAD("9");
+            HG_(getPayloadWS)( &ws_words, &ws_size, univ_lsets, lset );
+            for (j = 0; j < ws_size; j++) {
+               Lock* lk = (Lock*)ws_words[j];
+               // for each ShM/ShR(tsetid,lsetid) state
+               // each lk in lset is a valid Lock
+               if (!is_sane_LockN(lk)) BAD("10");
+            }
+            HG_(getPayloadWS)( &ws_words, &ws_size, univ_tsets, tset );
+            for (j = 0; j < ws_size; j++) {
+               Thread* thr = (Thread*)ws_words[j];
+               //for each ShM/ShR(tsetid,lsetid) state
+               // each thr in tset is a valid thread, which is non-dead
+               if (!is_sane_Thread(thr)) BAD("11");
+            }
+         }
+         else if (is_SHVAL_NoAccess(w32) || is_SHVAL_New(w32)) {
+            /* nothing to check */
+         }
+         else {
+            /* bogus shadow mem value */
+            BAD("12");
+         }
+      } /* iterating over a SecMap */
+      // Check essential safety property
+      if (mbHasShared && !sm->mbHasShared) BAD("13");
+      // This is optional - check that destroyed memory has its hint
+      // bits cleared.  NB won't work properly unless full, eager
+      // GCing of SecMaps is implemented
+      //if (allNoAccess && sm->mbHasLocks) BAD("13a");
+   }
+   HG_(doneIterFM)( map_shmem );
+
+   // check the cache
+   valid_tags   = hg_zalloc(N_WAY_NENT * sizeof(Addr));
+   n_valid_tags = 0;
+   tl_assert(valid_tags);
+   for (i = 0; i < N_WAY_NENT; i++) {
+      CacheLine* cl;
+      Addr       tag; 
+      /* way0, dude */
+      cl  = &cache_shmem.lyns0[i];
+      tag =  cache_shmem.tags0[i];
+      if (tag != 1) {
+         if (!is_valid_scache_tag(tag)) BAD("14-0");
+         if (!is_sane_CacheLine(cl)) BAD("15-0");
+         /* A valid tag should be of the form 
+            X---X line_number:N_WAY_BITS 0:N_LINE_BITS */
+         if (tag & (N_LINE_ARANGE-1)) BAD("16-0");
+         if ( i != ((tag >> N_LINE_BITS) & (N_WAY_NENT-1)) ) BAD("16-1");
+         valid_tags[n_valid_tags++] = tag;
+      }
+   }
+   tl_assert(n_valid_tags <= N_WAY_NENT);
+   if (n_valid_tags > 1) {
+      /* Check that the valid tags are unique */
+      VG_(ssort)( valid_tags, n_valid_tags, sizeof(Addr), cmp_Addr_for_ssort );
+      for (i = 0; i < n_valid_tags-1; i++) {
+         if (valid_tags[i] >= valid_tags[i+1])
+            BAD("16-2");
+      }
+   }
+   hg_free(valid_tags);
+   return;
+  bad:
+   VG_(printf)("shmem__sanity_check: who=\"%s\", bad=\"%s\"\n", who, how);
+   tl_assert(0);
+#undef BAD
+}
+
+static void all_except_Locks__sanity_check ( Char* who ) {
+   stats__sanity_checks++;
+   if (0) VG_(printf)("all_except_Locks__sanity_check(%s)\n", who);
+   threads__sanity_check(who);
+   segments__sanity_check(who);
+   shmem__sanity_check(who);
+   laog__sanity_check(who);
+}
+static void all__sanity_check ( Char* who ) {
+   all_except_Locks__sanity_check(who);
+   locks__sanity_check(who);
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- the core memory state machine (msm__* functions)         ---*/
+/*----------------------------------------------------------------*/
+
+static UWord stats__msm_read_Excl_nochange = 0;
+static UWord stats__msm_read_Excl_transfer = 0;
+static UWord stats__msm_read_Excl_to_ShR   = 0;
+static UWord stats__msm_read_ShR_to_ShR    = 0;
+static UWord stats__msm_read_ShM_to_ShM    = 0;
+static UWord stats__msm_read_New_to_Excl   = 0;
+static UWord stats__msm_read_NoAccess      = 0;
+
+static UWord stats__msm_write_Excl_nochange = 0;
+static UWord stats__msm_write_Excl_transfer = 0;
+static UWord stats__msm_write_Excl_to_ShM   = 0;
+static UWord stats__msm_write_ShR_to_ShM    = 0;
+static UWord stats__msm_write_ShM_to_ShM    = 0;
+static UWord stats__msm_write_New_to_Excl   = 0;
+static UWord stats__msm_write_NoAccess      = 0;
+
+/* fwds */
+static void record_error_Race ( Thread* thr, 
+                                Addr data_addr, Bool isWrite, Int szB,
+                                UInt old_sv, UInt new_sv, 
+                                ExeContext* mb_lastlock );
+
+static void record_error_FreeMemLock ( Thread* thr, Lock* lk );
+
+static void record_error_UnlockUnlocked ( Thread*, Lock* );
+static void record_error_UnlockForeign  ( Thread*, Thread*, Lock* );
+static void record_error_UnlockBogus    ( Thread*, Addr );
+static void record_error_PthAPIerror    ( Thread*, HChar*, Word, HChar* );
+static void record_error_LockOrder      ( Thread*, Addr, Addr,
+                                                   ExeContext*, ExeContext* );
+
+static void record_error_Misc ( Thread*, HChar* );
+static void announce_one_thread ( Thread* thr ); /* fwds */
+
+static WordSetID add_BHL ( WordSetID lockset ) {
+   return HG_(addToWS)( univ_lsets, lockset, (Word)__bus_lock_Lock );
+}
+static WordSetID del_BHL ( WordSetID lockset ) {
+   return HG_(delFromWS)( univ_lsets, lockset, (Word)__bus_lock_Lock );
+}
+
+
+/* Last-lock-lossage records.  This mechanism exists to help explain
+   to programmers why we are complaining about a race.  The idea is to
+   monitor all lockset transitions.  When a previously nonempty
+   lockset becomes empty, the lock(s) that just disappeared (the
+   "lossage") are the locks that have consistently protected the
+   location (ga_of_access) in question for the longest time.  Most of
+   the time the lossage-set is a single lock.  Because the
+   lossage-lock is the one that has survived longest, there is there
+   is a good chance that it is indeed the lock that the programmer
+   intended to use to protect the location.
+
+   Note that we cannot in general just look at the lossage set when we
+   see a transition to ShM(...,empty-set), because a transition to an
+   empty lockset can happen arbitrarily far before the point where we
+   want to report an error.  This is in the case where there are many
+   transitions ShR -> ShR, all with an empty lockset, and only later
+   is there a transition to ShM.  So what we want to do is note the
+   lossage lock at the point where a ShR -> ShR transition empties out
+   the lockset, so we can present it later if there should be a
+   transition to ShM.
+
+   So this function finds such transitions.  For each, it associates
+   in ga_to_lastlock, the guest address and the lossage lock.  In fact
+   we do not record the Lock* directly as that may disappear later,
+   but instead the ExeContext inside the Lock which says where it was
+   initialised or first locked.  ExeContexts are permanent so keeping
+   them indefinitely is safe.
+
+   A boring detail: the hardware bus lock is not interesting in this
+   respect, so we first remove that from the pre/post locksets.
+*/
+
+static UWord stats__ga_LL_adds = 0;
+
+static WordFM* ga_to_lastlock = NULL; /* GuestAddr -> ExeContext* */
+
+static 
+void record_last_lock_lossage ( Addr ga_of_access,
+                                WordSetID lset_old, WordSetID lset_new )
+{
+   Lock* lk;
+   Int   card_old, card_new;
+
+   tl_assert(lset_old != lset_new);
+
+   if (0) VG_(printf)("XX1: %d (card %d) -> %d (card %d) %p\n", 
+                      (Int)lset_old, 
+                      HG_(cardinalityWS)(univ_lsets,lset_old),
+                      (Int)lset_new, 
+                      HG_(cardinalityWS)(univ_lsets,lset_new),
+                      ga_of_access );
+
+   /* This is slow, but at least it's simple.  The bus hardware lock
+      just confuses the logic, so remove it from the locksets we're
+      considering before doing anything else. */
+   lset_new = del_BHL( lset_new );
+
+   if (!HG_(isEmptyWS)( univ_lsets, lset_new )) {
+      /* The post-transition lock set is not empty.  So we are not
+         interested.  We're only interested in spotting transitions
+         that make locksets become empty. */
+      return;
+   }
+
+   /* lset_new is now empty */
+   card_new = HG_(cardinalityWS)( univ_lsets, lset_new );
+   tl_assert(card_new == 0);
+
+   lset_old = del_BHL( lset_old );
+   card_old = HG_(cardinalityWS)( univ_lsets, lset_old );
+
+   if (0) VG_(printf)(" X2: %d (card %d) -> %d (card %d)\n",
+                      (Int)lset_old, card_old, (Int)lset_new, card_new );
+
+   if (card_old == 0) {
+      /* The old lockset was also empty.  Not interesting. */
+      return;
+   }
+
+   tl_assert(card_old > 0);
+   tl_assert(!HG_(isEmptyWS)( univ_lsets, lset_old ));
+
+   /* Now we know we've got a transition from a nonempty lockset to an
+      empty one.  So lset_old must be the set of locks lost.  Record
+      some details.  If there is more than one element in the lossage
+      set, just choose one arbitrarily -- not the best, but at least
+      it's simple. */
+
+   lk = (Lock*)HG_(anyElementOfWS)( univ_lsets, lset_old );
+   if (0) VG_(printf)("lossage %d %p\n", 
+                      HG_(cardinalityWS)( univ_lsets, lset_old), lk );
+   if (lk->appeared_at) {
+      if (ga_to_lastlock == NULL)
+         ga_to_lastlock = HG_(newFM)( hg_zalloc, hg_free, NULL );
+      HG_(addToFM)( ga_to_lastlock, ga_of_access, (Word)lk->appeared_at );
+      stats__ga_LL_adds++;
+   }
+}
+
+/* This queries the table (ga_to_lastlock) made by
+   record_last_lock_lossage, when constructing error messages.  It
+   attempts to find the ExeContext of the allocation or initialisation
+   point for the lossage lock associated with 'ga'. */
+
+static ExeContext* maybe_get_lastlock_initpoint ( Addr ga ) 
+{
+   ExeContext* ec_hint = NULL;
+   if (ga_to_lastlock != NULL 
+       && HG_(lookupFM)(ga_to_lastlock, 
+                        NULL, (Word*)(void*)&ec_hint, ga)) {
+      tl_assert(ec_hint != NULL);
+      return ec_hint;
+   } else {
+      return NULL;
+   }
+}
+
+
+static void msm__show_state_change ( Thread* thr_acc, Addr a, Int szB,
+                                     Char howC,
+                                     UInt sv_old, UInt sv_new )
+{
+   ThreadId tid;
+   UChar txt_old[100], txt_new[100];
+   Char* how = "";
+   tl_assert(is_sane_Thread(thr_acc));
+   tl_assert(clo_trace_level == 1 || clo_trace_level == 2);
+   switch (howC) {
+      case 'r': how = "rd"; break;
+      case 'w': how = "wr"; break;
+      case 'p': how = "pa"; break;
+      default: tl_assert(0);
+   }
+   show_shadow_w32_for_user(txt_old, sizeof(txt_old), sv_old);
+   show_shadow_w32_for_user(txt_new, sizeof(txt_new), sv_new);
+   txt_old[sizeof(txt_old)-1] = 0;
+   txt_new[sizeof(txt_new)-1] = 0;
+   if (clo_trace_level == 2) {
+      /* show everything */
+      VG_(message)(Vg_UserMsg, "");
+      announce_one_thread( thr_acc );
+      VG_(message)(Vg_UserMsg, 
+                   "TRACE: %p %s %d thr#%d :: %s --> %s",
+                   a, how, szB, thr_acc->errmsg_index, txt_old, txt_new );
+      tid = map_threads_maybe_reverse_lookup_SLOW(thr_acc);
+      if (tid != VG_INVALID_THREADID) {
+         VG_(get_and_pp_StackTrace)( tid, 8 );
+      }
+   } else {
+      /* Just print one line */
+      VG_(message)(Vg_UserMsg, 
+                   "TRACE: %p %s %d thr#%d :: %22s --> %22s",
+                   a, how, szB, thr_acc->errmsg_index, txt_old, txt_new );
+   }
+}
+
+
+/* Here are some MSM stats from startup/shutdown of OpenOffice.
+
+     msm:  489,734,723   80,278,862 rd/wr_Excl_nochange
+     msm:    3,171,542       93,738 rd/wr_Excl_transfer
+     msm:       45,036          167 rd/wr_Excl_to_ShR/ShM
+     msm:   13,352,594          285 rd/wr_ShR_to_ShR/ShM
+     msm:    1,125,879      815,779 rd/wr_ShM_to_ShM
+     msm:    7,561,842  250,629,935 rd/wr_New_to_Excl
+     msm:       17,778            0 rd/wr_NoAccess
+
+   This says how the clauses should be ordered for greatest speed:
+
+   * the vast majority of memory reads (490 million out of a total of
+     515 million) are of memory in an exclusive state, and the state
+     is unchanged.  All other read accesses are insignificant by
+     comparison.
+
+   * 75% (251 million out of a total of 332 million) writes are 'first
+     time' writes, which take New memory into exclusive ownership.
+     Almost all the rest (80 million) are accesses to exclusive state,
+     which remains unchanged.  All other write accesses are
+     insignificant. */
+
+/* The core MSM.  If 'wold' is the old 32-bit shadow word for a
+   location, return the new shadow word that would result for a read
+   of the location, and report any errors necessary on the way.  This
+   does not update shadow memory - it merely produces new shadow words
+   from old.  'thr_acc' and 'a' are supplied only so it can produce
+   coherent error messages if necessary. */
+static
+UInt msm__handle_read ( Thread* thr_acc, Addr a, UInt wold, Int szB )
+{
+   UInt wnew = SHVAL_Invalid;
+
+   tl_assert(is_sane_Thread(thr_acc));
+
+   if (0) VG_(printf)("read thr=%p %p\n", thr_acc, a);
+
+   /* Exclusive */
+   if (LIKELY(is_SHVAL_Excl(wold))) {
+      /* read Excl(segid) 
+           |  segid_old == segid-of-thread
+           -> no change
+           |  segid_old `happens_before` segid-of-this-thread
+           -> Excl(segid-of-this-thread)
+           |  otherwise
+           -> ShR
+      */
+      SegmentID segid_old = un_SHVAL_Excl(wold);
+      tl_assert(is_sane_SegmentID(segid_old));
+      if (LIKELY(segid_old == thr_acc->csegid)) {
+         /* no change */
+         stats__msm_read_Excl_nochange++;
+         /*NOCHANGE*/return wold;
+      }
+      if (happens_before(segid_old, thr_acc->csegid)) {
+         /* -> Excl(segid-of-this-thread) */
+         wnew = mk_SHVAL_Excl(thr_acc->csegid);
+         stats__msm_read_Excl_transfer++;
+         goto changed;
+      }
+      /* else */ {
+         /* Enter the shared-readonly (ShR) state. */
+         WordSetID tset, lset;
+         /* This location has been accessed by precisely two threads.
+            Make an appropriate tset. */
+         // FIXME: performance: duplicate map_segments_lookup(segid_old)
+         // since must also be done in happens_before()
+         Segment* seg_old = map_segments_lookup( segid_old );
+         Thread*  thr_old = seg_old->thr;
+         tset = HG_(doubletonWS)( univ_tsets, (Word)thr_old, (Word)thr_acc );
+         lset = add_BHL( thr_acc->locksetA ); /* read ==> use all locks */
+         wnew = mk_SHVAL_ShR( tset, lset );
+         stats__msm_read_Excl_to_ShR++;
+         goto changed;
+      }
+      /*NOTREACHED*/
+   } 
+
+   /* Shared-Readonly */
+   if (is_SHVAL_ShR(wold)) {
+     /* read Shared-Readonly(threadset, lockset)
+        We remain in ShR state, but add this thread to the 
+        threadset and refine the lockset accordingly.  Do not
+        complain if the lockset becomes empty -- that's ok. */
+      WordSetID tset_old = un_SHVAL_ShR_tset(wold);
+      WordSetID lset_old = un_SHVAL_ShR_lset(wold);
+      WordSetID tset_new = HG_(addToWS)( univ_tsets, 
+                                         tset_old, (Word)thr_acc );
+      WordSetID lset_new = HG_(intersectWS)( univ_lsets,
+                                             lset_old, 
+                                             add_BHL(thr_acc->locksetA)
+                                             /* read ==> use all locks */ );
+      /*UInt*/  wnew     = mk_SHVAL_ShR( tset_new, lset_new );
+      if (lset_old != lset_new)
+         record_last_lock_lossage(a,lset_old,lset_new);
+      stats__msm_read_ShR_to_ShR++;
+      goto changed;
+   }
+
+   /* Shared-Modified */
+   if (is_SHVAL_ShM(wold)) {
+      /* read Shared-Modified(threadset, lockset)
+         We remain in ShM state, but add this thread to the 
+         threadset and refine the lockset accordingly.
+         If the lockset becomes empty, complain. */
+      WordSetID tset_old = un_SHVAL_ShM_tset(wold);
+      WordSetID lset_old = un_SHVAL_ShM_lset(wold);
+      WordSetID tset_new = HG_(addToWS)( univ_tsets,
+                                         tset_old, (Word)thr_acc );
+      WordSetID lset_new = HG_(intersectWS)( univ_lsets,
+                                             lset_old,
+                                             add_BHL(thr_acc->locksetA)
+                                             /* read ==> use all locks */ ); 
+      /*UInt*/  wnew     = mk_SHVAL_ShM( tset_new, lset_new );
+      if (lset_old != lset_new)
+         record_last_lock_lossage(a,lset_old,lset_new);
+      if (HG_(isEmptyWS)(univ_lsets, lset_new)
+          && !HG_(isEmptyWS)(univ_lsets, lset_old)) {
+         record_error_Race( thr_acc, a, 
+                            False/*isWrite*/, szB, wold, wnew,
+                            maybe_get_lastlock_initpoint(a) );
+      }
+      stats__msm_read_ShM_to_ShM++;
+      goto changed;
+   }
+ 
+   /* New */
+   if (is_SHVAL_New(wold)) {
+      /* read New -> Excl(segid) */
+      wnew = mk_SHVAL_Excl( thr_acc->csegid );
+      stats__msm_read_New_to_Excl++;
+      goto changed;
+   } 
+
+   /* NoAccess */
+   if (is_SHVAL_NoAccess(wold)) {
+      // FIXME: complain if accessing here
+      // FIXME: transition to Excl?
+      if (0)
+      VG_(printf)(
+         "msm__handle_read_aligned_32(thr=%p, addr=%p): NoAccess\n",
+         thr_acc, (void*)a );
+      stats__msm_read_NoAccess++;
+      /*NOCHANGE*/return wold; /* no change */
+   }
+
+   /* hmm, bogus state */
+   tl_assert(0);
+
+  changed:
+   if (UNLIKELY(clo_trace_level > 0)) {
+      if (a <= clo_trace_addr && clo_trace_addr < a+szB
+          && wold != wnew) {
+         msm__show_state_change( thr_acc, a, szB, 'r', wold, wnew );
+      }
+   }
+   return wnew;
+}
+
+/* Similar to msm__handle_read, compute a new 32-bit shadow word
+   resulting from a write to a location, and report any errors
+   necessary on the way. */
+static
+UInt msm__handle_write ( Thread* thr_acc, Addr a, UInt wold, Int szB )
+{
+   UInt wnew = SHVAL_Invalid;
+
+   tl_assert(is_sane_Thread(thr_acc));
+
+   if (0) VG_(printf)("write32 thr=%p %p\n", thr_acc, a);
+
+   /* New */
+   if (LIKELY(is_SHVAL_New(wold))) {
+      /* write New -> Excl(segid) */
+      wnew = mk_SHVAL_Excl( thr_acc->csegid );
+      stats__msm_write_New_to_Excl++;
+      goto changed;
+   }
+
+   /* Exclusive */
+   if (is_SHVAL_Excl(wold)) {
+      // I believe is identical to case for read Excl
+      // apart from enters ShM rather than ShR 
+      /* read Excl(segid) 
+           |  segid_old == segid-of-thread
+           -> no change
+           |  segid_old `happens_before` segid-of-this-thread
+           -> Excl(segid-of-this-thread)
+           |  otherwise
+           -> ShM
+      */
+      SegmentID segid_old = un_SHVAL_Excl(wold);
+      tl_assert(is_sane_SegmentID(segid_old));
+      if (segid_old == thr_acc->csegid) {
+         /* no change */
+         stats__msm_write_Excl_nochange++;
+         /*NOCHANGE*/return wold;
+      }
+      if (happens_before(segid_old, thr_acc->csegid)) {
+         /* -> Excl(segid-of-this-thread) */
+         wnew = mk_SHVAL_Excl(thr_acc->csegid);
+         stats__msm_write_Excl_transfer++;
+         goto changed;
+      }
+      /* else */ {
+         /* Enter the shared-modified (ShM) state. */
+         WordSetID tset, lset;
+         /* This location has been accessed by precisely two threads.
+            Make an appropriate tset. */
+         // FIXME: performance: duplicate map_segments_lookup(segid_old)
+         // since must also be done in happens_before()
+         Segment* seg_old = map_segments_lookup( segid_old );
+         Thread*  thr_old = seg_old->thr;
+         tset = HG_(doubletonWS)( univ_tsets, (Word)thr_old, (Word)thr_acc );
+         lset = thr_acc->locksetW; /* write ==> use only w-held locks */
+         wnew = mk_SHVAL_ShM( tset, lset );
+         if (HG_(isEmptyWS)(univ_lsets, lset)) {
+            record_error_Race( thr_acc, 
+                               a, True/*isWrite*/, szB, wold, wnew,
+                               maybe_get_lastlock_initpoint(a) );
+         }
+         stats__msm_write_Excl_to_ShM++;
+         goto changed;
+      }
+      /*NOTREACHED*/
+   } 
+
+   /* Shared-Readonly */
+   if (is_SHVAL_ShR(wold)) {
+      /* write Shared-Readonly(threadset, lockset)
+         We move to ShM state, add this thread to the 
+         threadset and refine the lockset accordingly.
+         If the lockset becomes empty, complain. */
+      WordSetID tset_old = un_SHVAL_ShR_tset(wold);
+      WordSetID lset_old = un_SHVAL_ShR_lset(wold);
+      WordSetID tset_new = HG_(addToWS)( univ_tsets, 
+                                         tset_old, (Word)thr_acc );
+      WordSetID lset_new = HG_(intersectWS)(
+                              univ_lsets, 
+                              lset_old, 
+                              thr_acc->locksetW
+                              /* write ==> use only w-held locks */
+                           );
+      /*UInt*/  wnew     = mk_SHVAL_ShM( tset_new, lset_new );
+      if (lset_old != lset_new)
+         record_last_lock_lossage(a,lset_old,lset_new);
+      if (HG_(isEmptyWS)(univ_lsets, lset_new)) {
+         record_error_Race( thr_acc, a, 
+                            True/*isWrite*/, szB, wold, wnew,
+                            maybe_get_lastlock_initpoint(a) );
+      }
+      stats__msm_write_ShR_to_ShM++;
+      goto changed;
+   }
+
+   /* Shared-Modified */
+   else if (is_SHVAL_ShM(wold)) {
+      /* write Shared-Modified(threadset, lockset)
+         We remain in ShM state, but add this thread to the 
+         threadset and refine the lockset accordingly.
+         If the lockset becomes empty, complain. */
+      WordSetID tset_old = un_SHVAL_ShM_tset(wold);
+      WordSetID lset_old = un_SHVAL_ShM_lset(wold);
+      WordSetID tset_new = HG_(addToWS)( univ_tsets,
+                                         tset_old, (Word)thr_acc );
+      WordSetID lset_new = HG_(intersectWS)( 
+                              univ_lsets,
+                              lset_old, 
+                              thr_acc->locksetW 
+                              /* write ==> use only w-held locks */
+                           ); 
+      /*UInt*/  wnew     = mk_SHVAL_ShM( tset_new, lset_new );
+      if (lset_old != lset_new)
+         record_last_lock_lossage(a,lset_old,lset_new);
+      if (HG_(isEmptyWS)(univ_lsets, lset_new)
+          && !HG_(isEmptyWS)(univ_lsets, lset_old)) {
+         record_error_Race( thr_acc, a, 
+                            True/*isWrite*/, szB, wold, wnew,
+                            maybe_get_lastlock_initpoint(a) );
+      }
+      stats__msm_write_ShM_to_ShM++;
+      goto changed;
+   }
+
+   /* NoAccess */
+   if (is_SHVAL_NoAccess(wold)) {
+      // FIXME: complain if accessing here
+      // FIXME: transition to Excl?
+      if (0)
+      VG_(printf)(
+         "msm__handle_write_aligned_32(thr=%p, addr=%p): NoAccess\n",
+         thr_acc, (void*)a );
+      stats__msm_write_NoAccess++;
+      /*NOCHANGE*/return wold;
+   } 
+
+   /* hmm, bogus state */
+   VG_(printf)("msm__handle_write_aligned_32: bogus old state 0x%x\n", 
+               wold);
+   tl_assert(0);
+
+  changed:
+   if (UNLIKELY(clo_trace_level > 0)) {
+      if (a <= clo_trace_addr && clo_trace_addr < a+szB
+          && wold != wnew) {
+         msm__show_state_change( thr_acc, a, szB, 'w', wold, wnew );
+      }
+   }
+   return wnew;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Shadow value and address range handlers                  ---*/
+/*----------------------------------------------------------------*/
+
+static void laog__pre_thread_acquires_lock ( Thread*, Lock* ); /* fwds */
+static void laog__handle_lock_deletions    ( WordSetID ); /* fwds */
+static inline Thread* get_current_Thread ( void ); /* fwds */
+
+/* ------------ CacheLineF and CacheLineZ related ------------ */
+
+static void write_twobit_array ( UChar* arr, UWord ix, UWord b2 ) {
+   Word bix, shft, mask, prep;
+   tl_assert((b2 & ~3) == 0);
+   tl_assert(ix >= 0);
+   bix  = ix >> 2;
+   shft = 2 * (ix & 3); /* 0, 2, 4 or 6 */
+   mask = 3 << shft;
+   prep = b2 << shft;
+   arr[bix] = (arr[bix] & ~mask) | prep;
+}
+
+static UWord read_twobit_array ( UChar* arr, UWord ix ) {
+   Word bix, shft;
+   tl_assert(ix >= 0);
+   bix  = ix >> 2;
+   shft = 2 * (ix & 3); /* 0, 2, 4 or 6 */
+   return (arr[bix] >> shft) & 3;
+}
+
+/* Given a lineZ index and a SecMap, return the CacheLineZ* and CacheLineF*
+   for that index. */
+static void get_ZF_by_index ( /*OUT*/CacheLineZ** zp,
+                              /*OUT*/CacheLineF** fp,
+                              SecMap* sm, Int zix ) {
+   CacheLineZ* lineZ;
+   tl_assert(zp);
+   tl_assert(fp);
+   tl_assert(zix >= 0 && zix < N_SECMAP_ZLINES);
+   tl_assert(is_sane_SecMap(sm));
+   lineZ = &sm->linesZ[zix];
+   if (lineZ->dict[0] == 0) {
+      Int fix = lineZ->dict[1];
+      tl_assert(sm->linesF);
+      tl_assert(sm->linesF_size > 0);
+      tl_assert(fix >= 0 && fix < sm->linesF_size);
+      *zp = NULL;
+      *fp = &sm->linesF[fix];
+      tl_assert(sm->linesF[fix].inUse);
+   } else {
+      *zp = lineZ;
+      *fp = NULL;
+   }
+}
+
+static void find_ZF_for_reading ( /*OUT*/CacheLineZ** zp,
+                                  /*OUT*/CacheLineF** fp, Addr tag ) {
+   CacheLineZ* lineZ;
+   CacheLineF* lineF;
+   UWord   zix;
+   SecMap* sm    = shmem__find_or_alloc_SecMap(tag);
+   UWord   smoff = shmem__get_SecMap_offset(tag);
+   /* since smoff is derived from a valid tag, it should be
+      cacheline-aligned. */
+   tl_assert(0 == (smoff & (N_LINE_ARANGE - 1)));
+   zix = smoff >> N_LINE_BITS;
+   tl_assert(zix < N_SECMAP_ZLINES);
+   lineZ = &sm->linesZ[zix];
+   lineF = NULL;
+   if (lineZ->dict[0] == 0) {
+      Word fix = lineZ->dict[1];
+      tl_assert(sm->linesF);
+      tl_assert(sm->linesF_size > 0);
+      tl_assert(fix >= 0 && fix < sm->linesF_size);
+      lineF = &sm->linesF[fix];
+      tl_assert(lineF->inUse);
+      lineZ = NULL;
+   }
+   *zp = lineZ;
+   *fp = lineF;
+}
+
+static void find_Z_for_writing ( /*OUT*/SecMap** smp,
+                                 /*OUT*/Word* zixp,
+                                 Addr tag ) {
+   CacheLineZ* lineZ;
+   CacheLineF* lineF;
+   UWord   zix;
+   SecMap* sm    = shmem__find_or_alloc_SecMap(tag);
+   UWord   smoff = shmem__get_SecMap_offset(tag);
+   /* since smoff is derived from a valid tag, it should be
+      cacheline-aligned. */
+   tl_assert(0 == (smoff & (N_LINE_ARANGE - 1)));
+   zix = smoff >> N_LINE_BITS;
+   tl_assert(zix < N_SECMAP_ZLINES);
+   lineZ = &sm->linesZ[zix];
+   lineF = NULL;
+   /* If lineZ has an associated lineF, free it up. */
+   if (lineZ->dict[0] == 0) {
+      Word fix = lineZ->dict[1];
+      tl_assert(sm->linesF);
+      tl_assert(sm->linesF_size > 0);
+      tl_assert(fix >= 0 && fix < sm->linesF_size);
+      lineF = &sm->linesF[fix];
+      tl_assert(lineF->inUse);
+      lineF->inUse = False;
+   }
+   *smp  = sm;
+   *zixp = zix;
+}
+
+static 
+void alloc_F_for_writing ( /*MOD*/SecMap* sm, /*OUT*/Word* fixp ) {
+   Word        i, new_size;
+   CacheLineF* nyu;
+
+   if (sm->linesF) {
+      tl_assert(sm->linesF_size > 0);
+   } else {
+      tl_assert(sm->linesF_size == 0);
+   }
+
+   if (sm->linesF) {
+      for (i = 0; i < sm->linesF_size; i++) {
+         if (!sm->linesF[i].inUse) {
+            *fixp = (Word)i;
+            return;
+         }
+      }
+   }
+
+   /* No free F line found.  Expand existing array and try again. */
+   new_size = sm->linesF_size==0 ? 1 : 2 * sm->linesF_size;
+   nyu      = hg_zalloc( new_size * sizeof(CacheLineF) );
+   tl_assert(nyu);
+
+   stats__secmap_linesF_allocd += (new_size - sm->linesF_size);
+   stats__secmap_linesF_bytes  += (new_size - sm->linesF_size)
+                                  * sizeof(CacheLineF);
+
+   if (0)
+   VG_(printf)("SM %p: expand F array from %d to %d\n", 
+               sm, (Int)sm->linesF_size, new_size);
+
+   for (i = 0; i < new_size; i++)
+      nyu[i].inUse = False;
+
+   if (sm->linesF) {
+      for (i = 0; i < sm->linesF_size; i++) {
+         tl_assert(sm->linesF[i].inUse);
+         nyu[i] = sm->linesF[i];
+      }
+      VG_(memset)(sm->linesF, 0, sm->linesF_size * sizeof(CacheLineF) );
+      hg_free(sm->linesF);
+   }
+
+   sm->linesF      = nyu;
+   sm->linesF_size = new_size;
+
+   for (i = 0; i < sm->linesF_size; i++) {
+      if (!sm->linesF[i].inUse) {
+         *fixp = (Word)i;
+         return;
+      }
+    }
+
+    /*NOTREACHED*/
+    tl_assert(0);
+}
+
+
+/* ------------ CacheLine and implicit-tree related ------------ */
+
+__attribute__((unused))
+static void pp_CacheLine ( CacheLine* cl ) {
+   Word i;
+   if (!cl) {
+      VG_(printf)("pp_CacheLine(NULL)\n");
+      return;
+   }
+   for (i = 0; i < N_LINE_TREES; i++) 
+      VG_(printf)("   descr: %04lx\n", (UWord)cl->descrs[i]);
+   for (i = 0; i < N_LINE_ARANGE; i++) 
+      VG_(printf)("    sval: %08lx\n", (UWord)cl->svals[i]);
+}
+
+static UChar descr_to_validbits ( UShort descr )
+{
+   /* a.k.a Party Time for gcc's constant folder */
+#  define DESCR(b8_7, b8_6, b8_5, b8_4, b8_3, b8_2, b8_1, b8_0, \
+                b16_3, b32_1, b16_2, b64, b16_1, b32_0, b16_0)  \
+             ( (UShort) ( ( (b8_7)  << 14) | ( (b8_6)  << 13) | \
+                          ( (b8_5)  << 12) | ( (b8_4)  << 11) | \
+                          ( (b8_3)  << 10) | ( (b8_2)  << 9)  | \
+                          ( (b8_1)  << 8)  | ( (b8_0)  << 7)  | \
+                          ( (b16_3) << 6)  | ( (b32_1) << 5)  | \
+                          ( (b16_2) << 4)  | ( (b64)   << 3)  | \
+                          ( (b16_1) << 2)  | ( (b32_0) << 1)  | \
+                          ( (b16_0) << 0) ) )
+
+#  define BYTE(bit7, bit6, bit5, bit4, bit3, bit2, bit1, bit0) \
+             ( (UChar) ( ( (bit7) << 7) | ( (bit6) << 6) | \
+                         ( (bit5) << 5) | ( (bit4) << 4) | \
+                         ( (bit3) << 3) | ( (bit2) << 2) | \
+                         ( (bit1) << 1) | ( (bit0) << 0) ) )
+
+   /* these should all get folded out at compile time */
+   tl_assert(DESCR(1,0,0,0,0,0,0,0, 0,0,0, 0, 0,0,0) == TREE_DESCR_8_7);
+   tl_assert(DESCR(0,0,0,0,0,0,0,1, 0,0,0, 0, 0,0,0) == TREE_DESCR_8_0);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 1,0,0, 0, 0,0,0) == TREE_DESCR_16_3);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 0,0,0) == TREE_DESCR_32_1);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,1, 0, 0,0,0) == TREE_DESCR_16_2);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 1, 0,0,0) == TREE_DESCR_64);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 1,0,0) == TREE_DESCR_16_1);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 0,1,0) == TREE_DESCR_32_0);
+   tl_assert(DESCR(0,0,0,0,0,0,0,0, 0,0,0, 0, 0,0,1) == TREE_DESCR_16_0);
+
+   switch (descr) {
+   /*
+              +--------------------------------- TREE_DESCR_8_7
+              |             +------------------- TREE_DESCR_8_0
+              |             |  +---------------- TREE_DESCR_16_3
+              |             |  | +-------------- TREE_DESCR_32_1
+              |             |  | | +------------ TREE_DESCR_16_2
+              |             |  | | |  +--------- TREE_DESCR_64
+              |             |  | | |  |  +------ TREE_DESCR_16_1
+              |             |  | | |  |  | +---- TREE_DESCR_32_0
+              |             |  | | |  |  | | +-- TREE_DESCR_16_0
+              |             |  | | |  |  | | |
+              |             |  | | |  |  | | |   GRANULARITY, 7 -> 0 */
+   case DESCR(1,1,1,1,1,1,1,1, 0,0,0, 0, 0,0,0): /* 8 8 8 8  8 8 8 8 */
+                                                 return BYTE(1,1,1,1,1,1,1,1);
+   case DESCR(1,1,0,0,1,1,1,1, 0,0,1, 0, 0,0,0): /* 8 8 16   8 8 8 8 */
+                                                 return BYTE(1,1,0,1,1,1,1,1);
+   case DESCR(0,0,1,1,1,1,1,1, 1,0,0, 0, 0,0,0): /* 16  8 8  8 8 8 8 */ 
+                                                 return BYTE(0,1,1,1,1,1,1,1);
+   case DESCR(0,0,0,0,1,1,1,1, 1,0,1, 0, 0,0,0): /* 16  16   8 8 8 8 */
+                                                 return BYTE(0,1,0,1,1,1,1,1);
+
+   case DESCR(1,1,1,1,1,1,0,0, 0,0,0, 0, 0,0,1): /* 8 8 8 8  8 8 16 */ 
+                                                 return BYTE(1,1,1,1,1,1,0,1);
+   case DESCR(1,1,0,0,1,1,0,0, 0,0,1, 0, 0,0,1): /* 8 8 16   8 8 16 */
+                                                 return BYTE(1,1,0,1,1,1,0,1);
+   case DESCR(0,0,1,1,1,1,0,0, 1,0,0, 0, 0,0,1): /* 16  8 8  8 8 16 */
+                                                 return BYTE(0,1,1,1,1,1,0,1);
+   case DESCR(0,0,0,0,1,1,0,0, 1,0,1, 0, 0,0,1): /* 16  16   8 8 16 */
+                                                 return BYTE(0,1,0,1,1,1,0,1);
+
+   case DESCR(1,1,1,1,0,0,1,1, 0,0,0, 0, 1,0,0): /* 8 8 8 8  16 8 8 */
+                                                 return BYTE(1,1,1,1,0,1,1,1);
+   case DESCR(1,1,0,0,0,0,1,1, 0,0,1, 0, 1,0,0): /* 8 8 16   16 8 8 */
+                                                 return BYTE(1,1,0,1,0,1,1,1);
+   case DESCR(0,0,1,1,0,0,1,1, 1,0,0, 0, 1,0,0): /* 16  8 8  16 8 8 */
+                                                 return BYTE(0,1,1,1,0,1,1,1);
+   case DESCR(0,0,0,0,0,0,1,1, 1,0,1, 0, 1,0,0): /* 16  16   16 8 8 */
+                                                 return BYTE(0,1,0,1,0,1,1,1);
+
+   case DESCR(1,1,1,1,0,0,0,0, 0,0,0, 0, 1,0,1): /* 8 8 8 8  16 16 */
+                                                 return BYTE(1,1,1,1,0,1,0,1);
+   case DESCR(1,1,0,0,0,0,0,0, 0,0,1, 0, 1,0,1): /* 8 8 16   16 16 */
+                                                 return BYTE(1,1,0,1,0,1,0,1);
+   case DESCR(0,0,1,1,0,0,0,0, 1,0,0, 0, 1,0,1): /* 16  8 8  16 16 */
+                                                 return BYTE(0,1,1,1,0,1,0,1);
+   case DESCR(0,0,0,0,0,0,0,0, 1,0,1, 0, 1,0,1): /* 16  16   16 16 */
+                                                 return BYTE(0,1,0,1,0,1,0,1);
+
+   case DESCR(0,0,0,0,1,1,1,1, 0,1,0, 0, 0,0,0): /* 32  8 8 8 8 */
+                                                 return BYTE(0,0,0,1,1,1,1,1);
+   case DESCR(0,0,0,0,1,1,0,0, 0,1,0, 0, 0,0,1): /* 32  8 8 16  */
+                                                 return BYTE(0,0,0,1,1,1,0,1);
+   case DESCR(0,0,0,0,0,0,1,1, 0,1,0, 0, 1,0,0): /* 32  16  8 8 */
+                                                 return BYTE(0,0,0,1,0,1,1,1);
+   case DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 1,0,1): /* 32  16  16  */
+                                                 return BYTE(0,0,0,1,0,1,0,1);
+
+   case DESCR(1,1,1,1,0,0,0,0, 0,0,0, 0, 0,1,0): /* 8 8 8 8  32 */
+                                                 return BYTE(1,1,1,1,0,0,0,1);
+   case DESCR(1,1,0,0,0,0,0,0, 0,0,1, 0, 0,1,0): /* 8 8 16   32 */
+                                                 return BYTE(1,1,0,1,0,0,0,1);
+   case DESCR(0,0,1,1,0,0,0,0, 1,0,0, 0, 0,1,0): /* 16  8 8  32 */
+                                                 return BYTE(0,1,1,1,0,0,0,1);
+   case DESCR(0,0,0,0,0,0,0,0, 1,0,1, 0, 0,1,0): /* 16  16   32 */
+                                                 return BYTE(0,1,0,1,0,0,0,1);
+
+   case DESCR(0,0,0,0,0,0,0,0, 0,1,0, 0, 0,1,0): /* 32 32 */
+                                                 return BYTE(0,0,0,1,0,0,0,1);
+
+   case DESCR(0,0,0,0,0,0,0,0, 0,0,0, 1, 0,0,0): /* 64 */
+                                                 return BYTE(0,0,0,0,0,0,0,1);
+
+   default: return BYTE(0,0,0,0,0,0,0,0); 
+                   /* INVALID - any valid descr produces at least one
+                      valid bit in tree[0..7]*/
+   }
+   /* NOTREACHED*/
+   tl_assert(0);
+
+#  undef DESCR
+#  undef BYTE
+}
+
+__attribute__((unused))
+static Bool is_sane_Descr ( UShort descr ) {
+   return descr_to_validbits(descr) != 0;
+}
+
+static void sprintf_Descr ( /*OUT*/UChar* dst, UShort descr ) {
+   VG_(sprintf)(dst, 
+                "%d%d%d%d%d%d%d%d %d%d%d %d %d%d%d",
+                (Int)((descr & TREE_DESCR_8_7) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_6) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_5) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_4) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_3) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_2) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_1) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_8_0) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_16_3) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_32_1) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_16_2) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_64)   ? 1 : 0),
+                (Int)((descr & TREE_DESCR_16_1) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_32_0) ? 1 : 0),
+                (Int)((descr & TREE_DESCR_16_0) ? 1 : 0)
+   );
+}
+static void sprintf_Byte ( /*OUT*/UChar* dst, UChar byte ) {
+   VG_(sprintf)(dst, "%d%d%d%d%d%d%d%d",
+                     (Int)((byte & 128) ? 1 : 0),
+                     (Int)((byte &  64) ? 1 : 0),
+                     (Int)((byte &  32) ? 1 : 0),
+                     (Int)((byte &  16) ? 1 : 0),
+                     (Int)((byte &   8) ? 1 : 0),
+                     (Int)((byte &   4) ? 1 : 0),
+                     (Int)((byte &   2) ? 1 : 0),
+                     (Int)((byte &   1) ? 1 : 0)
+   );
+}
+
+static Bool is_sane_Descr_and_Tree ( UShort descr, UInt* tree ) {
+   Word  i;
+   UChar validbits = descr_to_validbits(descr);
+   UChar buf[128], buf2[128];
+   if (validbits == 0)
+      goto bad;
+   for (i = 0; i < 8; i++) {
+      if (validbits & (1<<i)) {
+         if (!is_SHVAL_valid(tree[i]))
+            goto bad;
+      } else {
+         if (tree[i] != 0)
+            goto bad;
+      }
+   }
+   return True;
+  bad:
+   sprintf_Descr( buf, descr );
+   sprintf_Byte( buf2, validbits );
+   VG_(printf)("is_sane_Descr_and_Tree: bad tree {\n");
+   VG_(printf)("   validbits 0x%02lx    %s\n", (UWord)validbits, buf2);
+   VG_(printf)("       descr 0x%04lx  %s\n", (UWord)descr, buf);
+   for (i = 0; i < 8; i++)
+      VG_(printf)("   [%ld] 0x%08x\n", i, tree[i]);
+   VG_(printf)("}\n");
+   return 0;
+}
+
+
+static Bool is_sane_CacheLine ( CacheLine* cl )
+{
+   Word tno, cloff;
+
+   if (!cl) goto bad;
+
+   for (tno = 0, cloff = 0;  tno < N_LINE_TREES;  tno++, cloff += 8) {
+      UShort descr = cl->descrs[tno];
+      UInt*  tree  = &cl->svals[cloff];
+      if (!is_sane_Descr_and_Tree(descr, tree))
+         goto bad;
+   }
+   tl_assert(cloff == N_LINE_ARANGE);
+   return True;
+  bad:
+   pp_CacheLine(cl);
+   return False;
+}
+
+
+static UShort normalise_tree ( /*MOD*/UInt* tree ) {
+   Word   i;
+   UShort descr;
+   /* pre: incoming tree[0..7] does not have any invalid shvals, in
+      particular no zeroes. */
+   for (i = 0; i < 8; i++)
+      tl_assert(tree[i] != 0);
+   
+   descr = TREE_DESCR_8_7 | TREE_DESCR_8_6 | TREE_DESCR_8_5
+           | TREE_DESCR_8_4 | TREE_DESCR_8_3 | TREE_DESCR_8_2
+           | TREE_DESCR_8_1 | TREE_DESCR_8_0;
+   /* build 16-bit layer */
+   if (tree[1] == tree[0]) {
+      tree[1] = 0/*INVALID*/;
+      descr &= ~(TREE_DESCR_8_1 | TREE_DESCR_8_0);
+      descr |= TREE_DESCR_16_0;
+   }
+   if (tree[3] == tree[2]) {
+      tree[3] = 0/*INVALID*/;
+      descr &= ~(TREE_DESCR_8_3 | TREE_DESCR_8_2);
+      descr |= TREE_DESCR_16_1;
+   }
+   if (tree[5] == tree[4]) {
+      tree[5] = 0/*INVALID*/;
+      descr &= ~(TREE_DESCR_8_5 | TREE_DESCR_8_4);
+      descr |= TREE_DESCR_16_2;
+   }
+   if (tree[7] == tree[6]) {
+      tree[7] = 0/*INVALID*/;
+      descr &= ~(TREE_DESCR_8_7 | TREE_DESCR_8_6);
+      descr |= TREE_DESCR_16_3;
+   }
+   /* build 32-bit layer */
+   if (tree[2] == tree[0]
+       && (descr & TREE_DESCR_16_1) && (descr & TREE_DESCR_16_0)) {
+      tree[2] = 0; /* [3,1] must already be 0 */
+      descr &= ~(TREE_DESCR_16_1 | TREE_DESCR_16_0);
+      descr |= TREE_DESCR_32_0;
+   }
+   if (tree[6] == tree[4]
+       && (descr & TREE_DESCR_16_3) && (descr & TREE_DESCR_16_2)) {
+      tree[6] = 0; /* [7,5] must already be 0 */
+      descr &= ~(TREE_DESCR_16_3 | TREE_DESCR_16_2);
+      descr |= TREE_DESCR_32_1;
+   }
+   /* build 64-bit layer */
+   if (tree[4] == tree[0]
+       && (descr & TREE_DESCR_32_1) && (descr & TREE_DESCR_32_0)) {
+      tree[4] = 0; /* [7,6,5,3,2,1] must already be 0 */
+      descr &= ~(TREE_DESCR_32_1 | TREE_DESCR_32_0);
+      descr |= TREE_DESCR_64;
+   }
+   return descr;
+}
+
+/* This takes a cacheline where all the data is at the leaves
+   (w8[..]) and builds a correctly normalised tree. */
+static void normalise_CacheLine ( /*MOD*/CacheLine* cl )
+{
+   Word tno, cloff;
+   for (tno = 0, cloff = 0;  tno < N_LINE_TREES;  tno++, cloff += 8) {
+      UInt* tree = &cl->svals[cloff];
+      cl->descrs[tno] = normalise_tree( tree );
+   }
+   tl_assert(cloff == N_LINE_ARANGE);
+   if (SCE_CACHELINE)
+      tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   stats__cline_normalises++;
+}
+
+
+static 
+UInt* sequentialise_tree ( /*MOD*/UInt* dst, /*OUT*/Bool* anyShared,
+                           UShort descr, UInt* tree ) {
+   UInt* dst0 = dst;
+   *anyShared = False;
+
+#  define PUT(_n,_v)                                \
+      do { Word i;                                  \
+           if (is_SHVAL_Sh(_v))                     \
+              *anyShared = True;                    \
+           for (i = 0; i < (_n); i++)               \
+                  *dst++ = (_v);                    \
+      } while (0)
+
+   /* byte 0 */
+   if (descr & TREE_DESCR_64)   PUT(8, tree[0]); else
+   if (descr & TREE_DESCR_32_0) PUT(4, tree[0]); else
+   if (descr & TREE_DESCR_16_0) PUT(2, tree[0]); else
+   if (descr & TREE_DESCR_8_0)  PUT(1, tree[0]);
+   /* byte 1 */
+   if (descr & TREE_DESCR_8_1)  PUT(1, tree[1]);
+   /* byte 2 */
+   if (descr & TREE_DESCR_16_1) PUT(2, tree[2]); else
+   if (descr & TREE_DESCR_8_2)  PUT(1, tree[2]);
+   /* byte 3 */
+   if (descr & TREE_DESCR_8_3)  PUT(1, tree[3]);
+   /* byte 4 */
+   if (descr & TREE_DESCR_32_1) PUT(4, tree[4]); else
+   if (descr & TREE_DESCR_16_2) PUT(2, tree[4]); else
+   if (descr & TREE_DESCR_8_4)  PUT(1, tree[4]);
+   /* byte 5 */
+   if (descr & TREE_DESCR_8_5)  PUT(1, tree[5]);
+   /* byte 6 */
+   if (descr & TREE_DESCR_16_3) PUT(2, tree[6]); else
+   if (descr & TREE_DESCR_8_6)  PUT(1, tree[6]);
+   /* byte 7 */
+   if (descr & TREE_DESCR_8_7)  PUT(1, tree[7]);
+
+#  undef PUT
+
+   tl_assert( (((Char*)dst) - ((Char*)dst0)) == 8 * sizeof(UInt) );
+   return dst;
+}
+
+/* Write the cacheline 'wix' to backing store.  Where it ends up
+   is determined by its tag field. */
+static
+Bool sequentialise_CacheLine ( /*OUT*/UInt* dst, Word nDst, CacheLine* src )
+{
+   Word  tno, cloff;
+   Bool  anyShared = False;
+   UInt* dst0      = dst;
+
+   for (tno = 0, cloff = 0;  tno < N_LINE_TREES;  tno++, cloff += 8) {
+      UShort descr = src->descrs[tno];
+      UInt*  tree  = &src->svals[cloff];
+      Bool   bTmp  = False;
+      dst = sequentialise_tree ( dst, &bTmp, descr, tree );
+      anyShared |= bTmp;
+   }
+   tl_assert(cloff == N_LINE_ARANGE);
+
+   /* Assert we wrote N_LINE_ARANGE shadow values. */
+   tl_assert( ((HChar*)dst) - ((HChar*)dst0) 
+              == nDst * sizeof(UInt) );
+
+   return anyShared;
+}
+
+
+static __attribute__((noinline)) void cacheline_wback ( UWord wix )
+{
+   Word        i, j;
+   Bool        anyShared = False;
+   Addr        tag;
+   SecMap*     sm;
+   CacheLine*  cl;
+   CacheLineZ* lineZ;
+   CacheLineF* lineF;
+   Word        zix, fix;
+   UInt        shvals[N_LINE_ARANGE];
+   UInt        sv;
+
+   if (0)
+   VG_(printf)("scache wback line %d\n", (Int)wix);
+
+   tl_assert(wix >= 0 && wix < N_WAY_NENT);
+
+   tag =  cache_shmem.tags0[wix];
+   cl  = &cache_shmem.lyns0[wix];
+
+   /* The cache line may have been invalidated; if so, ignore it. */
+   if (!is_valid_scache_tag(tag))
+      return;
+
+   /* Where are we going to put it? */
+   sm         = NULL;
+   lineZ      = NULL;
+   lineF      = NULL;
+   zix = fix = -1;
+
+   find_Z_for_writing( &sm, &zix, tag );
+   tl_assert(sm);
+   tl_assert(zix >= 0 && zix < N_SECMAP_ZLINES);
+   lineZ = &sm->linesZ[zix];
+
+   /* Generate the data to be stored */
+   if (SCE_CACHELINE)
+      tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   anyShared = sequentialise_CacheLine( shvals, N_LINE_ARANGE, cl );
+
+   lineZ->dict[0] = lineZ->dict[1] 
+                  = lineZ->dict[2] = lineZ->dict[3] = 0;
+
+   for (i = 0; i < N_LINE_ARANGE; i++) {
+
+      sv = shvals[i];
+      for (j = 0; j < 4; j++) {
+         if (sv == lineZ->dict[j])
+            goto dict_ok;
+      }
+      for (j = 0; j < 4; j++) {
+         if (lineZ->dict[j] == 0)
+            break;
+      }
+      tl_assert(j >= 0 && j <= 4);
+      if (j == 4) break; /* we'll have to use the f rep */
+      tl_assert(is_SHVAL_valid(sv));
+      lineZ->dict[j] = sv;
+     dict_ok:
+      write_twobit_array( lineZ->ix2s, i, j );
+
+   }
+
+   tl_assert(i >= 0 && i <= N_LINE_ARANGE);
+
+   if (i < N_LINE_ARANGE) {
+      /* cannot use the compressed rep.  Use f rep instead. */
+      alloc_F_for_writing( sm, &fix );
+      tl_assert(sm->linesF);
+      tl_assert(sm->linesF_size > 0);
+      tl_assert(fix >= 0 && fix < sm->linesF_size);
+      lineF = &sm->linesF[fix];
+      tl_assert(!lineF->inUse);
+      lineZ->dict[0] = lineZ->dict[2] = lineZ->dict[3] = 0;
+      lineZ->dict[1] = (UInt)fix;
+      lineF->inUse = True;
+      for (i = 0; i < N_LINE_ARANGE; i++) {
+         sv = shvals[i];
+         tl_assert(is_SHVAL_valid(sv));
+         lineF->w32s[i] = sv;
+      }
+      stats__cache_F_wbacks++;
+   } else {
+      stats__cache_Z_wbacks++;
+   }
+
+   if (anyShared)
+      sm->mbHasShared = True;
+
+   /* mb_tidy_one_cacheline(); */
+}
+
+/* Fetch the cacheline 'wix' from the backing store.  The tag
+   associated with 'wix' is assumed to have already been filled in;
+   hence that is used to determine where in the backing store to read
+   from. */
+static __attribute__((noinline)) void cacheline_fetch ( UWord wix )
+{
+   Word        i;
+   Addr        tag;
+   CacheLine*  cl;
+   CacheLineZ* lineZ;
+   CacheLineF* lineF;
+
+   if (0)
+   VG_(printf)("scache fetch line %d\n", (Int)wix);
+
+   tl_assert(wix >= 0 && wix < N_WAY_NENT);
+
+   tag =  cache_shmem.tags0[wix];
+   cl  = &cache_shmem.lyns0[wix];
+
+   /* reject nonsense requests */
+   tl_assert(is_valid_scache_tag(tag));
+
+   lineZ = NULL;
+   lineF = NULL;
+   find_ZF_for_reading( &lineZ, &lineF, tag );
+   tl_assert( (lineZ && !lineF) || (!lineZ && lineF) );
+
+   /* expand the data into the bottom layer of the tree, then get
+      cacheline_normalise to build the descriptor array. */
+   if (lineF) {
+      tl_assert(lineF->inUse);
+      for (i = 0; i < N_LINE_ARANGE; i++) {
+         cl->svals[i] = lineF->w32s[i];
+      }
+      stats__cache_F_fetches++;
+   } else {
+      for (i = 0; i < N_LINE_ARANGE; i++) {
+         UInt sv;
+         UWord ix = read_twobit_array( lineZ->ix2s, i );
+         tl_assert(ix >= 0 && ix <= 3);
+         sv = lineZ->dict[ix];
+         tl_assert(sv != 0);
+         cl->svals[i] = sv;
+      }
+      stats__cache_Z_fetches++;
+   }
+   normalise_CacheLine( cl );
+}
+
+static void shmem__invalidate_scache ( void ) {
+   Word wix;
+   if (0) VG_(printf)("scache inval\n");
+   tl_assert(!is_valid_scache_tag(1));
+   for (wix = 0; wix < N_WAY_NENT; wix++) {
+      cache_shmem.tags0[wix] = 1/*INVALID*/;
+   }
+   stats__cache_invals++;
+}
+
+static void shmem__flush_and_invalidate_scache ( void ) {
+   Word wix;
+   Addr tag;
+   if (0) VG_(printf)("scache flush and invalidate\n");
+   tl_assert(!is_valid_scache_tag(1));
+   for (wix = 0; wix < N_WAY_NENT; wix++) {
+      tag = cache_shmem.tags0[wix];
+      if (tag == 1/*INVALID*/) {
+         /* already invalid; nothing to do */
+      } else {
+         tl_assert(is_valid_scache_tag(tag));
+         cacheline_wback( wix );
+      }
+      cache_shmem.tags0[wix] = 1/*INVALID*/;
+   }
+   stats__cache_flushes++;
+   stats__cache_invals++;
+}
+
+
+/* ------------ Basic shadow memory read/write ops ------------ */
+
+static inline Bool aligned16 ( Addr a ) {
+   return 0 == (a & 1);
+}
+static inline Bool aligned32 ( Addr a ) {
+   return 0 == (a & 3);
+}
+static inline Bool aligned64 ( Addr a ) {
+   return 0 == (a & 7);
+}
+static inline UWord get_cacheline_offset ( Addr a ) {
+   return (UWord)(a & (N_LINE_ARANGE - 1));
+}
+static inline UWord get_treeno ( Addr a ) {
+   return get_cacheline_offset(a) >> 3;
+}
+static inline UWord get_tree_offset ( Addr a ) {
+   return a & 7;
+}
+
+static __attribute__((noinline))
+       CacheLine* get_cacheline_MISS ( Addr a ); /* fwds */
+static inline CacheLine* get_cacheline ( Addr a )
+{
+   /* tag is 'a' with the in-line offset masked out, 
+      eg a[31]..a[4] 0000 */
+   Addr       tag = a & ~(N_LINE_ARANGE - 1);
+   UWord      wix = (a >> N_LINE_BITS) & (N_WAY_NENT - 1);
+   stats__cache_totrefs++;
+   if (LIKELY(tag == cache_shmem.tags0[wix])) {
+      return &cache_shmem.lyns0[wix];
+   } else {
+      return get_cacheline_MISS( a );
+   }
+}
+
+static __attribute__((noinline))
+       CacheLine* get_cacheline_MISS ( Addr a )
+{
+   /* tag is 'a' with the in-line offset masked out, 
+      eg a[31]..a[4] 0000 */
+
+   CacheLine* cl;
+   Addr*      tag_old_p;
+   Addr       tag = a & ~(N_LINE_ARANGE - 1);
+   UWord      wix = (a >> N_LINE_BITS) & (N_WAY_NENT - 1);
+
+   tl_assert(tag != cache_shmem.tags0[wix]);
+
+   /* Dump the old line into the backing store. */
+   stats__cache_totmisses++;
+
+   cl        = &cache_shmem.lyns0[wix];
+   tag_old_p = &cache_shmem.tags0[wix];
+
+   if (is_valid_scache_tag( *tag_old_p )) {
+      /* EXPENSIVE and REDUNDANT: callee does it */
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+      cacheline_wback( wix );
+   }
+   /* and reload the new one */
+   *tag_old_p = tag;
+   cacheline_fetch( wix );
+   if (SCE_CACHELINE)
+      tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   return cl;
+}
+
+static UShort pulldown_to_32 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+   stats__cline_64to32pulldown++;
+   switch (toff) {
+      case 0: case 4:
+         tl_assert(descr & TREE_DESCR_64);
+         tree[4] = tree[0];
+         descr &= ~TREE_DESCR_64;
+         descr |= (TREE_DESCR_32_1 | TREE_DESCR_32_0);
+         break;
+      default:
+         tl_assert(0);
+   }
+   return descr;
+}
+
+static UShort pulldown_to_16 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+   stats__cline_32to16pulldown++;
+   switch (toff) {
+      case 0: case 2:
+         if (!(descr & TREE_DESCR_32_0)) {
+            descr = pulldown_to_32(tree, 0, descr);
+         }
+         tl_assert(descr & TREE_DESCR_32_0);
+         tree[2] = tree[0];
+         descr &= ~TREE_DESCR_32_0;
+         descr |= (TREE_DESCR_16_1 | TREE_DESCR_16_0);
+         break;
+      case 4: case 6:
+         if (!(descr & TREE_DESCR_32_1)) {
+            descr = pulldown_to_32(tree, 4, descr);
+         }
+         tl_assert(descr & TREE_DESCR_32_1);
+         tree[6] = tree[4];
+         descr &= ~TREE_DESCR_32_1;
+         descr |= (TREE_DESCR_16_3 | TREE_DESCR_16_2);
+         break;
+      default:
+         tl_assert(0);
+   }
+   return descr;
+}
+
+static UShort pulldown_to_8 ( /*MOD*/UInt* tree, UWord toff, UShort descr ) {
+   stats__cline_16to8pulldown++;
+   switch (toff) {
+      case 0: case 1:
+         if (!(descr & TREE_DESCR_16_0)) {
+            descr = pulldown_to_16(tree, 0, descr);
+         }
+         tl_assert(descr & TREE_DESCR_16_0);
+         tree[1] = tree[0];
+         descr &= ~TREE_DESCR_16_0;
+         descr |= (TREE_DESCR_8_1 | TREE_DESCR_8_0);
+         break;
+      case 2: case 3:
+         if (!(descr & TREE_DESCR_16_1)) {
+            descr = pulldown_to_16(tree, 2, descr);
+         }
+         tl_assert(descr & TREE_DESCR_16_1);
+         tree[3] = tree[2];
+         descr &= ~TREE_DESCR_16_1;
+         descr |= (TREE_DESCR_8_3 | TREE_DESCR_8_2);
+         break;
+      case 4: case 5:
+         if (!(descr & TREE_DESCR_16_2)) {
+            descr = pulldown_to_16(tree, 4, descr);
+         }
+         tl_assert(descr & TREE_DESCR_16_2);
+         tree[5] = tree[4];
+         descr &= ~TREE_DESCR_16_2;
+         descr |= (TREE_DESCR_8_5 | TREE_DESCR_8_4);
+         break;
+      case 6: case 7:
+         if (!(descr & TREE_DESCR_16_3)) {
+            descr = pulldown_to_16(tree, 6, descr);
+         }
+         tl_assert(descr & TREE_DESCR_16_3);
+         tree[7] = tree[6];
+         descr &= ~TREE_DESCR_16_3;
+         descr |= (TREE_DESCR_8_7 | TREE_DESCR_8_6);
+         break;
+      default:
+         tl_assert(0);
+   }
+   return descr;
+}
+
+
+static UShort pullup_descr_to_16 ( UShort descr, UWord toff ) {
+   UShort mask;
+   switch (toff) {
+      case 0:
+         mask = TREE_DESCR_8_1 | TREE_DESCR_8_0;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_16_0;
+         break;
+      case 2:
+         mask = TREE_DESCR_8_3 | TREE_DESCR_8_2;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_16_1;
+         break;
+      case 4:
+         mask = TREE_DESCR_8_5 | TREE_DESCR_8_4;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_16_2;
+         break;
+      case 6:
+         mask = TREE_DESCR_8_7 | TREE_DESCR_8_6;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_16_3;
+         break;
+      default:
+         tl_assert(0);
+   }
+   return descr;
+}
+
+static UShort pullup_descr_to_32 ( UShort descr, UWord toff ) {
+   UShort mask;
+   switch (toff) {
+      case 0:
+         if (!(descr & TREE_DESCR_16_0))
+            descr = pullup_descr_to_16(descr, 0);
+         if (!(descr & TREE_DESCR_16_1))
+            descr = pullup_descr_to_16(descr, 2);
+         mask = TREE_DESCR_16_1 | TREE_DESCR_16_0;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_32_0;
+         break;
+      case 4:
+         if (!(descr & TREE_DESCR_16_2))
+            descr = pullup_descr_to_16(descr, 4);
+         if (!(descr & TREE_DESCR_16_3))
+            descr = pullup_descr_to_16(descr, 6);
+         mask = TREE_DESCR_16_3 | TREE_DESCR_16_2;
+         tl_assert( (descr & mask) == mask );
+         descr &= ~mask;
+         descr |= TREE_DESCR_32_1;
+         break;
+      default:
+         tl_assert(0);
+   }
+   return descr;
+}
+
+static Bool valid_value_is_above_me_32 ( UShort descr, UWord toff ) {
+   switch (toff) {
+      case 0: case 4:
+         return 0 != (descr & TREE_DESCR_64);
+      default:
+         tl_assert(0);
+   }
+}
+
+static Bool valid_value_is_below_me_16 ( UShort descr, UWord toff ) {
+   switch (toff) {
+      case 0:
+         return 0 != (descr & (TREE_DESCR_8_1 | TREE_DESCR_8_0));
+      case 2:
+         return 0 != (descr & (TREE_DESCR_8_3 | TREE_DESCR_8_2));
+      case 4:
+         return 0 != (descr & (TREE_DESCR_8_5 | TREE_DESCR_8_4));
+      case 6:
+         return 0 != (descr & (TREE_DESCR_8_7 | TREE_DESCR_8_6));
+      default:
+         tl_assert(0);
+   }
+}
+
+static void shadow_mem_read8 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_read8s++;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 .. 7 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+      UInt* tree = &cl->svals[tno << 3];
+      cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_read( thr_acc, a, svOld, 1 );
+   cl->svals[cloff] = svNew;
+}
+static void shadow_mem_read16 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_read16s++;
+   if (UNLIKELY(!aligned16(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+      if (valid_value_is_below_me_16(descr, toff)) {
+         goto slowcase;
+      } else {
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+      }
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_read( thr_acc, a, svOld, 2 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_16to8splits++;
+   shadow_mem_read8( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_read8( thr_acc, a + 1, 0/*unused*/ );
+}
+
+__attribute__((noinline))
+static void shadow_mem_read32_SLOW ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   if (UNLIKELY(!aligned32(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 or 4 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+      if (valid_value_is_above_me_32(descr, toff)) {
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+      } else {
+         goto slowcase;
+      }
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_read( thr_acc, a, svOld, 4 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_32to16splits++;
+   shadow_mem_read16( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_read16( thr_acc, a + 2, 0/*unused*/ );
+}
+inline
+static void shadow_mem_read32 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_read32s++;
+   if (UNLIKELY(!aligned32(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 or 4 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) goto slowcase;
+   { UInt* p = &cl->svals[cloff];
+     *p = msm__handle_read( thr_acc, a, *p, 4 );
+   }
+   return;
+  slowcase: /* misaligned, or not at this level in the tree */
+   shadow_mem_read32_SLOW( thr_acc, a, uuOpaque );
+}
+
+inline
+static void shadow_mem_read64 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_read64s++;
+   if (UNLIKELY(!aligned64(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0, unused */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & TREE_DESCR_64) )) {
+      goto slowcase;
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_read( thr_acc, a, svOld, 8 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_64to32splits++;
+   shadow_mem_read32( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_read32( thr_acc, a + 4, 0/*unused*/ );
+}
+
+static void shadow_mem_write8 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_write8s++;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 .. 7 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+      UInt* tree = &cl->svals[tno << 3];
+      cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_write( thr_acc, a, svOld, 1 );
+   cl->svals[cloff] = svNew;
+}
+static void shadow_mem_write16 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_write16s++;
+   if (UNLIKELY(!aligned16(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+      if (valid_value_is_below_me_16(descr, toff)) {
+         goto slowcase;
+      } else {
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+      }
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_write( thr_acc, a, svOld, 2 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_16to8splits++;
+   shadow_mem_write8( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_write8( thr_acc, a + 1, 0/*unused*/ );
+}
+
+__attribute__((noinline))
+static void shadow_mem_write32_SLOW ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   if (UNLIKELY(!aligned32(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 or 4 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+      if (valid_value_is_above_me_32(descr, toff)) {
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+      } else {
+         goto slowcase;
+      }
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_write( thr_acc, a, svOld, 4 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_32to16splits++;
+   shadow_mem_write16( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_write16( thr_acc, a + 2, 0/*unused*/ );
+}
+inline
+static void shadow_mem_write32 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_write32s++;
+   if (UNLIKELY(!aligned32(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 or 4 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) goto slowcase;
+   { UInt* p = &cl->svals[cloff];
+     *p = msm__handle_write( thr_acc, a, *p, 4 );
+   }
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   shadow_mem_write32_SLOW( thr_acc, a, uuOpaque );
+}
+
+inline
+static void shadow_mem_write64 ( Thread* thr_acc, Addr a, UInt uuOpaque ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UInt       svOld, svNew;
+   UShort     descr;
+   stats__cline_write64s++;
+   if (UNLIKELY(!aligned64(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0, unused */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & TREE_DESCR_64) )) {
+      goto slowcase;
+   }
+   svOld = cl->svals[cloff];
+   svNew = msm__handle_write( thr_acc, a, svOld, 8 );
+   cl->svals[cloff] = svNew;
+   return;
+  slowcase: /* misaligned, or must go further down the tree */
+   stats__cline_64to32splits++;
+   shadow_mem_write32( thr_acc, a + 0, 0/*unused*/ );
+   shadow_mem_write32( thr_acc, a + 4, 0/*unused*/ );
+}
+
+static void shadow_mem_set8 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_set8s++;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 .. 7 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+      UInt* tree = &cl->svals[tno << 3];
+      cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+   }
+   cl->svals[cloff] = svNew;
+}
+static void shadow_mem_set16 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_set16s++;
+   if (UNLIKELY(!aligned16(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0, 2, 4 or 6 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_16_0 << toff)) )) {
+      if (valid_value_is_below_me_16(descr, toff)) {
+         /* Writing at this level.  Need to fix up 'descr'. */
+         cl->descrs[tno] = pullup_descr_to_16(descr, toff);
+         /* At this point, the tree does not match cl->descr[tno] any
+            more.  The assignments below will fix it up. */
+      } else {
+         /* We can't indiscriminately write on the w16 node as in the
+            w64 case, as that might make the node inconsistent with
+            its parent.  So first, pull down to this level. */
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_16(tree, toff, descr);
+      if (SCE_CACHELINE)
+         tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+      }
+   }
+   cl->svals[cloff + 0] = svNew;
+   cl->svals[cloff + 1] = 0;
+   return;
+  slowcase: /* misaligned */
+   stats__cline_16to8splits++;
+   shadow_mem_set8( uu_thr_acc, a + 0, svNew );
+   shadow_mem_set8( uu_thr_acc, a + 1, svNew );
+}
+static void shadow_mem_set32 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_set32s++;
+   if (UNLIKELY(!aligned32(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 or 4 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_32_0 << toff)) )) {
+      if (valid_value_is_above_me_32(descr, toff)) {
+         /* We can't indiscriminately write on the w32 node as in the
+            w64 case, as that might make the node inconsistent with
+            its parent.  So first, pull down to this level. */
+         UInt* tree = &cl->svals[tno << 3];
+         cl->descrs[tno] = pulldown_to_32(tree, toff, descr);
+         if (SCE_CACHELINE)
+            tl_assert(is_sane_CacheLine(cl)); /* EXPENSIVE */
+      } else {
+         /* Writing at this level.  Need to fix up 'descr'. */
+         cl->descrs[tno] = pullup_descr_to_32(descr, toff);
+         /* At this point, the tree does not match cl->descr[tno] any
+            more.  The assignments below will fix it up. */
+      }
+   }
+   cl->svals[cloff + 0] = svNew;
+   cl->svals[cloff + 1] = 0;
+   cl->svals[cloff + 2] = 0;
+   cl->svals[cloff + 3] = 0;
+   return;
+  slowcase: /* misaligned */
+   stats__cline_32to16splits++;
+   shadow_mem_set16( uu_thr_acc, a + 0, svNew );
+   shadow_mem_set16( uu_thr_acc, a + 2, svNew );
+}
+inline
+static void shadow_mem_set64 ( Thread* uu_thr_acc, Addr a, UInt svNew ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   stats__cline_set64s++;
+   if (UNLIKELY(!aligned64(a))) goto slowcase;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 */
+   cl->descrs[tno] = TREE_DESCR_64;
+   cl->svals[cloff + 0] = svNew;
+   cl->svals[cloff + 1] = 0;
+   cl->svals[cloff + 2] = 0;
+   cl->svals[cloff + 3] = 0;
+   cl->svals[cloff + 4] = 0;
+   cl->svals[cloff + 5] = 0;
+   cl->svals[cloff + 6] = 0;
+   cl->svals[cloff + 7] = 0;
+   return;
+  slowcase: /* misaligned */
+   stats__cline_64to32splits++;
+   shadow_mem_set32( uu_thr_acc, a + 0, svNew );
+   shadow_mem_set32( uu_thr_acc, a + 4, svNew );
+}
+
+static UInt shadow_mem_get8 ( Addr a ) {
+   CacheLine* cl; 
+   UWord      cloff, tno, toff;
+   UShort     descr;
+   stats__cline_get8s++;
+   cl    = get_cacheline(a);
+   cloff = get_cacheline_offset(a);
+   tno   = get_treeno(a);
+   toff  = get_tree_offset(a); /* == 0 .. 7 */
+   descr = cl->descrs[tno];
+   if (UNLIKELY( !(descr & (TREE_DESCR_8_0 << toff)) )) {
+      UInt* tree = &cl->svals[tno << 3];
+      cl->descrs[tno] = pulldown_to_8(tree, toff, descr);
+   }
+   return cl->svals[cloff];
+}
+
+static void shadow_mem_copy8 ( Addr src, Addr dst, Bool normalise ) {
+   UInt       sv;
+   stats__cline_copy8s++;
+   sv = shadow_mem_get8( src );
+
+   if (UNLIKELY(clo_trace_level > 0)) {
+      if (dst == clo_trace_addr) {
+         Thread* thr    = get_current_Thread();
+         UInt    sv_old = shadow_mem_get8( dst );
+         msm__show_state_change( thr, dst, 1, 'w', sv_old, sv );
+      }
+   }
+
+   shadow_mem_set8( NULL/*unused*/, dst, sv );
+}
+
+
+/* ------------ Shadow memory range setting ops ------------ */
+
+static void shadow_mem_modify_range(
+               Thread* thr, 
+               Addr    a, 
+               SizeT   len,
+               void    (*fn8) (Thread*,Addr,UInt),
+               void    (*fn16)(Thread*,Addr,UInt),
+               void    (*fn32)(Thread*,Addr,UInt),
+               void    (*fn64)(Thread*,Addr,UInt),
+               UInt    opaque
+            )
+{
+   /* fast track a couple of common cases */
+   if (len == 4 && aligned32(a)) {
+      fn32( thr, a, opaque );
+      return;
+   }
+   if (len == 8 && aligned64(a)) {
+      fn64( thr, a, opaque );
+      return;
+   }
+
+   /* be completely general (but as efficient as possible) */
+   if (len == 0) return;
+
+   if (!aligned16(a) && len >= 1) {
+      fn8( thr, a, opaque );
+      a += 1;
+      len -= 1;
+      tl_assert(aligned16(a));
+   }
+   if (len == 0) return;
+
+   if (!aligned32(a) && len >= 2) {
+      fn16( thr, a, opaque );
+      a += 2;
+      len -= 2;
+      tl_assert(aligned32(a));
+   }
+   if (len == 0) return;
+
+   if (!aligned64(a) && len >= 4) {
+      fn32( thr, a, opaque );
+      a += 4;
+      len -= 4;
+      tl_assert(aligned64(a));
+   }
+   if (len == 0) return;
+
+   if (len >= 8) {
+      tl_assert(aligned64(a));
+      while (len >= 8) {
+         fn64( thr, a, opaque );
+         a += 8;
+         len -= 8;
+      }
+      tl_assert(aligned64(a));
+   }
+   if (len == 0) return;
+
+   if (len >= 4)
+      tl_assert(aligned32(a));
+   if (len >= 4) {
+      fn32( thr, a, opaque );
+      a += 4;
+      len -= 4;
+   }
+   if (len == 0) return;
+
+   if (len >= 2)
+      tl_assert(aligned16(a));
+   if (len >= 2) {
+      fn16( thr, a, opaque );
+      a += 2;
+      len -= 2;
+   }
+   if (len == 0) return;
+
+   if (len >= 1) {
+      fn8( thr, a, opaque );
+      a += 1;
+      len -= 1;
+   }
+   tl_assert(len == 0);
+}
+
+/* Block-copy states (needed for implementing realloc()). */
+static void shadow_mem_copy_range ( Addr src, Addr dst, SizeT len )
+{
+   SizeT i;
+   if (len == 0)
+      return;
+   /* To be simple, just copy byte by byte.  But so as not to wreck
+      performance for later accesses to dst[0 .. len-1], normalise
+      destination lines as we finish with them, and also normalise the
+      line containing the first and last address. */
+   for (i = 0; i < len; i++) {
+      Bool normalise
+         = get_cacheline_offset( dst+i+1 ) == 0 /* last in line */
+           || i == 0       /* first in range */
+           || i == len-1;  /* last in range */
+      shadow_mem_copy8( src+i, dst+i, normalise );
+   }
+}
+
+static void shadow_mem_read_range ( Thread* thr, Addr a, SizeT len ) {
+   shadow_mem_modify_range( thr, a, len, 
+                            shadow_mem_read8,
+                            shadow_mem_read16,
+                            shadow_mem_read32,
+                            shadow_mem_read64,
+                            0/*opaque,ignored*/ );
+}
+
+static void shadow_mem_write_range ( Thread* thr, Addr a, SizeT len ) {
+   shadow_mem_modify_range( thr, a, len, 
+                            shadow_mem_write8,
+                            shadow_mem_write16,
+                            shadow_mem_write32,
+                            shadow_mem_write64,
+                            0/*opaque,ignored*/ );
+}
+
+static void shadow_mem_make_New ( Thread* thr, Addr a, SizeT len )
+{
+   if (UNLIKELY(clo_trace_level > 0)) {
+      if (len > 0 && a <= clo_trace_addr && clo_trace_addr < a+len) {
+         UInt sv_old = shadow_mem_get8( clo_trace_addr );
+         msm__show_state_change( thr, a, (Int)len, 'p', sv_old, SHVAL_New );
+      }
+   }
+   shadow_mem_modify_range( thr, a, len, 
+                            shadow_mem_set8,
+                            shadow_mem_set16,
+                            shadow_mem_set32,
+                            shadow_mem_set64,
+                            SHVAL_New/*opaque*/ );
+}
+
+
+/* Putting memory into the NoAccess state.  This is hugely complicated
+   by the problem of memory that contains locks.
+
+   1. Examine the .mbHasLocks fields in all SecMaps in the range to be
+      deleted.  This quickly indicates if there are or might be any
+      locks in the range to be deleted.  Note that .mbHasLocks fields on
+      SecMaps are not subject to scaching, so it safe to look at them
+      without flushing the scache.
+
+   2. Set the range to NoAccess.  Clear the .mbHasShared and
+      .mbHasLocks hint bits for any completely vacated SecMaps.
+      Clearing the hint bits isn't necessary for correctness, but it
+      is important to avoid ending up with hint bits being permanently
+      set, which would render them pointless.
+
+   3. If (1) indicated "definitely no locks", we're done.  This is
+      the fast and hopefully common case.
+
+   Otherwise, the range contains some locks (or may do), so we have to
+   go to considerable effort to tidy up.
+
+   4. Make up a set containing the locks which are deleted:
+
+      ToDelete = NULL
+
+      for each lk in map_locks {
+         if lk's guest addr falls in the range to memory be deleted
+            add lk to ToDelete
+
+         if lk is held, issue an error message - freeing memory
+            containing a held lock
+      }
+
+   5. If ToDelete is empty, there were in fact no locks in the range,
+      despite what the .mbHasLocks hint bits indicated.  We're done.
+
+   6. Flush the scache.  This is necessary both to bring the SecMap
+      .mbHasShared fields up to date, and to bring the actual shadow
+      values up to date.  We will need to examine both of these.
+
+      Invalidate the scache.  This is necessary because we will be
+      modifying values in the backing store (SecMaps) and need
+      subsequent shmem accesses to get the new values.
+
+   7. Modify all shadow words, by removing ToDelete from the lockset
+      of all ShM and ShR states.  Note this involves a complete scan
+      over map_shmem, which is very expensive according to OProfile.
+      Hence it depends critically on the size of each entry in
+      map_shmem.  See comments on definition of N_SECMAP_BITS above.
+
+      Why is it safe to do (7) after (2) ?  Because we're not
+      interested in messing with ShR/M states which are going to be
+      set to NoAccess anyway.
+
+      Optimisation 1 (implemented): skip this step for SecMaps which
+      do not have .mbHasShared set
+
+      Optimisation 2 (not implemented): for each SecMap, have a
+      summary lock set which is the union of all locks mentioned in
+      locksets on this page (or any superset of it).  Then skip step
+      (2) if the summary lockset does not intersect with ToDelete.
+
+      That's potentially cheap, since the usual lockset refinement
+      only shrinks locksets; hence there is no point in updating the
+      summary lockset for ShM/R -> ShM/R transitions.  Therefore only
+      need to do this for Excl->ShM/R transitions.
+
+   8. Tell laog that these locks have disappeared.
+*/
+static void shadow_mem_make_NoAccess ( Thread* thr, Addr aIN, SizeT len )
+{
+   Lock*     lk;
+   Addr      gla, sma, firstSM, lastSM, firstA, lastA;
+   WordSetID locksToDelete;
+   Bool      mbHasLocks;
+
+   if (0 && len > 500)
+      VG_(printf)("make NoAccess ( %p, %d )\n", aIN, len );
+
+   if (len == 0) 
+      return;
+
+   /* --- Step 1 --- */
+
+   firstA  = aIN;
+   lastA   = aIN + len - 1;
+
+   firstSM = shmem__round_to_SecMap_base( firstA );
+   lastSM  = shmem__round_to_SecMap_base( lastA );
+   tl_assert(firstSM <= lastSM);
+
+   mbHasLocks = False;
+   for (sma = firstSM; sma <= lastSM; sma += N_SECMAP_ARANGE) {
+      if (shmem__get_mbHasLocks(sma)) {
+         mbHasLocks = True;
+         break;
+      }
+   }
+
+   /* --- Step 2 --- */
+
+   if (UNLIKELY(clo_trace_level > 0)) {
+      if (len > 0 && firstA <= clo_trace_addr && clo_trace_addr <= lastA) {
+         UInt sv_old = shadow_mem_get8( clo_trace_addr );
+         msm__show_state_change( thr, firstA, (Int)len, 'p',
+                                      sv_old, SHVAL_NoAccess );
+      }
+   }
+   shadow_mem_modify_range( thr, firstA, len, 
+                            shadow_mem_set8,
+                            shadow_mem_set16,
+                            shadow_mem_set32,
+                            shadow_mem_set64,
+                            SHVAL_NoAccess/*opaque*/ );
+
+   for (sma = firstSM; sma <= lastSM; sma += N_SECMAP_ARANGE) {
+      /* Is this sm entirely within the deleted range? */
+      if (firstA <= sma && sma + N_SECMAP_ARANGE - 1 <= lastA) {
+         /* Yes.  Clear the hint bits. */
+         shmem__set_mbHasLocks( sma, False );
+         shmem__set_mbHasShared( sma, False );
+      }
+   }
+
+   /* --- Step 3 --- */
+
+   if (!mbHasLocks)
+      return;
+
+   /* --- Step 4 --- */
+
+   if (0) 
+   VG_(printf)("shadow_mem_make_NoAccess(%p, %u, %p): maybe slow case\n",
+               (void*)firstA, (UWord)len, (void*)lastA);
+   locksToDelete = HG_(emptyWS)( univ_lsets );
+   
+   /* FIXME: don't iterate over the complete lock set */
+   HG_(initIterFM)( map_locks );
+   while (HG_(nextIterFM)( map_locks,
+                           (Word*)(void*)&gla, (Word*)(void*)&lk )) {
+      tl_assert(is_sane_LockN(lk));
+      if (gla < firstA || gla > lastA)
+         continue;
+      locksToDelete = HG_(addToWS)( univ_lsets, locksToDelete, (Word)lk );
+      /* If the lock is held, we must remove it from the currlock sets
+         of all threads that hold it.  Also take the opportunity to
+         report an error.  To report an error we need to know at least
+         one of the threads that holds it; really we should mention
+         them all, but that's too much hassle.  So choose one
+         arbitrarily. */
+      if (lk->heldBy) {
+         tl_assert(!HG_(isEmptyBag)(lk->heldBy));
+         record_error_FreeMemLock( (Thread*)HG_(anyElementOfBag)(lk->heldBy),
+                                   lk );
+         /* remove lock from locksets of all owning threads */
+         remove_Lock_from_locksets_of_all_owning_Threads( lk );
+         /* Leave lk->heldBy in place; del_Lock below will free it up. */
+      }
+   }
+   HG_(doneIterFM)( map_locks );
+
+   /* --- Step 5 --- */
+
+   if (HG_(isEmptyWS)( univ_lsets, locksToDelete ))
+      return;
+
+   /* --- Step 6 --- */
+
+   shmem__flush_and_invalidate_scache();
+
+   /* --- Step 7 --- */
+
+   if (0) 
+   VG_(printf)("shadow_mem_make_NoAccess(%p, %u, %p): definitely slow case\n",
+               (void*)firstA, (UWord)len, (void*)lastA);
+
+   /* Modify all shadow words, by removing locksToDelete from the lockset
+      of all ShM and ShR states.
+      Optimisation 1: skip SecMaps which do not have .mbHasShared set
+   */
+   { Int        stats_SMs = 0, stats_SMs_scanned = 0;
+     Addr       ga;
+     SecMap*    sm;
+     SecMapIter itr;
+     UInt*      w32p;
+
+     HG_(initIterFM)( map_shmem );
+     while (HG_(nextIterFM)( map_shmem,
+                             (Word*)(void*)&ga, (Word*)(void*)&sm )) {
+        tl_assert(sm);
+        stats_SMs++;
+        /* Skip this SecMap if the summary bit indicates it is safe to
+           do so. */
+        if (!sm->mbHasShared)
+           continue;
+        stats_SMs_scanned++;
+        initSecMapIter( &itr );
+        while (stepSecMapIter( &w32p, &itr, sm )) {
+           Bool isM;
+           UInt wold, wnew, lset_old, tset_old, lset_new;
+           wold = *w32p;
+           if (LIKELY( !is_SHVAL_Sh(wold) ))
+              continue;
+           isM      = is_SHVAL_ShM(wold);
+           lset_old = un_SHVAL_Sh_lset(wold);
+           tset_old = un_SHVAL_Sh_tset(wold);
+           lset_new = HG_(minusWS)( univ_lsets, lset_old, locksToDelete );
+           wnew     = isM ? mk_SHVAL_ShM(tset_old, lset_new)
+                          : mk_SHVAL_ShR(tset_old, lset_new);
+           if (wnew != wold)
+              *w32p = wnew;
+        }
+     }
+     HG_(doneIterFM)( map_shmem );
+     if (SHOW_EXPENSIVE_STUFF)
+        VG_(printf)("shadow_mem_make_NoAccess: %d SMs, %d scanned\n", 
+                    stats_SMs, stats_SMs_scanned);
+   }
+
+   /* Now we have to free up the Locks in locksToDelete and remove
+      any mention of them from admin_locks and map_locks.  This is
+      inefficient. */
+   { Lock* lkprev = NULL;
+     lk = admin_locks;
+     while (True) {
+        if (lk == NULL) break;
+        if (lkprev) tl_assert(lkprev->admin == lk);
+
+        if (!HG_(elemWS)(univ_lsets, locksToDelete, (Word)lk)) {
+           lkprev = lk;
+           lk = lk->admin;
+           continue;
+        }
+        /* Need to delete 'lk' */
+        if (lkprev == NULL) {
+           admin_locks = lk->admin;
+        } else {
+           lkprev->admin = lk->admin;
+        }
+        /* and get it out of map_locks */
+        map_locks_delete(lk->guestaddr);
+        /* release storage (incl. associated .heldBy Bag) */
+        { Lock* tmp = lk->admin;
+          del_LockN(lk);
+          lk = tmp;
+        }
+     }
+   }
+
+   /* --- Step 8 --- */
+
+   /* update lock order acquisition graph */
+   laog__handle_lock_deletions( locksToDelete );
+
+   if (0) all__sanity_check("Make NoAccess");
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Event handlers (evh__* functions)                        ---*/
+/*--- plus helpers (evhH__* functions)                         ---*/
+/*----------------------------------------------------------------*/
+
+/*--------- Event handler helpers (evhH__* functions) ---------*/
+
+/* Create a new segment for 'thr', making it depend (.prev) on its
+   existing segment, bind together the SegmentID and Segment, and
+   return both of them.  Also update 'thr' so it references the new
+   Segment. */
+static 
+void evhH__start_new_segment_for_thread ( /*OUT*/SegmentID* new_segidP,
+                                          /*OUT*/Segment** new_segP,
+                                          Thread* thr )
+{
+   Segment* cur_seg;
+   tl_assert(new_segP);
+   tl_assert(new_segidP);
+   tl_assert(is_sane_Thread(thr));
+   cur_seg = map_segments_lookup( thr->csegid );
+   tl_assert(cur_seg);
+   tl_assert(cur_seg->thr == thr); /* all sane segs should point back
+                                      at their owner thread. */
+   *new_segP = mk_Segment( thr, cur_seg, NULL/*other*/ );
+   *new_segidP = alloc_SegmentID();
+   map_segments_add( *new_segidP, *new_segP );
+   thr->csegid = *new_segidP;
+}
+
+
+/* The lock at 'lock_ga' has acquired a writer.  Make all necessary
+   updates, and also do all possible error checks. */
+static 
+void evhH__post_thread_w_acquires_lock ( Thread* thr, 
+                                         LockKind lkk, Addr lock_ga )
+{
+   Lock* lk; 
+
+   /* Basically what we need to do is call lockN_acquire_writer.
+      However, that will barf if any 'invalid' lock states would
+      result.  Therefore check before calling.  Side effect is that
+      'is_sane_LockN(lk)' is both a pre- and post-condition of this
+      routine. 
+
+      Because this routine is only called after successful lock
+      acquisition, we should not be asked to move the lock into any
+      invalid states.  Requests to do so are bugs in libpthread, since
+      that should have rejected any such requests. */
+
+   /* be paranoid w.r.t hint bits, even if lock_ga is complete
+      nonsense */
+   shmem__set_mbHasLocks( lock_ga, True );
+
+   tl_assert(is_sane_Thread(thr));
+   /* Try to find the lock.  If we can't, then create a new one with
+      kind 'lkk'. */
+   lk = map_locks_lookup_or_create( 
+           lkk, lock_ga, map_threads_reverse_lookup_SLOW(thr) );
+   tl_assert( is_sane_LockN(lk) );
+   shmem__set_mbHasLocks( lock_ga, True );
+
+   if (lk->heldBy == NULL) {
+      /* the lock isn't held.  Simple. */
+      tl_assert(!lk->heldW);
+      lockN_acquire_writer( lk, thr );
+      goto noerror;
+   }
+
+   /* So the lock is already held.  If held as a r-lock then
+      libpthread must be buggy. */
+   tl_assert(lk->heldBy);
+   if (!lk->heldW) {
+      record_error_Misc( thr, "Bug in libpthread: write lock "
+                              "granted on rwlock which is currently rd-held");
+      goto error;
+   }
+
+   /* So the lock is held in w-mode.  If it's held by some other
+      thread, then libpthread must be buggy. */
+   tl_assert(HG_(sizeUniqueBag)(lk->heldBy) == 1); /* from precondition */
+
+   if (thr != (Thread*)HG_(anyElementOfBag)(lk->heldBy)) {
+      record_error_Misc( thr, "Bug in libpthread: write lock "
+                              "granted on mutex/rwlock which is currently "
+                              "wr-held by a different thread");
+      goto error;
+   }
+
+   /* So the lock is already held in w-mode by 'thr'.  That means this
+      is an attempt to lock it recursively, which is only allowable
+      for LK_mbRec kinded locks.  Since this routine is called only
+      once the lock has been acquired, this must also be a libpthread
+      bug. */
+   if (lk->kind != LK_mbRec) {
+      record_error_Misc( thr, "Bug in libpthread: recursive write lock "
+                              "granted on mutex/wrlock which does not "
+                              "support recursion");
+      goto error;
+   }
+
+   /* So we are recursively re-locking a lock we already w-hold. */
+   lockN_acquire_writer( lk, thr );
+   goto noerror;
+
+  noerror:
+   /* check lock order acquisition graph, and update.  This has to
+      happen before the lock is added to the thread's locksetA/W. */
+   laog__pre_thread_acquires_lock( thr, lk );
+   /* update the thread's held-locks set */
+   thr->locksetA = HG_(addToWS)( univ_lsets, thr->locksetA, (Word)lk );
+   thr->locksetW = HG_(addToWS)( univ_lsets, thr->locksetW, (Word)lk );
+   /* fall through */
+
+  error:
+   tl_assert(is_sane_LockN(lk));
+}
+
+
+/* The lock at 'lock_ga' has acquired a reader.  Make all necessary
+   updates, and also do all possible error checks. */
+static 
+void evhH__post_thread_r_acquires_lock ( Thread* thr, 
+                                         LockKind lkk, Addr lock_ga )
+{
+   Lock* lk; 
+
+   /* Basically what we need to do is call lockN_acquire_reader.
+      However, that will barf if any 'invalid' lock states would
+      result.  Therefore check before calling.  Side effect is that
+      'is_sane_LockN(lk)' is both a pre- and post-condition of this
+      routine. 
+
+      Because this routine is only called after successful lock
+      acquisition, we should not be asked to move the lock into any
+      invalid states.  Requests to do so are bugs in libpthread, since
+      that should have rejected any such requests. */
+
+   /* be paranoid w.r.t hint bits, even if lock_ga is complete
+      nonsense */
+   shmem__set_mbHasLocks( lock_ga, True );
+
+   tl_assert(is_sane_Thread(thr));
+   /* Try to find the lock.  If we can't, then create a new one with
+      kind 'lkk'.  Only a reader-writer lock can be read-locked,
+      hence the first assertion. */
+   tl_assert(lkk == LK_rdwr);
+   lk = map_locks_lookup_or_create( 
+           lkk, lock_ga, map_threads_reverse_lookup_SLOW(thr) );
+   tl_assert( is_sane_LockN(lk) );
+   shmem__set_mbHasLocks( lock_ga, True );
+
+   if (lk->heldBy == NULL) {
+      /* the lock isn't held.  Simple. */
+      tl_assert(!lk->heldW);
+      lockN_acquire_reader( lk, thr );
+      goto noerror;
+   }
+
+   /* So the lock is already held.  If held as a w-lock then
+      libpthread must be buggy. */
+   tl_assert(lk->heldBy);
+   if (lk->heldW) {
+      record_error_Misc( thr, "Bug in libpthread: read lock "
+                              "granted on rwlock which is "
+                              "currently wr-held");
+      goto error;
+   }
+
+   /* Easy enough.  In short anybody can get a read-lock on a rwlock
+      provided it is either unlocked or already in rd-held. */
+   lockN_acquire_reader( lk, thr );
+   goto noerror;
+
+  noerror:
+   /* check lock order acquisition graph, and update.  This has to
+      happen before the lock is added to the thread's locksetA/W. */
+   laog__pre_thread_acquires_lock( thr, lk );
+   /* update the thread's held-locks set */
+   thr->locksetA = HG_(addToWS)( univ_lsets, thr->locksetA, (Word)lk );
+   /* but don't update thr->locksetW, since lk is only rd-held */
+   /* fall through */
+
+  error:
+   tl_assert(is_sane_LockN(lk));
+}
+
+
+/* The lock at 'lock_ga' is just about to be unlocked.  Make all
+   necessary updates, and also do all possible error checks. */
+static 
+void evhH__pre_thread_releases_lock ( Thread* thr,
+                                      Addr lock_ga, Bool isRDWR )
+{
+   Lock* lock;
+   Word  n;
+
+   /* This routine is called prior to a lock release, before
+      libpthread has had a chance to validate the call.  Hence we need
+      to detect and reject any attempts to move the lock into an
+      invalid state.  Such attempts are bugs in the client.
+
+      isRDWR is True if we know from the wrapper context that lock_ga
+      should refer to a reader-writer lock, and is False if [ditto]
+      lock_ga should refer to a standard mutex. */
+
+   /* be paranoid w.r.t hint bits, even if lock_ga is complete
+      nonsense */
+   shmem__set_mbHasLocks( lock_ga, True );
+
+   tl_assert(is_sane_Thread(thr));
+   lock = map_locks_maybe_lookup( lock_ga );
+
+   if (!lock) {
+      /* We know nothing about a lock at 'lock_ga'.  Nevertheless
+         the client is trying to unlock it.  So complain, then ignore
+         the attempt. */
+      record_error_UnlockBogus( thr, lock_ga );
+      return;
+   }
+
+   tl_assert(lock->guestaddr == lock_ga);
+   tl_assert(is_sane_LockN(lock));
+
+   if (isRDWR && lock->kind != LK_rdwr) {
+      record_error_Misc( thr, "pthread_rwlock_unlock with a "
+                              "pthread_mutex_t* argument " );
+   }
+   if ((!isRDWR) && lock->kind == LK_rdwr) {
+      record_error_Misc( thr, "pthread_mutex_unlock with a "
+                              "pthread_rwlock_t* argument " );
+   }
+
+   if (!lock->heldBy) {
+      /* The lock is not held.  This indicates a serious bug in the
+         client. */
+      tl_assert(!lock->heldW);
+      record_error_UnlockUnlocked( thr, lock );
+      tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+      tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+      goto error;
+   }
+
+   /* The lock is held.  Is this thread one of the holders?  If not,
+      report a bug in the client. */
+   n = HG_(elemBag)( lock->heldBy, (Word)thr );
+   tl_assert(n >= 0);
+   if (n == 0) {
+      /* We are not a current holder of the lock.  This is a bug in
+         the guest, and (per POSIX pthread rules) the unlock
+         attempt will fail.  So just complain and do nothing
+         else. */
+      Thread* realOwner = (Thread*)HG_(anyElementOfBag)( lock->heldBy );
+      tl_assert(is_sane_Thread(realOwner));
+      tl_assert(realOwner != thr);
+      tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+      tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+      record_error_UnlockForeign( thr, realOwner, lock );
+      goto error;
+   }
+
+   /* Ok, we hold the lock 'n' times. */
+   tl_assert(n >= 1);
+
+   lockN_release( lock, thr );
+
+   n--;
+   tl_assert(n >= 0);
+
+   if (n > 0) {
+      tl_assert(lock->heldBy);
+      tl_assert(n == HG_(elemBag)( lock->heldBy, (Word)thr )); 
+      /* We still hold the lock.  So either it's a recursive lock 
+         or a rwlock which is currently r-held. */
+      tl_assert(lock->kind == LK_mbRec
+                || (lock->kind == LK_rdwr && !lock->heldW));
+      tl_assert(HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lock ));
+      if (lock->heldW)
+         tl_assert(HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+      else
+         tl_assert(!HG_(elemWS)( univ_lsets, thr->locksetW, (Word)lock ));
+   } else {
+      /* We no longer hold the lock. */
+      if (lock->heldBy) {
+         tl_assert(0 == HG_(elemBag)( lock->heldBy, (Word)thr ));
+      }
+      /* update this thread's lockset accordingly. */
+      thr->locksetA
+         = HG_(delFromWS)( univ_lsets, thr->locksetA, (Word)lock );
+      thr->locksetW
+         = HG_(delFromWS)( univ_lsets, thr->locksetW, (Word)lock );
+   }
+   /* fall through */
+
+  error:
+   tl_assert(is_sane_LockN(lock));
+}
+
+
+/*--------- Event handlers proper (evh__* functions) ---------*/
+
+/* What is the Thread* for the currently running thread?  This is
+   absolutely performance critical.  We receive notifications from the
+   core for client code starts/stops, and cache the looked-up result
+   in 'current_Thread'.  Hence, for the vast majority of requests,
+   finding the current thread reduces to a read of a global variable,
+   provided get_current_Thread_in_C_C is inlined.
+
+   Outside of client code, current_Thread is NULL, and presumably
+   any uses of it will cause a segfault.  Hence:
+
+   - for uses definitely within client code, use
+     get_current_Thread_in_C_C.
+
+   - for all other uses, use get_current_Thread.
+*/
+
+static Thread* current_Thread = NULL;
+
+static void evh__start_client_code ( ThreadId tid, ULong nDisp ) {
+   if (0) VG_(printf)("start %d %llu\n", (Int)tid, nDisp);
+   tl_assert(current_Thread == NULL);
+   current_Thread = map_threads_lookup( tid );
+   tl_assert(current_Thread != NULL);
+}
+static void evh__stop_client_code ( ThreadId tid, ULong nDisp ) {
+   if (0) VG_(printf)(" stop %d %llu\n", (Int)tid, nDisp);
+   tl_assert(current_Thread != NULL);
+   current_Thread = NULL;
+}
+static inline Thread* get_current_Thread_in_C_C ( void ) {
+   return current_Thread;
+}
+static inline Thread* get_current_Thread ( void ) {
+   ThreadId coretid;
+   Thread*  thr;
+   thr = get_current_Thread_in_C_C();
+   if (LIKELY(thr))
+      return thr;
+   /* evidently not in client code.  Do it the slow way. */
+   coretid = VG_(get_running_tid)();
+   /* FIXME: get rid of the following kludge.  It exists because
+      evim__new_mem is called during initialisation (as notification
+      of initial memory layout) and VG_(get_running_tid)() returns
+      VG_INVALID_THREADID at that point. */
+   if (coretid == VG_INVALID_THREADID)
+      coretid = 1; /* KLUDGE */
+   thr = map_threads_lookup( coretid );
+   return thr;
+}
+
+static
+void evh__new_mem ( Addr a, SizeT len ) {
+   if (SHOW_EVENTS >= 2)
+      VG_(printf)("evh__new_mem(%p, %lu)\n", (void*)a, len );
+   shadow_mem_make_New( get_current_Thread(), a, len );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__new_mem-post");
+}
+
+static
+void evh__new_mem_w_perms ( Addr a, SizeT len, 
+                            Bool rr, Bool ww, Bool xx ) {
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__new_mem_w_perms(%p, %lu, %d,%d,%d)\n",
+                  (void*)a, len, (Int)rr, (Int)ww, (Int)xx );
+   if (rr || ww || xx)
+      shadow_mem_make_New( get_current_Thread(), a, len );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__new_mem_w_perms-post");
+}
+
+static
+void evh__set_perms ( Addr a, SizeT len,
+                      Bool rr, Bool ww, Bool xx ) {
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__set_perms(%p, %lu, %d,%d,%d)\n",
+                  (void*)a, len, (Int)rr, (Int)ww, (Int)xx );
+   /* Hmm.  What should we do here, that actually makes any sense?
+      Let's say: if neither readable nor writable, then declare it
+      NoAccess, else leave it alone. */
+   if (!(rr || ww))
+      shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__set_perms-post");
+}
+
+static
+void evh__die_mem ( Addr a, SizeT len ) {
+   if (SHOW_EVENTS >= 2)
+      VG_(printf)("evh__die_mem(%p, %lu)\n", (void*)a, len );
+   shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__die_mem-post");
+}
+
+static
+void evh__pre_thread_ll_create ( ThreadId parent, ThreadId child )
+{
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__pre_thread_ll_create(p=%d, c=%d)\n",
+                  (Int)parent, (Int)child );
+
+   if (parent != VG_INVALID_THREADID) {
+      Thread*   thr_p;
+      Thread*   thr_c;
+      SegmentID segid_c;
+      Segment*  seg_c;
+
+      tl_assert(is_sane_ThreadId(parent));
+      tl_assert(is_sane_ThreadId(child));
+      tl_assert(parent != child);
+
+      thr_p = map_threads_maybe_lookup( parent );
+      thr_c = map_threads_maybe_lookup( child );
+
+      tl_assert(thr_p != NULL);
+      tl_assert(thr_c == NULL);
+
+      /* Create a new thread record for the child. */
+      // FIXME: code duplication from init_data_structures
+      segid_c = alloc_SegmentID();
+      seg_c   = mk_Segment( NULL/*thr*/, NULL/*prev*/, NULL/*other*/ );
+      map_segments_add( segid_c, seg_c );
+
+      /* a Thread for the new thread ... */
+      thr_c = mk_Thread( segid_c );
+      seg_c->thr = thr_c;
+
+      /* and bind it in the thread-map table */
+      map_threads[child] = thr_c;
+
+      /* Record where the parent is so we can later refer to this in
+         error messages.
+
+         On amd64-linux, this entails a nasty glibc-2.5 specific hack.
+         The stack snapshot is taken immediately after the parent has
+         returned from its sys_clone call.  Unfortunately there is no
+         unwind info for the insn following "syscall" - reading the
+         glibc sources confirms this.  So we ask for a snapshot to be
+         taken as if RIP was 3 bytes earlier, in a place where there
+         is unwind info.  Sigh.
+      */
+      { Word first_ip_delta = 0;
+#       if defined(VGP_amd64_linux)
+        first_ip_delta = -3;
+#       endif
+        thr_c->created_at = VG_(record_ExeContext)(parent, first_ip_delta);
+      }
+
+      /* Now, mess with segments. */ 
+      if (clo_happens_before >= 1) {
+         /* Make the child's new segment depend on the parent */
+         seg_c->other = map_segments_lookup( thr_p->csegid );
+         seg_c->other_hint = 'c';
+         seg_c->vts = tick_VTS( thr_c, seg_c->other->vts );
+         tl_assert(seg_c->prev == NULL);
+         /* and start a new segment for the parent. */
+         { SegmentID new_segid = 0; /* bogus */
+           Segment*  new_seg   = NULL;
+           evhH__start_new_segment_for_thread( &new_segid, &new_seg, 
+                                               thr_p );
+           tl_assert(is_sane_SegmentID(new_segid));
+           tl_assert(is_sane_Segment(new_seg));
+           new_seg->vts = tick_VTS( thr_p, new_seg->prev->vts );
+           tl_assert(new_seg->other == NULL);
+         }
+      }
+   }
+
+   if (clo_sanity_flags & SCE_THREADS)
+      all__sanity_check("evh__pre_thread_create-post");
+}
+
+static
+void evh__pre_thread_ll_exit ( ThreadId quit_tid )
+{
+   Int     nHeld;
+   Thread* thr_q;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__pre_thread_ll_exit(thr=%d)\n",
+                  (Int)quit_tid );
+
+   /* quit_tid has disappeared without joining to any other thread.
+      Therefore there is no synchronisation event associated with its
+      exit and so we have to pretty much treat it as if it was still
+      alive but mysteriously making no progress.  That is because, if
+      we don't know when it really exited, then we can never say there
+      is a point in time when we're sure the thread really has
+      finished, and so we need to consider the possibility that it
+      lingers indefinitely and continues to interact with other
+      threads. */
+   /* However, it might have rendezvous'd with a thread that called
+      pthread_join with this one as arg, prior to this point (that's
+      how NPTL works).  In which case there has already been a prior
+      sync event.  So in any case, just let the thread exit.  On NPTL,
+      all thread exits go through here. */
+   tl_assert(is_sane_ThreadId(quit_tid));
+   thr_q = map_threads_maybe_lookup( quit_tid );
+   tl_assert(thr_q != NULL);
+
+   /* Complain if this thread holds any locks. */
+   nHeld = HG_(cardinalityWS)( univ_lsets, thr_q->locksetA );
+   tl_assert(nHeld >= 0);
+   if (nHeld > 0) {
+      HChar buf[80];
+      VG_(sprintf)(buf, "Exiting thread still holds %d lock%s",
+                        nHeld, nHeld > 1 ? "s" : "");
+      record_error_Misc( thr_q, buf );
+   }
+
+   /* About the only thing we do need to do is clear the map_threads
+      entry, in order that the Valgrind core can re-use it. */
+   map_threads_delete( quit_tid );
+
+   if (clo_sanity_flags & SCE_THREADS)
+      all__sanity_check("evh__pre_thread_ll_exit-post");
+}
+
+static
+void evh__HG_PTHREAD_JOIN_POST ( ThreadId stay_tid, Thread* quit_thr )
+{
+   Int      stats_SMs, stats_SMs_scanned, stats_reExcls;
+   Addr     ga;
+   SecMap*  sm;
+   Thread*  thr_s;
+   Thread*  thr_q;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__post_thread_join(stayer=%d, quitter=%p)\n",
+                  (Int)stay_tid, quit_thr );
+
+   tl_assert(is_sane_ThreadId(stay_tid));
+
+   thr_s = map_threads_maybe_lookup( stay_tid );
+   thr_q = quit_thr;
+   tl_assert(thr_s != NULL);
+   tl_assert(thr_q != NULL);
+   tl_assert(thr_s != thr_q);
+
+   if (clo_happens_before >= 1) {
+      /* Start a new segment for the stayer */
+      SegmentID new_segid = 0; /* bogus */
+      Segment*  new_seg   = NULL;
+      evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr_s );
+      tl_assert(is_sane_SegmentID(new_segid));
+      tl_assert(is_sane_Segment(new_seg));
+      /* and make it depend on the quitter's last segment */
+      tl_assert(new_seg->other == NULL);
+      new_seg->other = map_segments_lookup( thr_q->csegid );
+      new_seg->other_hint = 'j';
+      tl_assert(new_seg->thr == thr_s);
+      new_seg->vts = tickL_and_joinR_VTS( thr_s, new_seg->prev->vts,
+                                                 new_seg->other->vts );
+   }
+
+   // FIXME: error-if: exiting thread holds any locks
+   //        or should evh__pre_thread_ll_exit do that?
+
+   /* Delete thread from ShM/ShR thread sets and restore Excl states
+      where appropriate */
+
+   /* When Thread(t) joins to Thread(u):
+
+      scan all shadow memory.  For each ShM/ShR thread set, replace
+      't' in each set with 'u'.  If this results in a singleton 'u',
+      change the state to Excl(u->csegid).
+
+      Optimisation: tag each SecMap with a superset of the union of
+      the thread sets in the SecMap.  Then if the tag set does not
+      include 't' then the SecMap can be skipped, because there is no
+      't' to change to anything else.
+
+      Problem is that the tag set needs to be updated often, after
+      every ShR/ShM store.  (that increases the thread set of the
+      shadow value.)
+
+      --> Compromise.  Tag each SecMap with a .mbHasShared bit which
+          must be set true if any ShR/ShM on the page.  Set this for
+          any transitions into ShR/ShM on the page.  Then skip page if
+          not set.
+
+      .mbHasShared bits are (effectively) cached in cache_shmem.
+      Hence that must be flushed before we can safely consult them.
+
+      Since we're modifying the backing store, we also need to
+      invalidate cache_shmem, so that subsequent memory references get
+      up to date shadow values.
+   */
+   shmem__flush_and_invalidate_scache();
+
+   stats_SMs = stats_SMs_scanned = stats_reExcls = 0;
+   HG_(initIterFM)( map_shmem );
+   while (HG_(nextIterFM)( map_shmem,
+                           (Word*)(void*)&ga, (Word*)(void*)&sm )) {
+      SecMapIter itr;
+      UInt*      w32p;
+      tl_assert(sm);
+      stats_SMs++;
+      /* Skip this SecMap if the summary bit indicates it is safe to
+         do so. */
+      if (!sm->mbHasShared)
+         continue;
+      stats_SMs_scanned++;
+      initSecMapIter( &itr );
+      while (stepSecMapIter( &w32p, &itr, sm )) {
+         Bool isM;
+         UInt wnew, wold, lset_old, tset_old, tset_new;
+         wold = *w32p;
+         if (!is_SHVAL_Sh(wold))
+            continue;
+         isM = is_SHVAL_ShM(wold);
+         lset_old = un_SHVAL_Sh_lset(wold);
+         tset_old = un_SHVAL_Sh_tset(wold);
+         /* Subst thr_q -> thr_s in the thread set.  Longwindedly, if
+            thr_q is in the set, delete it and add thr_s; else leave
+            it alone.  FIXME: is inefficient - make a special
+            substInWS method for this. */
+         tset_new 
+            = HG_(elemWS)( univ_tsets, tset_old, (Word)thr_q )
+              ? HG_(addToWS)(
+                   univ_tsets, 
+                   HG_(delFromWS)( univ_tsets, tset_old, (Word)thr_q ),
+                   (Word)thr_s 
+                )
+              : tset_old;
+
+         tl_assert(HG_(cardinalityWS)(univ_tsets, tset_new) 
+                   <= HG_(cardinalityWS)(univ_tsets, tset_old));
+
+         if (0) {
+            VG_(printf)("smga %p: old 0x%x new 0x%x   ",
+                        ga, tset_old, tset_new);
+            HG_(ppWS)( univ_tsets, tset_old );
+            VG_(printf)("  -->  ");
+            HG_(ppWS)( univ_tsets, tset_new );
+            VG_(printf)("\n");
+         }
+         if (HG_(isSingletonWS)( univ_tsets, tset_new, (Word)thr_s )) {
+            /* This word returns to Excl state */
+            wnew = mk_SHVAL_Excl(thr_s->csegid);
+            stats_reExcls++;
+         } else {
+            wnew = isM ? mk_SHVAL_ShM(tset_new, lset_old)
+                       : mk_SHVAL_ShR(tset_new, lset_old);
+         }
+         *w32p = wnew;
+      }
+   }
+   HG_(doneIterFM)( map_shmem );
+
+   if (SHOW_EXPENSIVE_STUFF)
+      VG_(printf)("evh__post_thread_join: %d SMs, "
+                  "%d scanned, %d re-Excls\n", 
+                  stats_SMs, stats_SMs_scanned, stats_reExcls);
+
+   /* This holds because, at least when using NPTL as the thread
+      library, we should be notified the low level thread exit before
+      we hear of any join event on it.  The low level exit
+      notification feeds through into evh__pre_thread_ll_exit,
+      which should clear the map_threads entry for it.  Hence we
+      expect there to be no map_threads entry at this point. */
+   tl_assert( map_threads_maybe_reverse_lookup_SLOW(thr_q)
+              == VG_INVALID_THREADID);
+
+   if (clo_sanity_flags & SCE_THREADS)
+      all__sanity_check("evh__post_thread_join-post");
+}
+
+static
+void evh__pre_mem_read ( CorePart part, ThreadId tid, Char* s, 
+                         Addr a, SizeT size) {
+   if (SHOW_EVENTS >= 2
+       || (SHOW_EVENTS >= 1 && size != 1))
+      VG_(printf)("evh__pre_mem_read(ctid=%d, \"%s\", %p, %lu)\n", 
+                  (Int)tid, s, (void*)a, size );
+   shadow_mem_read_range( map_threads_lookup(tid), a, size);
+   if (size >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__pre_mem_read-post");
+}
+
+static
+void evh__pre_mem_read_asciiz ( CorePart part, ThreadId tid,
+                                Char* s, Addr a ) {
+   Int len;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__pre_mem_asciiz(ctid=%d, \"%s\", %p)\n", 
+                  (Int)tid, s, (void*)a );
+   // FIXME: think of a less ugly hack
+   len = VG_(strlen)( (Char*) a );
+   shadow_mem_read_range( map_threads_lookup(tid), a, len+1 );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__pre_mem_read_asciiz-post");
+}
+
+static
+void evh__pre_mem_write ( CorePart part, ThreadId tid, Char* s,
+                          Addr a, SizeT size ) {
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__pre_mem_write(ctid=%d, \"%s\", %p, %lu)\n", 
+                  (Int)tid, s, (void*)a, size );
+   shadow_mem_write_range( map_threads_lookup(tid), a, size);
+   if (size >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__pre_mem_write-post");
+}
+
+static
+void evh__new_mem_heap ( Addr a, SizeT len, Bool is_inited ) {
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__new_mem_heap(%p, %lu, inited=%d)\n", 
+                  (void*)a, len, (Int)is_inited );
+   // FIXME: this is kinda stupid
+   if (is_inited) {
+      shadow_mem_make_New(get_current_Thread(), a, len);
+   } else {
+      shadow_mem_make_New(get_current_Thread(), a, len);
+   }
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__pre_mem_read-post");
+}
+
+static
+void evh__die_mem_heap ( Addr a, SizeT len ) {
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__die_mem_heap(%p, %lu)\n", (void*)a, len );
+   shadow_mem_make_NoAccess( get_current_Thread(), a, len );
+   if (len >= SCE_BIGRANGE_T && (clo_sanity_flags & SCE_BIGRANGE))
+      all__sanity_check("evh__pre_mem_read-post");
+}
+
+// thread async exit?
+
+static VG_REGPARM(1)
+void evh__mem_help_read_1(Addr a) {
+   shadow_mem_read8( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_2(Addr a) {
+   shadow_mem_read16( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_4(Addr a) {
+   shadow_mem_read32( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_read_8(Addr a) {
+   shadow_mem_read64( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(2)
+void evh__mem_help_read_N(Addr a, SizeT size) {
+   shadow_mem_read_range( get_current_Thread_in_C_C(), a, size );
+}
+
+static VG_REGPARM(1)
+void evh__mem_help_write_1(Addr a) {
+   shadow_mem_write8( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_2(Addr a) {
+   shadow_mem_write16( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_4(Addr a) {
+   shadow_mem_write32( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(1)
+void evh__mem_help_write_8(Addr a) {
+   shadow_mem_write64( get_current_Thread_in_C_C(), a, 0/*unused*/ );
+}
+static VG_REGPARM(2)
+void evh__mem_help_write_N(Addr a, SizeT size) {
+   shadow_mem_write_range( get_current_Thread_in_C_C(), a, size );
+}
+
+static void evh__bus_lock(void) {
+   Thread* thr;
+   if (0) VG_(printf)("evh__bus_lock()\n");
+   thr = get_current_Thread();
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+   evhH__post_thread_w_acquires_lock( thr, LK_nonRec, (Addr)&__bus_lock );
+}
+static void evh__bus_unlock(void) {
+   Thread* thr;
+   if (0) VG_(printf)("evh__bus_unlock()\n");
+   thr = get_current_Thread();
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+   evhH__pre_thread_releases_lock( thr, (Addr)&__bus_lock, False/*!isRDWR*/ );
+}
+
+
+/* -------------- events to do with mutexes -------------- */
+
+/* EXPOSITION only: by intercepting lock init events we can show the
+   user where the lock was initialised, rather than only being able to
+   show where it was first locked.  Intercepting lock initialisations
+   is not necessary for the basic operation of the race checker. */
+static
+void evh__HG_PTHREAD_MUTEX_INIT_POST( ThreadId tid, 
+                                      void* mutex, Word mbRec )
+{
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_MUTEX_INIT_POST(ctid=%d, mbRec=%ld, %p)\n", 
+                  (Int)tid, mbRec, (void*)mutex );
+   tl_assert(mbRec == 0 || mbRec == 1);
+   map_locks_lookup_or_create( mbRec ? LK_mbRec : LK_nonRec,
+                               (Addr)mutex, tid );
+   if (clo_sanity_flags & SCE_LOCKS)
+      all__sanity_check("evh__hg_PTHREAD_MUTEX_INIT_POST");
+}
+
+static
+void evh__HG_PTHREAD_MUTEX_DESTROY_PRE( ThreadId tid, void* mutex )
+{
+   Thread* thr;
+   Lock*   lk;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_MUTEX_DESTROY_PRE(ctid=%d, %p)\n", 
+                  (Int)tid, (void*)mutex );
+
+   thr = map_threads_maybe_lookup( tid );
+   /* cannot fail - Thread* must already exist */
+   tl_assert( is_sane_Thread(thr) );
+
+   lk = map_locks_maybe_lookup( (Addr)mutex );
+
+   if (lk == NULL || (lk->kind != LK_nonRec && lk->kind != LK_mbRec)) {
+      record_error_Misc( thr,
+                         "pthread_mutex_destroy with invalid argument" );
+   }
+
+   if (lk) {
+      tl_assert( is_sane_LockN(lk) );
+      tl_assert( lk->guestaddr == (Addr)mutex );
+      if (lk->heldBy) {
+         /* Basically act like we unlocked the lock */
+         record_error_Misc( thr, "pthread_mutex_destroy of a locked mutex" );
+         /* remove lock from locksets of all owning threads */
+         remove_Lock_from_locksets_of_all_owning_Threads( lk );
+         HG_(deleteBag)( lk->heldBy );
+         lk->heldBy = NULL;
+         lk->heldW = False;
+         lk->acquired_at = NULL;
+      }
+      tl_assert( !lk->heldBy );
+      tl_assert( is_sane_LockN(lk) );
+   }
+
+   if (clo_sanity_flags & SCE_LOCKS)
+      all__sanity_check("evh__hg_PTHREAD_MUTEX_DESTROY_PRE");
+}
+
+static void evh__HG_PTHREAD_MUTEX_LOCK_PRE ( ThreadId tid,
+                                             void* mutex, Word isTryLock )
+{
+   /* Just check the mutex is sane; nothing else to do. */
+   // 'mutex' may be invalid - not checked by wrapper
+   Thread* thr;
+   Lock*   lk;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_MUTEX_LOCK_PRE(ctid=%d, mutex=%p)\n", 
+                  (Int)tid, (void*)mutex );
+
+   tl_assert(isTryLock == 0 || isTryLock == 1);
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   lk = map_locks_maybe_lookup( (Addr)mutex );
+
+   if (lk && (lk->kind == LK_rdwr)) {
+      record_error_Misc( thr, "pthread_mutex_lock with a "
+                              "pthread_rwlock_t* argument " );
+   }
+
+   if ( lk 
+        && isTryLock == 0
+        && (lk->kind == LK_nonRec || lk->kind == LK_rdwr)
+        && lk->heldBy
+        && lk->heldW
+        && HG_(elemBag)( lk->heldBy, (Word)thr ) > 0 ) {
+      /* uh, it's a non-recursive lock and we already w-hold it, and
+         this is a real lock operation (not a speculative "tryLock"
+         kind of thing).  Duh.  Deadlock coming up; but at least
+         produce an error message. */
+      record_error_Misc( thr, "Attempt to re-lock a "
+                              "non-recursive lock I already hold" );
+   }
+}
+
+static void evh__HG_PTHREAD_MUTEX_LOCK_POST ( ThreadId tid, void* mutex )
+{
+   // only called if the real library call succeeded - so mutex is sane
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_PTHREAD_MUTEX_LOCK_POST(ctid=%d, mutex=%p)\n", 
+                  (Int)tid, (void*)mutex );
+
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   evhH__post_thread_w_acquires_lock( 
+      thr, 
+      LK_mbRec, /* if not known, create new lock with this LockKind */
+      (Addr)mutex
+   );
+}
+
+static void evh__HG_PTHREAD_MUTEX_UNLOCK_PRE ( ThreadId tid, void* mutex )
+{
+   // 'mutex' may be invalid - not checked by wrapper
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_PTHREAD_MUTEX_UNLOCK_PRE(ctid=%d, mutex=%p)\n", 
+                  (Int)tid, (void*)mutex );
+
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   evhH__pre_thread_releases_lock( thr, (Addr)mutex, False/*!isRDWR*/ );
+}
+
+static void evh__HG_PTHREAD_MUTEX_UNLOCK_POST ( ThreadId tid, void* mutex )
+{
+   // only called if the real library call succeeded - so mutex is sane
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_MUTEX_UNLOCK_POST(ctid=%d, mutex=%p)\n", 
+                  (Int)tid, (void*)mutex );
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // anything we should do here?
+}
+
+
+/* --------------- events to do with CVs --------------- */
+
+/* A mapping from CV to the thread segment which has most recently
+   signalled/broadcasted on it.  This makes it possible to create
+   thread segments to model happens-before events arising from CV
+   signallings/broadcasts.
+*/
+
+/* pthread_mutex_cond* -> Segment* */
+static WordFM* map_cond_to_Segment = NULL;
+
+static void map_cond_to_Segment_INIT ( void ) {
+   if (UNLIKELY(map_cond_to_Segment == NULL)) {
+      map_cond_to_Segment = HG_(newFM)( hg_zalloc, hg_free, NULL );
+      tl_assert(map_cond_to_Segment != NULL);
+   }
+}
+
+static void evh__HG_PTHREAD_COND_SIGNAL_PRE ( ThreadId tid, void* cond )
+{
+   /* 'tid' has signalled on 'cond'.  Start a new segment for this
+      thread, and make a binding from 'cond' to our old segment in the
+      mapping.  This is later used by other thread(s) which
+      successfully exit from a pthread_cond_wait on the same cv; then
+      they know what the signalling segment was, so a dependency edge
+      back to it can be constructed. */
+
+   Thread*   thr;
+   SegmentID new_segid;
+   Segment*  new_seg;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_PTHREAD_COND_SIGNAL_PRE(ctid=%d, cond=%p)\n", 
+                  (Int)tid, (void*)cond );
+
+   map_cond_to_Segment_INIT();
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // error-if: mutex is bogus
+   // error-if: mutex is not locked
+
+   if (clo_happens_before >= 2) {
+      /* create a new segment ... */
+      new_segid = 0; /* bogus */
+      new_seg   = NULL;
+      evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+      tl_assert( is_sane_SegmentID(new_segid) );
+      tl_assert( is_sane_Segment(new_seg) );
+      tl_assert( new_seg->thr == thr );
+      tl_assert( is_sane_Segment(new_seg->prev) );
+      tl_assert( new_seg->prev->vts );
+      new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+
+      /* ... and add the binding. */
+      HG_(addToFM)( map_cond_to_Segment, (Word)cond,
+                                         (Word)(new_seg->prev) );
+   }
+}
+
+/* returns True if it reckons 'mutex' is valid and held by this
+   thread, else False */
+static Bool evh__HG_PTHREAD_COND_WAIT_PRE ( ThreadId tid,
+                                            void* cond, void* mutex )
+{
+   Thread* thr;
+   Lock*   lk;
+   Bool    lk_valid = True;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_COND_WAIT_PRE"
+                  "(ctid=%d, cond=%p, mutex=%p)\n", 
+                  (Int)tid, (void*)cond, (void*)mutex );
+
+   map_cond_to_Segment_INIT();
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   lk = map_locks_maybe_lookup( (Addr)mutex );
+
+   /* Check for stupid mutex arguments.  There are various ways to be
+      a bozo.  Only complain once, though, even if more than one thing
+      is wrong. */
+   if (lk == NULL) {
+      lk_valid = False;
+      record_error_Misc( 
+         thr, 
+         "pthread_cond_{timed}wait called with invalid mutex" );
+   } else {
+      tl_assert( is_sane_LockN(lk) );
+      if (lk->kind == LK_rdwr) {
+         lk_valid = False;
+         record_error_Misc( 
+            thr, "pthread_cond_{timed}wait called with mutex "
+                 "of type pthread_rwlock_t*" );
+      } else
+         if (lk->heldBy == NULL) {
+         lk_valid = False;
+         record_error_Misc( 
+            thr, "pthread_cond_{timed}wait called with un-held mutex");
+      } else
+      if (lk->heldBy != NULL
+          && HG_(elemBag)( lk->heldBy, (Word)thr ) == 0) {
+         lk_valid = False;
+         record_error_Misc( 
+            thr, "pthread_cond_{timed}wait called with mutex "
+                 "held by a different thread" );
+      }
+   }
+
+   // error-if: cond is also associated with a different mutex
+
+   return lk_valid;
+}
+
+static void evh__HG_PTHREAD_COND_WAIT_POST ( ThreadId tid,
+                                             void* cond, void* mutex )
+{
+   /* A pthread_cond_wait(cond, mutex) completed successfully.  Start
+      a new segment for this thread.  Look up the signalling-segment
+      for the 'cond' in the mapping, and add a dependency edge from
+      the new segment back to it. */
+
+   Thread*   thr;
+   SegmentID new_segid;
+   Segment*  new_seg;
+   Segment*  signalling_seg;
+   Bool      found;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_PTHREAD_COND_WAIT_POST"
+                  "(ctid=%d, cond=%p, mutex=%p)\n", 
+                  (Int)tid, (void*)cond, (void*)mutex );
+
+   map_cond_to_Segment_INIT();
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // error-if: cond is also associated with a different mutex
+
+   if (clo_happens_before >= 2) {
+      /* create a new segment ... */
+      new_segid = 0; /* bogus */
+      new_seg   = NULL;
+      evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+      tl_assert( is_sane_SegmentID(new_segid) );
+      tl_assert( is_sane_Segment(new_seg) );
+      tl_assert( new_seg->thr == thr );
+      tl_assert( is_sane_Segment(new_seg->prev) );
+      tl_assert( new_seg->other == NULL);
+
+      /* and find out which thread signalled us; then add a dependency
+         edge back to it. */
+      signalling_seg = NULL;
+      found = HG_(lookupFM)( map_cond_to_Segment, 
+                             NULL, (Word*)(void*)&signalling_seg,
+                                   (Word)cond );
+      if (found) {
+         tl_assert(is_sane_Segment(signalling_seg));
+         tl_assert(new_seg->prev);
+         tl_assert(new_seg->prev->vts);
+         new_seg->other      = signalling_seg;
+         new_seg->other_hint = 's';
+         tl_assert(new_seg->other->vts);
+         new_seg->vts = tickL_and_joinR_VTS( 
+                           new_seg->thr, 
+                           new_seg->prev->vts,
+                           new_seg->other->vts );
+      } else {
+         /* Hmm.  How can a wait on 'cond' succeed if nobody signalled
+            it?  If this happened it would surely be a bug in the
+            threads library.  Or one of those fabled "spurious
+            wakeups". */
+         record_error_Misc( thr, "Bug in libpthread: pthread_cond_wait "
+                                 "succeeded on"
+                                 " without prior pthread_cond_post");
+         tl_assert(new_seg->prev->vts);
+         new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+      }
+   }
+}
+
+
+/* -------------- events to do with rwlocks -------------- */
+
+/* EXPOSITION only */
+static
+void evh__HG_PTHREAD_RWLOCK_INIT_POST( ThreadId tid, void* rwl )
+{
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_RWLOCK_INIT_POST(ctid=%d, %p)\n", 
+                  (Int)tid, (void*)rwl );
+   map_locks_lookup_or_create( LK_rdwr, (Addr)rwl, tid );
+   if (clo_sanity_flags & SCE_LOCKS)
+      all__sanity_check("evh__hg_PTHREAD_RWLOCK_INIT_POST");
+}
+
+static
+void evh__HG_PTHREAD_RWLOCK_DESTROY_PRE( ThreadId tid, void* rwl )
+{
+   Thread* thr;
+   Lock*   lk;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_RWLOCK_DESTROY_PRE(ctid=%d, %p)\n", 
+                  (Int)tid, (void*)rwl );
+
+   thr = map_threads_maybe_lookup( tid );
+   /* cannot fail - Thread* must already exist */
+   tl_assert( is_sane_Thread(thr) );
+
+   lk = map_locks_maybe_lookup( (Addr)rwl );
+
+   if (lk == NULL || lk->kind != LK_rdwr) {
+      record_error_Misc( thr,
+                         "pthread_rwlock_destroy with invalid argument" );
+   }
+
+   if (lk) {
+      tl_assert( is_sane_LockN(lk) );
+      tl_assert( lk->guestaddr == (Addr)rwl );
+      if (lk->heldBy) {
+         /* Basically act like we unlocked the lock */
+         record_error_Misc( thr, "pthread_rwlock_destroy of a locked mutex" );
+         /* remove lock from locksets of all owning threads */
+         remove_Lock_from_locksets_of_all_owning_Threads( lk );
+         HG_(deleteBag)( lk->heldBy );
+         lk->heldBy = NULL;
+         lk->heldW = False;
+      }
+      tl_assert( !lk->heldBy );
+      tl_assert( is_sane_LockN(lk) );
+   }
+
+   if (clo_sanity_flags & SCE_LOCKS)
+      all__sanity_check("evh__hg_PTHREAD_RWLOCK_DESTROY_PRE");
+}
+
+static 
+void evh__HG_PTHREAD_RWLOCK_LOCK_PRE ( ThreadId tid, void* rwl, Word isW )
+{
+   /* Just check the rwl is sane; nothing else to do. */
+   // 'rwl' may be invalid - not checked by wrapper
+   Thread* thr;
+   Lock*   lk;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_RWLOCK_LOCK_PRE(ctid=%d, isW=%d, %p)\n", 
+                  (Int)tid, (Int)isW, (void*)rwl );
+
+   tl_assert(isW == 0 || isW == 1); /* assured us by wrapper */
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   lk = map_locks_maybe_lookup( (Addr)rwl );
+   if ( lk 
+        && (lk->kind == LK_nonRec || lk->kind == LK_mbRec) ) {
+      /* Wrong kind of lock.  Duh.  */
+      record_error_Misc( thr, "pthread_rwlock_{rd,rw}lock with a "
+                              "pthread_mutex_t* argument " );
+   }
+}
+
+static 
+void evh__HG_PTHREAD_RWLOCK_LOCK_POST ( ThreadId tid, void* rwl, Word isW )
+{
+   // only called if the real library call succeeded - so mutex is sane
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_RWLOCK_LOCK_POST(ctid=%d, isW=%d, %p)\n", 
+                  (Int)tid, (Int)isW, (void*)rwl );
+
+   tl_assert(isW == 0 || isW == 1); /* assured us by wrapper */
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   (isW ? evhH__post_thread_w_acquires_lock 
+        : evhH__post_thread_r_acquires_lock)( 
+      thr, 
+      LK_rdwr, /* if not known, create new lock with this LockKind */
+      (Addr)rwl
+   );
+}
+
+static void evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE ( ThreadId tid, void* rwl )
+{
+   // 'rwl' may be invalid - not checked by wrapper
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE(ctid=%d, rwl=%p)\n", 
+                  (Int)tid, (void*)rwl );
+
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   evhH__pre_thread_releases_lock( thr, (Addr)rwl, True/*isRDWR*/ );
+}
+
+static void evh__HG_PTHREAD_RWLOCK_UNLOCK_POST ( ThreadId tid, void* rwl )
+{
+   // only called if the real library call succeeded - so mutex is sane
+   Thread* thr;
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__hg_PTHREAD_RWLOCK_UNLOCK_POST(ctid=%d, rwl=%p)\n", 
+                  (Int)tid, (void*)rwl );
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // anything we should do here?
+}
+
+
+/* --------------- events to do with semaphores --------------- */
+
+/* This is similar but not identical the handling for condition
+   variables. */
+
+/* For each semaphore, we maintain a stack of Segments.  When a 'post'
+   operation is done on a semaphore (unlocking, essentially), a new
+   segment is created for the posting thread, and the old segment is
+   pushed on the semaphore's stack.
+
+   Later, when a (probably different) thread completes 'wait' on the
+   semaphore, we pop a Segment off the semaphore's stack (which should
+   be nonempty).  We start a new segment for the thread and make it
+   also depend on the just-popped segment.  This mechanism creates
+   dependencies between posters and waiters of the semaphore.
+
+   It may not be necessary to use a stack - perhaps a bag of Segments
+   would do.  But we do need to keep track of how many unused-up posts
+   have happened for the semaphore.
+
+   Imagine T1 and T2 both post once on a semphore S, and T3 waits
+   twice on S.  T3 cannot complete its waits without both T1 and T2
+   posting.  The above mechanism will ensure that T3 acquires
+   dependencies on both T1 and T2.
+*/
+
+/* sem_t* -> XArray* Segment* */
+static WordFM* map_sem_to_Segment_stack = NULL;
+
+static void map_sem_to_Segment_stack_INIT ( void ) {
+   if (map_sem_to_Segment_stack == NULL) {
+      map_sem_to_Segment_stack = HG_(newFM)( hg_zalloc, hg_free, NULL );
+      tl_assert(map_sem_to_Segment_stack != NULL);
+   }
+}
+
+static void push_Segment_for_sem ( void* sem, Segment* seg ) {
+   XArray* xa;
+   tl_assert(seg);
+   map_sem_to_Segment_stack_INIT();
+   if (HG_(lookupFM)( map_sem_to_Segment_stack, 
+                      NULL, (Word*)(void*)&xa, (Word)sem )) {
+      tl_assert(xa);
+      VG_(addToXA)( xa, &seg );
+   } else {
+      xa = VG_(newXA)( hg_zalloc, hg_free, sizeof(Segment*) );
+      VG_(addToXA)( xa, &seg );
+      HG_(addToFM)( map_sem_to_Segment_stack, (Word)sem, (Word)xa );
+   }
+}
+
+static Segment* mb_pop_Segment_for_sem ( void* sem ) {
+   XArray*  xa;
+   Segment* seg;
+   map_sem_to_Segment_stack_INIT();
+   if (HG_(lookupFM)( map_sem_to_Segment_stack, 
+                      NULL, (Word*)(void*)&xa, (Word)sem )) {
+      /* xa is the stack for this semaphore. */
+      Word sz = VG_(sizeXA)( xa );
+      tl_assert(sz >= 0);
+      if (sz == 0)
+         return NULL; /* odd, the stack is empty */
+      seg = *(Segment**)VG_(indexXA)( xa, sz-1 );
+      tl_assert(seg);
+      VG_(dropTailXA)( xa, 1 );
+      return seg;
+   } else {
+      /* hmm, that's odd.  No stack for this semaphore. */
+      return NULL;
+   }
+}
+
+static void evh__HG_POSIX_SEM_ZAPSTACK ( ThreadId tid, void* sem )
+{
+   Segment* seg;
+
+   /* Empty out the semaphore's segment stack.  Occurs at
+      sem_init and sem_destroy time. */
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_POSIX_SEM_ZAPSTACK(ctid=%d, sem=%p)\n", 
+                  (Int)tid, (void*)sem );
+
+   /* This is stupid, but at least it's easy. */
+   do {
+     seg = mb_pop_Segment_for_sem( sem );
+   } while (seg);
+
+   tl_assert(!seg);
+}
+
+static void evh__HG_POSIX_SEMPOST_PRE ( ThreadId tid, void* sem )
+{
+   /* 'tid' has posted on 'sem'.  Start a new segment for this thread,
+      and push the old segment on a stack of segments associated with
+      'sem'.  This is later used by other thread(s) which successfully
+      exit from a sem_wait on the same sem; then they know what the
+      posting segment was, so a dependency edge back to it can be
+      constructed. */
+
+   Thread*   thr;
+   SegmentID new_segid;
+   Segment*  new_seg;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_POSIX_SEMPOST_PRE(ctid=%d, sem=%p)\n", 
+                  (Int)tid, (void*)sem );
+
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // error-if: sem is bogus
+
+   if (clo_happens_before >= 2) {
+      /* create a new segment ... */
+      new_segid = 0; /* bogus */
+      new_seg   = NULL;
+      evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+      tl_assert( is_sane_SegmentID(new_segid) );
+      tl_assert( is_sane_Segment(new_seg) );
+      tl_assert( new_seg->thr == thr );
+      tl_assert( is_sane_Segment(new_seg->prev) );
+      tl_assert( new_seg->prev->vts );
+      new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+
+      /* ... and add the binding. */
+      push_Segment_for_sem( sem, new_seg->prev );
+   }
+}
+
+static void evh__HG_POSIX_SEMWAIT_POST ( ThreadId tid, void* sem )
+{
+   /* A sem_wait(sem) completed successfully.  Start a new segment for
+      this thread.  Pop the posting-segment for the 'sem' in the
+      mapping, and add a dependency edge from the new segment back to
+      it. */
+
+   Thread*   thr;
+   SegmentID new_segid;
+   Segment*  new_seg;
+   Segment*  posting_seg;
+
+   if (SHOW_EVENTS >= 1)
+      VG_(printf)("evh__HG_POSIX_SEMWAIT_POST(ctid=%d, sem=%p)\n", 
+                  (Int)tid, (void*)sem );
+
+   thr = map_threads_maybe_lookup( tid );
+   tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+   // error-if: sem is bogus
+
+   if (clo_happens_before >= 2) {
+      /* create a new segment ... */
+      new_segid = 0; /* bogus */
+      new_seg   = NULL;
+      evhH__start_new_segment_for_thread( &new_segid, &new_seg, thr );
+      tl_assert( is_sane_SegmentID(new_segid) );
+      tl_assert( is_sane_Segment(new_seg) );
+      tl_assert( new_seg->thr == thr );
+      tl_assert( is_sane_Segment(new_seg->prev) );
+      tl_assert( new_seg->other == NULL);
+
+      /* and find out which thread posted last on sem; then add a
+         dependency edge back to it. */
+      posting_seg = mb_pop_Segment_for_sem( sem );
+      if (posting_seg) {
+         tl_assert(is_sane_Segment(posting_seg));
+         tl_assert(new_seg->prev);
+         tl_assert(new_seg->prev->vts);
+         new_seg->other      = posting_seg;
+         new_seg->other_hint = 'S';
+         tl_assert(new_seg->other->vts);
+         new_seg->vts = tickL_and_joinR_VTS( 
+                           new_seg->thr, 
+                           new_seg->prev->vts,
+                           new_seg->other->vts );
+      } else {
+         /* Hmm.  How can a wait on 'sem' succeed if nobody posted to
+            it?  If this happened it would surely be a bug in the
+            threads library. */
+         record_error_Misc( thr, "Bug in libpthread: sem_wait succeeded on"
+                                 " semaphore without prior sem_post");
+         tl_assert(new_seg->prev->vts);
+         new_seg->vts = tick_VTS( new_seg->thr, new_seg->prev->vts );
+      }
+   }
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Lock acquisition order monitoring                      ---*/
+/*--------------------------------------------------------------*/
+
+/* FIXME: here are some optimisations still to do in
+          laog__pre_thread_acquires_lock.
+
+   The graph is structured so that if L1 --*--> L2 then L1 must be
+   acquired before L2.
+
+   The common case is that some thread T holds (eg) L1 L2 and L3 and
+   is repeatedly acquiring and releasing Ln, and there is no ordering
+   error in what it is doing.  Hence it repeatly:
+
+   (1) searches laog to see if Ln --*--> {L1,L2,L3}, which always 
+       produces the answer No (because there is no error).
+
+   (2) adds edges {L1,L2,L3} --> Ln to laog, which are already present
+       (because they already got added the first time T acquired Ln).
+
+   Hence cache these two events:
+
+   (1) Cache result of the query from last time.  Invalidate the cache
+       any time any edges are added to or deleted from laog.
+
+   (2) Cache these add-edge requests and ignore them if said edges
+       have already been added to laog.  Invalidate the cache any time
+       any edges are deleted from laog.
+*/
+
+typedef
+   struct {
+      WordSetID inns; /* in univ_laog */
+      WordSetID outs; /* in univ_laog */
+   }
+   LAOGLinks;
+
+/* lock order acquisition graph */
+static WordFM* laog = NULL; /* WordFM Lock* LAOGLinks* */
+
+/* EXPOSITION ONLY: for each edge in 'laog', record the two places
+   where that edge was created, so that we can show the user later if
+   we need to. */
+typedef
+   struct {
+      Addr        src_ga; /* Lock guest addresses for */
+      Addr        dst_ga; /* src/dst of the edge */
+      ExeContext* src_ec; /* And corresponding places where that */
+      ExeContext* dst_ec; /* ordering was established */
+   }
+   LAOGLinkExposition;
+
+static Word cmp_LAOGLinkExposition ( Word llx1W, Word llx2W ) {
+   /* Compare LAOGLinkExposition*s by (src_ga,dst_ga) field pair. */
+   LAOGLinkExposition* llx1 = (LAOGLinkExposition*)llx1W;
+   LAOGLinkExposition* llx2 = (LAOGLinkExposition*)llx2W;
+   if (llx1->src_ga < llx2->src_ga) return -1;
+   if (llx1->src_ga > llx2->src_ga) return  1;
+   if (llx1->dst_ga < llx2->dst_ga) return -1;
+   if (llx1->dst_ga > llx2->dst_ga) return  1;
+   return 0;
+}
+
+static WordFM* laog_exposition = NULL; /* WordFM LAOGLinkExposition* NULL */
+/* end EXPOSITION ONLY */
+
+
+static void laog__show ( Char* who ) {
+   Word i, ws_size;
+   Word* ws_words;
+   Lock* me;
+   LAOGLinks* links;
+   VG_(printf)("laog (requested by %s) {\n", who);
+   HG_(initIterFM)( laog );
+   me = NULL;
+   links = NULL;
+   while (HG_(nextIterFM)( laog, (Word*)(void*)&me,
+                                 (Word*)(void*)&links )) {
+      tl_assert(me);
+      tl_assert(links);
+      VG_(printf)("   node %p:\n", me);
+      HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->inns );
+      for (i = 0; i < ws_size; i++)
+         VG_(printf)("      inn %p\n", ws_words[i] );
+      HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->outs );
+      for (i = 0; i < ws_size; i++)
+         VG_(printf)("      out %p\n", ws_words[i] );
+      me = NULL;
+      links = NULL;
+   }
+   HG_(doneIterFM)( laog );
+   VG_(printf)("}\n");
+}
+
+__attribute__((noinline))
+static void laog__add_edge ( Lock* src, Lock* dst ) {
+   Word       keyW;
+   LAOGLinks* links;
+   Bool       presentF, presentR;
+   if (0) VG_(printf)("laog__add_edge %p %p\n", src, dst);
+
+   /* Take the opportunity to sanity check the graph.  Record in
+      presentF if there is already a src->dst mapping in this node's
+      forwards links, and presentR if there is already a src->dst
+      mapping in this node's backwards links.  They should agree!
+      Also, we need to know whether the edge was already present so as
+      to decide whether or not to update the link details mapping.  We
+      can compute presentF and presentR essentially for free, so may
+      as well do this always. */
+   presentF = presentR = False;
+
+   /* Update the out edges for src */
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)src )) {
+      WordSetID outs_new;
+      tl_assert(links);
+      tl_assert(keyW == (Word)src);
+      outs_new = HG_(addToWS)( univ_laog, links->outs, (Word)dst );
+      presentF = outs_new == links->outs;
+      links->outs = outs_new;
+   } else {
+      links = hg_zalloc(sizeof(LAOGLinks));
+      links->inns = HG_(emptyWS)( univ_laog );
+      links->outs = HG_(singletonWS)( univ_laog, (Word)dst );
+      HG_(addToFM)( laog, (Word)src, (Word)links );
+   }
+   /* Update the in edges for dst */
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)dst )) {
+      WordSetID inns_new;
+      tl_assert(links);
+      tl_assert(keyW == (Word)dst);
+      inns_new = HG_(addToWS)( univ_laog, links->inns, (Word)src );
+      presentR = inns_new == links->inns;
+      links->inns = inns_new;
+   } else {
+      links = hg_zalloc(sizeof(LAOGLinks));
+      links->inns = HG_(singletonWS)( univ_laog, (Word)src );
+      links->outs = HG_(emptyWS)( univ_laog );
+      HG_(addToFM)( laog, (Word)dst, (Word)links );
+   }
+
+   tl_assert( (presentF && presentR) || (!presentF && !presentR) );
+
+   if (!presentF && src->acquired_at && dst->acquired_at) {
+      LAOGLinkExposition expo;
+      /* If this edge is entering the graph, and we have acquired_at
+         information for both src and dst, record those acquisition
+         points.  Hence, if there is later a violation of this
+         ordering, we can show the user the two places in which the
+         required src-dst ordering was previously established. */
+      if (0) VG_(printf)("acquire edge %p %p\n", 
+                         src->guestaddr, dst->guestaddr);
+      expo.src_ga = src->guestaddr;
+      expo.dst_ga = dst->guestaddr;
+      expo.src_ec = NULL;
+      expo.dst_ec = NULL;
+      tl_assert(laog_exposition);
+      if (HG_(lookupFM)( laog_exposition, NULL, NULL, (Word)&expo )) {
+         /* we already have it; do nothing */
+      } else {
+         LAOGLinkExposition* expo2 = hg_zalloc(sizeof(LAOGLinkExposition));
+         expo2->src_ga = src->guestaddr;
+         expo2->dst_ga = dst->guestaddr;
+         expo2->src_ec = src->acquired_at;
+         expo2->dst_ec = dst->acquired_at;
+         HG_(addToFM)( laog_exposition, (Word)expo2, (Word)NULL );
+      }
+   }
+}
+
+__attribute__((noinline))
+static void laog__del_edge ( Lock* src, Lock* dst ) {
+   Word       keyW;
+   LAOGLinks* links;
+   if (0) VG_(printf)("laog__del_edge %p %p\n", src, dst);
+   /* Update the out edges for src */
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)src )) {
+      tl_assert(links);
+      tl_assert(keyW == (Word)src);
+      links->outs = HG_(delFromWS)( univ_laog, links->outs, (Word)dst );
+   }
+   /* Update the in edges for dst */
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)dst )) {
+      tl_assert(links);
+      tl_assert(keyW == (Word)dst);
+      links->inns = HG_(delFromWS)( univ_laog, links->inns, (Word)src );
+   }
+}
+
+__attribute__((noinline))
+static WordSetID /* in univ_laog */ laog__succs ( Lock* lk ) {
+   Word       keyW;
+   LAOGLinks* links;
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)lk )) {
+      tl_assert(links);
+      tl_assert(keyW == (Word)lk);
+      return links->outs;
+   } else {
+      return HG_(emptyWS)( univ_laog );
+   }
+}
+
+__attribute__((noinline))
+static WordSetID /* in univ_laog */ laog__preds ( Lock* lk ) {
+   Word       keyW;
+   LAOGLinks* links;
+   keyW  = 0;
+   links = NULL;
+   if (HG_(lookupFM)( laog, &keyW, (Word*)(void*)&links, (Word)lk )) {
+      tl_assert(links);
+      tl_assert(keyW == (Word)lk);
+      return links->inns;
+   } else {
+      return HG_(emptyWS)( univ_laog );
+   }
+}
+
+__attribute__((noinline))
+static void laog__sanity_check ( Char* who ) {
+   Word i, ws_size;
+   Word* ws_words;
+   Lock* me;
+   LAOGLinks* links;
+   if ( !laog )
+      return; /* nothing much we can do */
+   HG_(initIterFM)( laog );
+   me = NULL;
+   links = NULL;
+   if (0) VG_(printf)("laog sanity check\n");
+   while (HG_(nextIterFM)( laog, (Word*)(void*)&me,
+                                 (Word*)(void*)&links )) {
+      tl_assert(me);
+      tl_assert(links);
+      HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->inns );
+      for (i = 0; i < ws_size; i++) {
+         if ( ! HG_(elemWS)( univ_laog, 
+                             laog__succs( (Lock*)ws_words[i] ), 
+                             (Word)me ))
+            goto bad;
+      }
+      HG_(getPayloadWS)( &ws_words, &ws_size, univ_laog, links->outs );
+      for (i = 0; i < ws_size; i++) {
+         if ( ! HG_(elemWS)( univ_laog, 
+                             laog__preds( (Lock*)ws_words[i] ), 
+                             (Word)me ))
+            goto bad;
+      }
+      me = NULL;
+      links = NULL;
+   }
+   HG_(doneIterFM)( laog );
+   return;
+
+  bad:
+   VG_(printf)("laog__sanity_check(%s) FAILED\n", who);
+   laog__show(who);
+   tl_assert(0);
+}
+
+/* If there is a path in laog from 'src' to any of the elements in
+   'dst', return an arbitrarily chosen element of 'dst' reachable from
+   'src'.  If no path exist from 'src' to any element in 'dst', return
+   NULL. */
+__attribute__((noinline))
+static
+Lock* laog__do_dfs_from_to ( Lock* src, WordSetID dsts /* univ_lsets */ )
+{
+   Lock*     ret;
+   Word      i, ssz;
+   XArray*   stack;   /* of Lock* */
+   WordFM*   visited; /* Lock* -> void, iow, Set(Lock*) */
+   Lock*     here;
+   WordSetID succs;
+   Word      succs_size;
+   Word*     succs_words;
+   //laog__sanity_check();
+
+   /* If the destination set is empty, we can never get there from
+      'src' :-), so don't bother to try */
+   if (HG_(isEmptyWS)( univ_lsets, dsts ))
+      return NULL;
+
+   ret     = NULL;
+   stack   = VG_(newXA)( hg_zalloc, hg_free, sizeof(Lock*) );
+   visited = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+
+   (void) VG_(addToXA)( stack, &src );
+
+   while (True) {
+
+      ssz = VG_(sizeXA)( stack );
+
+      if (ssz == 0) { ret = NULL; break; }
+
+      here = *(Lock**) VG_(indexXA)( stack, ssz-1 );
+      VG_(dropTailXA)( stack, 1 );
+
+      if (HG_(elemWS)( univ_lsets, dsts, (Word)here )) { ret = here; break; }
+
+      if (HG_(lookupFM)( visited, NULL, NULL, (Word)here ))
+         continue;
+
+      HG_(addToFM)( visited, (Word)here, 0 );
+
+      succs = laog__succs( here );
+      HG_(getPayloadWS)( &succs_words, &succs_size, univ_laog, succs );
+      for (i = 0; i < succs_size; i++)
+         (void) VG_(addToXA)( stack, &succs_words[i] );
+   }
+
+   HG_(deleteFM)( visited, NULL, NULL );
+   VG_(deleteXA)( stack );
+   return ret;
+}
+
+
+/* Thread 'thr' is acquiring 'lk'.  Check for inconsistent ordering
+   between 'lk' and the locks already held by 'thr' and issue a
+   complaint if so.  Also, update the ordering graph appropriately.
+*/
+__attribute__((noinline))
+static void laog__pre_thread_acquires_lock ( 
+               Thread* thr, /* NB: BEFORE lock is added */
+               Lock*   lk
+            )
+{
+   Word*    ls_words;
+   Word     ls_size, i;
+   Lock*    other;
+
+   /* It may be that 'thr' already holds 'lk' and is recursively
+      relocking in.  In this case we just ignore the call. */
+   /* NB: univ_lsets really is correct here */
+   if (HG_(elemWS)( univ_lsets, thr->locksetA, (Word)lk ))
+      return;
+
+   if (!laog)
+      laog = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+   if (!laog_exposition)
+      laog_exposition = HG_(newFM)( hg_zalloc, hg_free, 
+                                    cmp_LAOGLinkExposition );
+
+   /* First, the check.  Complain if there is any path in laog from lk
+      to any of the locks already held by thr, since if any such path
+      existed, it would mean that previously lk was acquired before
+      (rather than after, as we are doing here) at least one of those
+      locks.
+   */
+   other = laog__do_dfs_from_to(lk, thr->locksetA);
+   if (other) {
+      LAOGLinkExposition key, *found;
+      /* So we managed to find a path lk --*--> other in the graph,
+         which implies that 'lk' should have been acquired before
+         'other' but is in fact being acquired afterwards.  We present
+         the lk/other arguments to record_error_LockOrder in the order
+         in which they should have been acquired. */
+      /* Go look in the laog_exposition mapping, to find the allocation
+         points for this edge, so we can show the user. */
+      key.src_ga = lk->guestaddr;
+      key.dst_ga = other->guestaddr;
+      key.src_ec = NULL;
+      key.dst_ec = NULL;
+      found = NULL;
+      if (HG_(lookupFM)( laog_exposition,
+                         (Word*)(void*)&found, NULL, (Word)&key )) {
+         tl_assert(found != &key);
+         tl_assert(found->src_ga == key.src_ga);
+         tl_assert(found->dst_ga == key.dst_ga);
+         tl_assert(found->src_ec);
+         tl_assert(found->dst_ec);
+         record_error_LockOrder( thr, 
+                                 lk->guestaddr, other->guestaddr,
+                                 found->src_ec, found->dst_ec );
+      } else {
+         /* Hmm.  This can't happen (can it?) */
+         record_error_LockOrder( thr, 
+                                 lk->guestaddr,        other->guestaddr,
+                                 NULL, NULL );
+      }
+   }
+
+   /* Second, add to laog the pairs
+        (old, lk)  |  old <- locks already held by thr
+      Since both old and lk are currently held by thr, their acquired_at
+      fields must be non-NULL.
+   */
+   tl_assert(lk->acquired_at);
+   HG_(getPayloadWS)( &ls_words, &ls_size, univ_lsets, thr->locksetA );
+   for (i = 0; i < ls_size; i++) {
+      Lock* old = (Lock*)ls_words[i];
+      tl_assert(old->acquired_at);
+      laog__add_edge( old, lk );
+   }
+
+   /* Why "except_Locks" ?  We're here because a lock is being
+      acquired by a thread, and we're in an inconsistent state here.
+      See the call points in evhH__post_thread_{r,w}_acquires_lock.
+      When called in this inconsistent state, locks__sanity_check duly
+      barfs. */
+   if (clo_sanity_flags & SCE_LAOG)
+      all_except_Locks__sanity_check("laog__pre_thread_acquires_lock-post");
+}
+
+
+/* Delete from 'laog' any pair mentioning a lock in locksToDelete */
+
+__attribute__((noinline))
+static void laog__handle_one_lock_deletion ( Lock* lk )
+{
+   WordSetID preds, succs;
+   Word preds_size, succs_size, i, j;
+   Word *preds_words, *succs_words;
+
+   preds = laog__preds( lk );
+   succs = laog__succs( lk );
+
+   HG_(getPayloadWS)( &preds_words, &preds_size, univ_laog, preds );
+   for (i = 0; i < preds_size; i++)
+      laog__del_edge( (Lock*)preds_words[i], lk );
+
+   HG_(getPayloadWS)( &succs_words, &succs_size, univ_laog, succs );
+   for (j = 0; j < succs_size; j++)
+      laog__del_edge( lk, (Lock*)succs_words[j] );
+
+   for (i = 0; i < preds_size; i++) {
+      for (j = 0; j < succs_size; j++) {
+         if (preds_words[i] != succs_words[j]) {
+            /* This can pass unlocked locks to laog__add_edge, since
+               we're deleting stuff.  So their acquired_at fields may
+               be NULL. */
+            laog__add_edge( (Lock*)preds_words[i], (Lock*)succs_words[j] );
+         }
+      }
+   }
+}
+
+__attribute__((noinline))
+static void laog__handle_lock_deletions (
+               WordSetID /* in univ_laog */ locksToDelete
+            )
+{
+   Word  i, ws_size;
+   Word* ws_words;
+
+   if (!laog)
+      laog = HG_(newFM)( hg_zalloc, hg_free, NULL/*unboxedcmp*/ );
+   if (!laog_exposition)
+      laog_exposition = HG_(newFM)( hg_zalloc, hg_free, 
+                                    cmp_LAOGLinkExposition );
+
+   HG_(getPayloadWS)( &ws_words, &ws_size, univ_lsets, locksToDelete );
+   for (i = 0; i < ws_size; i++)
+      laog__handle_one_lock_deletion( (Lock*)ws_words[i] );
+
+   if (clo_sanity_flags & SCE_LAOG)
+      all__sanity_check("laog__handle_lock_deletions-post");
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Malloc/free replacements                               ---*/
+/*--------------------------------------------------------------*/
+
+typedef
+   struct {
+      void*       next;    /* required by m_hashtable */
+      Addr        payload; /* ptr to actual block    */
+      SizeT       szB;     /* size requested         */
+      ExeContext* where;   /* where it was allocated */
+      Thread*     thr;     /* allocating thread      */
+   }
+   MallocMeta;
+
+/* A hash table of MallocMetas, used to track malloc'd blocks
+   (obviously). */
+static VgHashTable hg_mallocmeta_table = NULL;
+
+
+static MallocMeta* new_MallocMeta ( void ) {
+   MallocMeta* md = hg_zalloc( sizeof(MallocMeta) );
+   tl_assert(md);
+   return md;
+}
+static void delete_MallocMeta ( MallocMeta* md ) {
+   hg_free(md);
+}
+
+
+/* Allocate a client block and set up the metadata for it. */
+
+static
+void* handle_alloc ( ThreadId tid, 
+                     SizeT szB, SizeT alignB, Bool is_zeroed )
+{
+   Addr        p;
+   MallocMeta* md;
+
+   tl_assert( ((SSizeT)szB) >= 0 );
+   p = (Addr)VG_(cli_malloc)(alignB, szB);
+   if (!p) {
+      return NULL;
+   }
+   if (is_zeroed)
+      VG_(memset)((void*)p, 0, szB);
+
+   /* Note that map_threads_lookup must succeed (cannot assert), since
+      memory can only be allocated by currently alive threads, hence
+      they must have an entry in map_threads. */
+   md = new_MallocMeta();
+   md->payload = p;
+   md->szB     = szB;
+   md->where   = VG_(record_ExeContext)( tid, 0 );
+   md->thr     = map_threads_lookup( tid );
+
+   VG_(HT_add_node)( hg_mallocmeta_table, (VgHashNode*)md );
+
+   /* Tell the lower level memory wranglers. */
+   evh__new_mem_heap( p, szB, is_zeroed );
+
+   return (void*)p;
+}
+
+/* Re the checks for less-than-zero (also in hg_cli__realloc below):
+   Cast to a signed type to catch any unexpectedly negative args.
+   We're assuming here that the size asked for is not greater than
+   2^31 bytes (for 32-bit platforms) or 2^63 bytes (for 64-bit
+   platforms). */
+static void* hg_cli__malloc ( ThreadId tid, SizeT n ) {
+   if (((SSizeT)n) < 0) return NULL;
+   return handle_alloc ( tid, n, VG_(clo_alignment),
+                         /*is_zeroed*/False );
+}
+static void* hg_cli____builtin_new ( ThreadId tid, SizeT n ) {
+   if (((SSizeT)n) < 0) return NULL;
+   return handle_alloc ( tid, n, VG_(clo_alignment),
+                         /*is_zeroed*/False );
+}
+static void* hg_cli____builtin_vec_new ( ThreadId tid, SizeT n ) {
+   if (((SSizeT)n) < 0) return NULL;
+   return handle_alloc ( tid, n, VG_(clo_alignment), 
+                         /*is_zeroed*/False );
+}
+static void* hg_cli__memalign ( ThreadId tid, SizeT align, SizeT n ) {
+   if (((SSizeT)n) < 0) return NULL;
+   return handle_alloc ( tid, n, align, 
+                         /*is_zeroed*/False );
+}
+static void* hg_cli__calloc ( ThreadId tid, SizeT nmemb, SizeT size1 ) {
+   if ( ((SSizeT)nmemb) < 0 || ((SSizeT)size1) < 0 ) return NULL;
+   return handle_alloc ( tid, nmemb*size1, VG_(clo_alignment),
+                         /*is_zeroed*/True );
+}
+
+
+/* Free a client block, including getting rid of the relevant
+   metadata. */
+
+static void handle_free ( ThreadId tid, void* p )
+{
+   MallocMeta *md, *old_md;
+   SizeT      szB;
+
+   /* First see if we can find the metadata for 'p'. */
+   md = (MallocMeta*) VG_(HT_lookup)( hg_mallocmeta_table, (UWord)p );
+   if (!md)
+      return; /* apparently freeing a bogus address.  Oh well. */
+
+   tl_assert(md->payload == (Addr)p);
+   szB = md->szB;
+
+   /* Nuke the metadata block */
+   old_md = (MallocMeta*)
+            VG_(HT_remove)( hg_mallocmeta_table, (UWord)p );
+   tl_assert(old_md); /* it must be present - we just found it */
+   tl_assert(old_md == md);
+   tl_assert(old_md->payload == (Addr)p);
+
+   VG_(cli_free)((void*)old_md->payload);
+   delete_MallocMeta(old_md);
+
+   /* Tell the lower level memory wranglers. */
+   evh__die_mem_heap( (Addr)p, szB );
+}
+
+static void hg_cli__free ( ThreadId tid, void* p ) {
+   handle_free(tid, p);
+}
+static void hg_cli____builtin_delete ( ThreadId tid, void* p ) {
+   handle_free(tid, p);
+}
+static void hg_cli____builtin_vec_delete ( ThreadId tid, void* p ) {
+   handle_free(tid, p);
+}
+
+
+static void* hg_cli__realloc ( ThreadId tid, void* payloadV, SizeT new_size )
+{
+   MallocMeta *md, *md_new, *md_tmp;
+   SizeT      i;
+
+   Addr payload = (Addr)payloadV;
+
+   if (((SSizeT)new_size) < 0) return NULL;
+
+   md = (MallocMeta*) VG_(HT_lookup)( hg_mallocmeta_table, (UWord)payload );
+   if (!md)
+      return NULL; /* apparently realloc-ing a bogus address.  Oh well. */
+  
+   tl_assert(md->payload == payload);
+
+   if (md->szB == new_size) {
+      /* size unchanged */
+      md->where = VG_(record_ExeContext)(tid, 0);
+      return payloadV;
+   }
+
+   if (md->szB > new_size) {
+      /* new size is smaller */
+      md->szB   = new_size;
+      md->where = VG_(record_ExeContext)(tid, 0);
+      evh__die_mem_heap( md->payload + new_size, md->szB - new_size );
+      return payloadV;
+   }
+
+   /* else */ {
+      /* new size is bigger */
+      Addr p_new = (Addr)VG_(cli_malloc)(VG_(clo_alignment), new_size);
+
+      /* First half kept and copied, second half new */
+      // FIXME: shouldn't we use a copier which implements the
+      // memory state machine?
+      shadow_mem_copy_range( payload, p_new, md->szB );
+      evh__new_mem_heap ( p_new + md->szB, new_size - md->szB,
+                           /*inited*/False );
+      /* FIXME: can anything funny happen here?  specifically, if the
+         old range contained a lock, then die_mem_heap will complain.
+         Is that the correct behaviour?  Not sure. */
+      evh__die_mem_heap( payload, md->szB );
+
+      /* Copy from old to new */
+      for (i = 0; i < md->szB; i++)
+         ((UChar*)p_new)[i] = ((UChar*)payload)[i];
+
+      /* Because the metadata hash table is index by payload address,
+         we have to get rid of the old hash table entry and make a new
+         one.  We can't just modify the existing metadata in place,
+         because then it would (almost certainly) be in the wrong hash
+         chain. */
+      md_new = new_MallocMeta();
+      *md_new = *md;
+
+      md_tmp = VG_(HT_remove)( hg_mallocmeta_table, payload );
+      tl_assert(md_tmp);
+      tl_assert(md_tmp == md);
+
+      VG_(cli_free)((void*)md->payload);
+      delete_MallocMeta(md);
+
+      /* Update fields */
+      md_new->where   = VG_(record_ExeContext)( tid, 0 );
+      md_new->szB     = new_size;
+      md_new->payload = p_new;
+      md_new->thr     = map_threads_lookup( tid );
+
+      /* and add */
+      VG_(HT_add_node)( hg_mallocmeta_table, (VgHashNode*)md_new );
+
+      return (void*)p_new;
+   }  
+}
+
+
+/*--------------------------------------------------------------*/
+/*--- Instrumentation                                        ---*/
+/*--------------------------------------------------------------*/
+
+static void instrument_mem_access ( IRSB*   bbOut, 
+                                    IRExpr* addr,
+                                    Int     szB,
+                                    Bool    isStore,
+                                    Int     hWordTy_szB )
+{
+   IRType   tyAddr   = Ity_INVALID;
+   HChar*   hName    = NULL;
+   void*    hAddr    = NULL;
+   Int      regparms = 0;
+   IRExpr** argv     = NULL;
+   IRDirty* di       = NULL;
+
+   tl_assert(isIRAtom(addr));
+   tl_assert(hWordTy_szB == 4 || hWordTy_szB == 8);
+
+   tyAddr = typeOfIRExpr( bbOut->tyenv, addr );
+   tl_assert(tyAddr == Ity_I32 || tyAddr == Ity_I64);
+
+   /* So the effective address is in 'addr' now. */
+   regparms = 1; // unless stated otherwise
+   if (isStore) {
+      switch (szB) {
+         case 1:
+            hName = "evh__mem_help_write_1";
+            hAddr = &evh__mem_help_write_1;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 2:
+            hName = "evh__mem_help_write_2";
+            hAddr = &evh__mem_help_write_2;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 4:
+            hName = "evh__mem_help_write_4";
+            hAddr = &evh__mem_help_write_4;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 8:
+            hName = "evh__mem_help_write_8";
+            hAddr = &evh__mem_help_write_8;
+            argv = mkIRExprVec_1( addr );
+            break;
+         default:
+            tl_assert(szB > 8 && szB <= 512); /* stay sane */
+            regparms = 2;
+            hName = "evh__mem_help_write_N";
+            hAddr = &evh__mem_help_write_N;
+            argv = mkIRExprVec_2( addr, mkIRExpr_HWord( szB ));
+            break;
+      }
+   } else {
+      switch (szB) {
+         case 1:
+            hName = "evh__mem_help_read_1";
+            hAddr = &evh__mem_help_read_1;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 2:
+            hName = "evh__mem_help_read_2";
+            hAddr = &evh__mem_help_read_2;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 4:
+            hName = "evh__mem_help_read_4";
+            hAddr = &evh__mem_help_read_4;
+            argv = mkIRExprVec_1( addr );
+            break;
+         case 8:
+            hName = "evh__mem_help_read_8";
+            hAddr = &evh__mem_help_read_8;
+            argv = mkIRExprVec_1( addr );
+            break;
+         default: 
+            tl_assert(szB > 8 && szB <= 512); /* stay sane */
+            regparms = 2;
+            hName = "evh__mem_help_read_N";
+            hAddr = &evh__mem_help_read_N;
+            argv = mkIRExprVec_2( addr, mkIRExpr_HWord( szB ));
+            break;
+      }
+   }
+
+   /* Add the helper. */
+   tl_assert(hName);
+   tl_assert(hAddr);
+   tl_assert(argv);
+   di = unsafeIRDirty_0_N( regparms,
+                           hName, VG_(fnptr_to_fnentry)( hAddr ),
+                           argv );
+   addStmtToIRSB( bbOut, IRStmt_Dirty(di) );
+}
+
+
+static void instrument_memory_bus_event ( IRSB* bbOut, IRMBusEvent event )
+{
+   switch (event) {
+      case Imbe_Fence:
+         break; /* not interesting */
+      case Imbe_BusLock:
+      case Imbe_BusUnlock:
+         addStmtToIRSB(
+            bbOut,
+            IRStmt_Dirty(
+               unsafeIRDirty_0_N( 
+                  0/*regparms*/, 
+                  event == Imbe_BusLock ? "evh__bus_lock"
+                                        : "evh__bus_unlock",
+                  VG_(fnptr_to_fnentry)(
+                     event == Imbe_BusLock ? &evh__bus_lock 
+                                           : &evh__bus_unlock 
+                  ),
+                  mkIRExprVec_0() 
+               )
+            )
+         );
+         break;
+      default:
+         tl_assert(0);
+   }
+}
+
+
+static
+IRSB* hg_instrument ( VgCallbackClosure* closure,
+                      IRSB* bbIn,
+                      VexGuestLayout* layout,
+                      VexGuestExtents* vge,
+                      IRType gWordTy, IRType hWordTy )
+{
+   Int   i;
+   IRSB* bbOut;
+
+   if (gWordTy != hWordTy) {
+      /* We don't currently support this case. */
+      VG_(tool_panic)("host/guest word size mismatch");
+   }
+
+   /* Set up BB */
+   bbOut           = emptyIRSB();
+   bbOut->tyenv    = deepCopyIRTypeEnv(bbIn->tyenv);
+   bbOut->next     = deepCopyIRExpr(bbIn->next);
+   bbOut->jumpkind = bbIn->jumpkind;
+
+   // Copy verbatim any IR preamble preceding the first IMark
+   i = 0;
+   while (i < bbIn->stmts_used && bbIn->stmts[i]->tag != Ist_IMark) {
+      addStmtToIRSB( bbOut, bbIn->stmts[i] );
+      i++;
+   }
+
+   for (/*use current i*/; i < bbIn->stmts_used; i++) {
+      IRStmt* st = bbIn->stmts[i];
+      tl_assert(st);
+      tl_assert(isFlatIRStmt(st));
+      switch (st->tag) {
+         case Ist_NoOp:
+         case Ist_AbiHint:
+         case Ist_Put:
+         case Ist_PutI:
+         case Ist_IMark:
+         case Ist_Exit:
+            /* None of these can contain any memory references. */
+            break;
+
+         case Ist_MBE:
+            instrument_memory_bus_event( bbOut, st->Ist.MBE.event );
+            break;
+
+         case Ist_Store:
+            instrument_mem_access( 
+               bbOut, 
+               st->Ist.Store.addr, 
+               sizeofIRType(typeOfIRExpr(bbIn->tyenv, st->Ist.Store.data)),
+               True/*isStore*/,
+               sizeofIRType(hWordTy)
+            );
+            break;
+
+         case Ist_WrTmp: {
+            IRExpr* data = st->Ist.WrTmp.data;
+            if (data->tag == Iex_Load) {
+               instrument_mem_access(
+                  bbOut,
+                  data->Iex.Load.addr,
+                  sizeofIRType(data->Iex.Load.ty),
+                  False/*!isStore*/,
+                  sizeofIRType(hWordTy)
+               );
+            }
+            break;
+         }
+
+         case Ist_Dirty: {
+            Int      dataSize;
+            IRDirty* d = st->Ist.Dirty.details;
+            if (d->mFx != Ifx_None) {
+               /* This dirty helper accesses memory.  Collect the
+                  details. */
+               tl_assert(d->mAddr != NULL);
+               tl_assert(d->mSize != 0);
+               dataSize = d->mSize;
+               if (d->mFx == Ifx_Read || d->mFx == Ifx_Modify) {
+                  instrument_mem_access( 
+                     bbOut, d->mAddr, dataSize, False/*!isStore*/,
+                     sizeofIRType(hWordTy)
+                  );
+               }
+               if (d->mFx == Ifx_Write || d->mFx == Ifx_Modify) {
+                  instrument_mem_access( 
+                     bbOut, d->mAddr, dataSize, True/*isStore*/,
+                     sizeofIRType(hWordTy)
+                  );
+               }
+            } else {
+               tl_assert(d->mAddr == NULL);
+               tl_assert(d->mSize == 0);
+            }
+            break;
+         }
+
+         default:
+            tl_assert(0);
+
+      } /* switch (st->tag) */
+
+      addStmtToIRSB( bbOut, st );
+   } /* iterate over bbIn->stmts */
+
+   return bbOut;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Client requests                                          ---*/
+/*----------------------------------------------------------------*/
+
+/* Sheesh.  Yet another goddam finite map. */
+static WordFM* map_pthread_t_to_Thread = NULL; /* pthread_t -> Thread* */
+
+static void map_pthread_t_to_Thread_INIT ( void ) {
+   if (UNLIKELY(map_pthread_t_to_Thread == NULL)) {
+      map_pthread_t_to_Thread = HG_(newFM)( hg_zalloc, hg_free, NULL );
+      tl_assert(map_pthread_t_to_Thread != NULL);
+   }
+}
+
+
+static 
+Bool hg_handle_client_request ( ThreadId tid, UWord* args, UWord* ret)
+{
+   if (!VG_IS_TOOL_USERREQ('H','G',args[0]))
+      return False;
+
+   /* Anything that gets past the above check is one of ours, so we
+      should be able to handle it. */
+
+   /* default, meaningless return value, unless otherwise set */
+   *ret = 0;
+
+   switch (args[0]) {
+
+      /* --- --- User-visible client requests --- --- */
+
+      case VG_USERREQ__HG_CLEAN_MEMORY:
+         if (0) VG_(printf)("VG_USERREQ__HG_CLEAN_MEMORY(%p,%d)\n",
+                            args[1], args[2]);
+         /* Call die_mem to (expensively) tidy up properly, if there
+            are any held locks etc in the area */
+         if (args[2] > 0) { /* length */
+            evh__die_mem(args[1], args[2]);
+            /* and then set it to New */
+            evh__new_mem(args[1], args[2]);
+         }
+         break;
+
+      /* --- --- Client requests for Helgrind's use only --- --- */
+
+      /* Some thread is telling us its pthread_t value.  Record the
+         binding between that and the associated Thread*, so we can
+         later find the Thread* again when notified of a join by the
+         thread. */
+      case _VG_USERREQ__HG_SET_MY_PTHREAD_T: {
+         Thread* my_thr = NULL;
+         if (0)
+         VG_(printf)("SET_MY_PTHREAD_T (tid %d): pthread_t = %p\n", (Int)tid,
+                     (void*)args[1]);
+         map_pthread_t_to_Thread_INIT();
+         my_thr = map_threads_maybe_lookup( tid );
+         /* This assertion should hold because the map_threads (tid to
+            Thread*) binding should have been made at the point of
+            low-level creation of this thread, which should have
+            happened prior to us getting this client request for it.
+            That's because this client request is sent from
+            client-world from the 'thread_wrapper' function, which
+            only runs once the thread has been low-level created. */
+         tl_assert(my_thr != NULL);
+         /* So now we know that (pthread_t)args[1] is associated with
+            (Thread*)my_thr.  Note that down. */
+         if (0)
+         VG_(printf)("XXXX: bind pthread_t %p to Thread* %p\n",
+                     (void*)args[1], (void*)my_thr );
+         HG_(addToFM)( map_pthread_t_to_Thread, (Word)args[1], (Word)my_thr );
+         break;
+      }
+
+      case _VG_USERREQ__HG_PTH_API_ERROR: {
+         Thread* my_thr = NULL;
+         map_pthread_t_to_Thread_INIT();
+         my_thr = map_threads_maybe_lookup( tid );
+         tl_assert(my_thr); /* See justification above in SET_MY_PTHREAD_T */
+         record_error_PthAPIerror( my_thr, (HChar*)args[1], 
+                                           (Word)args[2], (HChar*)args[3] );
+         break;
+      }
+
+      /* This thread (tid) has completed a join with the quitting
+         thread whose pthread_t is in args[1]. */
+      case _VG_USERREQ__HG_PTHREAD_JOIN_POST: {
+         Thread* thr_q = NULL; /* quitter Thread* */
+         Bool    found = False;
+         if (0)
+         VG_(printf)("NOTIFY_JOIN_COMPLETE (tid %d): quitter = %p\n", (Int)tid,
+                     (void*)args[1]);
+         map_pthread_t_to_Thread_INIT();
+         found = HG_(lookupFM)( map_pthread_t_to_Thread, 
+                                NULL, (Word*)(void*)&thr_q, (Word)args[1] );
+          /* Can this fail?  It would mean that our pthread_join
+             wrapper observed a successful join on args[1] yet that
+             thread never existed (or at least, it never lodged an
+             entry in the mapping (via SET_MY_PTHREAD_T)).  Which
+             sounds like a bug in the threads library. */
+         // FIXME: get rid of this assertion; handle properly
+         tl_assert(found);
+         if (found) {
+            if (0)
+            VG_(printf)(".................... quitter Thread* = %p\n", 
+                        thr_q);
+            evh__HG_PTHREAD_JOIN_POST( tid, thr_q );
+         }
+         break;
+      }
+
+      /* EXPOSITION only: by intercepting lock init events we can show
+         the user where the lock was initialised, rather than only
+         being able to show where it was first locked.  Intercepting
+         lock initialisations is not necessary for the basic operation
+         of the race checker. */
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST:
+         evh__HG_PTHREAD_MUTEX_INIT_POST( tid, (void*)args[1], args[2] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE:
+         evh__HG_PTHREAD_MUTEX_DESTROY_PRE( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE:   // pth_mx_t*
+         evh__HG_PTHREAD_MUTEX_UNLOCK_PRE( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST:  // pth_mx_t*
+         evh__HG_PTHREAD_MUTEX_UNLOCK_POST( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE:     // pth_mx_t*, Word
+         evh__HG_PTHREAD_MUTEX_LOCK_PRE( tid, (void*)args[1], args[2] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST:    // pth_mx_t*
+         evh__HG_PTHREAD_MUTEX_LOCK_POST( tid, (void*)args[1] );
+         break;
+
+      /* This thread is about to do pthread_cond_signal on the
+         pthread_cond_t* in arg[1].  Ditto pthread_cond_broadcast. */
+      case _VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE:
+      case _VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE:
+         evh__HG_PTHREAD_COND_SIGNAL_PRE( tid, (void*)args[1] );
+         break;
+
+      /* Entry into pthread_cond_wait, cond=arg[1], mutex=arg[2].
+         Returns a flag indicating whether or not the mutex is believed to be
+         valid for this operation. */
+      case _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE: {
+         Bool mutex_is_valid
+            = evh__HG_PTHREAD_COND_WAIT_PRE( tid, (void*)args[1], 
+                                                  (void*)args[2] );
+         *ret = mutex_is_valid ? 1 : 0;
+         break;
+      }
+
+      /* Thread successfully completed pthread_cond_wait, cond=arg[1],
+         mutex=arg[2] */
+      case _VG_USERREQ__HG_PTHREAD_COND_WAIT_POST:
+         evh__HG_PTHREAD_COND_WAIT_POST( tid,
+                                         (void*)args[1], (void*)args[2] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST:
+         evh__HG_PTHREAD_RWLOCK_INIT_POST( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE:
+         evh__HG_PTHREAD_RWLOCK_DESTROY_PRE( tid, (void*)args[1] );
+         break;
+
+      /* rwlock=arg[1], isW=arg[2] */
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE:
+         evh__HG_PTHREAD_RWLOCK_LOCK_PRE( tid, (void*)args[1], args[2] );
+         break;
+
+      /* rwlock=arg[1], isW=arg[2] */
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST:
+         evh__HG_PTHREAD_RWLOCK_LOCK_POST( tid, (void*)args[1], args[2] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE:
+         evh__HG_PTHREAD_RWLOCK_UNLOCK_PRE( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST:
+         evh__HG_PTHREAD_RWLOCK_UNLOCK_POST( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_POSIX_SEMPOST_PRE: /* sem_t* */
+         evh__HG_POSIX_SEMPOST_PRE( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_POSIX_SEMWAIT_POST: /* sem_t* */
+         evh__HG_POSIX_SEMWAIT_POST( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_POSIX_SEM_ZAPSTACK: /* sem_t* */
+         evh__HG_POSIX_SEM_ZAPSTACK( tid, (void*)args[1] );
+         break;
+
+      case _VG_USERREQ__HG_GET_MY_SEGMENT: { // -> Segment*
+         Thread*   thr;
+         SegmentID segid;
+         Segment*  seg;
+         thr = map_threads_maybe_lookup( tid );
+         tl_assert(thr); /* cannot fail */
+         segid = thr->csegid;
+         tl_assert(is_sane_SegmentID(segid));
+         seg = map_segments_lookup( segid );
+         tl_assert(seg);
+         *ret = (UWord)seg;
+         break;
+      }
+
+      default:
+         /* Unhandled Helgrind client request! */
+        tl_assert2(0, "unhandled Helgrind client request!");
+   }
+
+   return True;
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Error management                                         ---*/
+/*----------------------------------------------------------------*/
+
+/* maps (by value) strings to a copy of them in ARENA_TOOL */
+static UWord stats__string_table_queries = 0;
+static WordFM* string_table = NULL;
+static Word string_table_cmp ( Word s1, Word s2 ) {
+   return (Word)VG_(strcmp)( (HChar*)s1, (HChar*)s2 );
+}
+static HChar* string_table_strdup ( HChar* str ) {
+   HChar* copy = NULL;
+   stats__string_table_queries++;
+   if (!str)
+      str = "(null)";
+   if (!string_table) {
+      string_table = HG_(newFM)( hg_zalloc, hg_free, string_table_cmp );
+      tl_assert(string_table);
+   }
+   if (HG_(lookupFM)( string_table,
+                      NULL, (Word*)(void*)&copy, (Word)str )) {
+      tl_assert(copy);
+      if (0) VG_(printf)("string_table_strdup: %p -> %p\n", str, copy );
+      return copy;
+   } else {
+      copy = VG_(strdup)(str);
+      tl_assert(copy);
+      HG_(addToFM)( string_table, (Word)copy, (Word)copy );
+      return copy;
+   }
+}
+
+/* maps from Lock .unique fields to LockP*s */
+static UWord stats__ga_LockN_to_P_queries = 0;
+static WordFM* yaWFM = NULL;
+static Word lock_unique_cmp ( Word lk1W, Word lk2W )
+{
+   Lock* lk1 = (Lock*)lk1W;
+   Lock* lk2 = (Lock*)lk2W;
+   tl_assert( is_sane_LockNorP(lk1) );
+   tl_assert( is_sane_LockNorP(lk2) );
+   if (lk1->unique < lk2->unique) return -1;
+   if (lk1->unique > lk2->unique) return 1;
+   return 0;
+}
+static Lock* mk_LockP_from_LockN ( Lock* lkn )
+{
+   Lock* lkp = NULL;
+   stats__ga_LockN_to_P_queries++;
+   tl_assert( is_sane_LockN(lkn) );
+   if (!yaWFM) {
+      yaWFM = HG_(newFM)( hg_zalloc, hg_free, lock_unique_cmp );
+      tl_assert(yaWFM);
+   }
+   if (!HG_(lookupFM)( yaWFM, NULL, (Word*)(void*)&lkp, (Word)lkn)) {
+      lkp = hg_zalloc( sizeof(Lock) );
+      *lkp = *lkn;
+      lkp->admin = NULL;
+      lkp->magic = LockP_MAGIC;
+      /* Forget about the bag of lock holders - don't copy that.
+         Also, acquired_at should be NULL whenever heldBy is, and vice
+         versa. */
+      lkp->heldW  = False;
+      lkp->heldBy = NULL;
+      lkp->acquired_at = NULL;
+      HG_(addToFM)( yaWFM, (Word)lkp, (Word)lkp );
+   }
+   tl_assert( is_sane_LockP(lkp) );
+   return lkp;
+}
+
+/* Errors:
+
+      race: program counter
+            read or write
+            data size
+            previous state
+            current state
+
+      FIXME: how does state printing interact with lockset gc?
+      Are the locksets in prev/curr state always valid?
+      Ditto question for the threadsets
+          ThreadSets - probably are always valid if Threads
+          are never thrown away.
+          LockSets - could at least print the lockset elements that
+          correspond to actual locks at the time of printing.  Hmm.
+*/
+
+/* Error kinds */
+typedef
+   enum {
+      XE_Race=1101,      // race
+      XE_FreeMemLock,    // freeing memory containing a locked lock
+      XE_UnlockUnlocked, // unlocking a not-locked lock
+      XE_UnlockForeign,  // unlocking a lock held by some other thread
+      XE_UnlockBogus,    // unlocking an address not known to be a lock
+      XE_PthAPIerror,    // error from the POSIX pthreads API
+      XE_LockOrder,      // lock order error
+      XE_Misc            // misc other error (w/ string to describe it)
+   }
+   XErrorTag;
+
+/* Extra contexts for kinds */
+typedef
+   struct  {
+      XErrorTag tag;
+      union {
+         struct {
+            Addr  data_addr;
+            Int   szB;
+            Bool  isWrite;
+            UInt  new_state;
+            UInt  old_state;
+            ExeContext* mb_lastlock;
+            Thread* thr;
+         } Race;
+         struct {
+            Thread* thr;  /* doing the freeing */
+            Lock*   lock; /* lock which is locked */
+         } FreeMemLock;
+         struct {
+            Thread* thr;  /* doing the unlocking */
+            Lock*   lock; /* lock (that is already unlocked) */
+         } UnlockUnlocked;
+         struct {
+            Thread* thr;    /* doing the unlocking */
+            Thread* owner;  /* thread that actually holds the lock */
+            Lock*   lock;   /* lock (that is held by 'owner') */
+         } UnlockForeign;
+         struct {
+            Thread* thr;     /* doing the unlocking */
+            Addr    lock_ga; /* purported address of the lock */
+         } UnlockBogus;
+         struct {
+            Thread* thr; 
+            HChar*  fnname; /* persistent, in tool-arena */
+            Word    err;    /* pth error code */
+            HChar*  errstr; /* persistent, in tool-arena */
+         } PthAPIerror;
+         struct {
+            Thread*     thr;
+            Addr        before_ga; /* always locked first in prog. history */
+            Addr        after_ga;
+            ExeContext* before_ec;
+            ExeContext* after_ec;
+         } LockOrder;
+         struct {
+            Thread* thr;
+            HChar*  errstr; /* persistent, in tool-arena */
+         } Misc;
+      } XE;
+   }
+   XError;
+
+static void init_XError ( XError* xe ) {
+   VG_(memset)(xe, 0, sizeof(*xe) );
+   xe->tag = XE_Race-1; /* bogus */
+}
+
+
+/* Extensions of suppressions */
+typedef
+   enum {
+      XS_Race=1201, /* race */
+      XS_FreeMemLock,
+      XS_UnlockUnlocked,
+      XS_UnlockForeign,
+      XS_UnlockBogus,
+      XS_PthAPIerror,
+      XS_LockOrder,
+      XS_Misc
+   }
+   XSuppTag;
+
+
+/* Updates the copy with address info if necessary. */
+static UInt hg_update_extra ( Error* err )
+{
+   XError* extra = (XError*)VG_(get_error_extra)(err);
+   tl_assert(extra);
+   //if (extra != NULL && Undescribed == extra->addrinfo.akind) {
+   //   describe_addr ( VG_(get_error_address)(err), &(extra->addrinfo) );
+   //}
+   return sizeof(XError);
+}
+
+static void record_error_Race ( Thread* thr, 
+                                Addr data_addr, Bool isWrite, Int szB,
+                                UInt old_sv, UInt new_sv,
+                                ExeContext* mb_lastlock ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   init_XError(&xe);
+   xe.tag = XE_Race;
+   xe.XE.Race.data_addr   = data_addr;
+   xe.XE.Race.szB         = szB;
+   xe.XE.Race.isWrite     = isWrite;
+   xe.XE.Race.new_state   = new_sv;
+   xe.XE.Race.old_state   = old_sv;
+   xe.XE.Race.mb_lastlock = mb_lastlock;
+   xe.XE.Race.thr         = thr;
+   // FIXME: tid vs thr
+   tl_assert(isWrite == False || isWrite == True);
+   tl_assert(szB == 8 || szB == 4 || szB == 2 || szB == 1);
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_Race, data_addr, NULL, &xe );
+}
+
+static void record_error_FreeMemLock ( Thread* thr, Lock* lk ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   tl_assert( is_sane_LockN(lk) );
+   init_XError(&xe);
+   xe.tag = XE_FreeMemLock;
+   xe.XE.FreeMemLock.thr  = thr;
+   xe.XE.FreeMemLock.lock = mk_LockP_from_LockN(lk);
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_FreeMemLock, 0, NULL, &xe );
+}
+
+static void record_error_UnlockUnlocked ( Thread* thr, Lock* lk ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   tl_assert( is_sane_LockN(lk) );
+   init_XError(&xe);
+   xe.tag = XE_UnlockUnlocked;
+   xe.XE.UnlockUnlocked.thr  = thr;
+   xe.XE.UnlockUnlocked.lock = mk_LockP_from_LockN(lk);
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_UnlockUnlocked, 0, NULL, &xe );
+}
+
+static void record_error_UnlockForeign ( Thread* thr,
+                                         Thread* owner, Lock* lk ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   tl_assert( is_sane_Thread(owner) );
+   tl_assert( is_sane_LockN(lk) );
+   init_XError(&xe);
+   xe.tag = XE_UnlockForeign;
+   xe.XE.UnlockForeign.thr   = thr;
+   xe.XE.UnlockForeign.owner = owner;
+   xe.XE.UnlockForeign.lock  = mk_LockP_from_LockN(lk);
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_UnlockForeign, 0, NULL, &xe );
+}
+
+static void record_error_UnlockBogus ( Thread* thr, Addr lock_ga ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   init_XError(&xe);
+   xe.tag = XE_UnlockBogus;
+   xe.XE.UnlockBogus.thr     = thr;
+   xe.XE.UnlockBogus.lock_ga = lock_ga;
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_UnlockBogus, 0, NULL, &xe );
+}
+
+static 
+void record_error_LockOrder ( Thread* thr, Addr before_ga, Addr after_ga,
+                              ExeContext* before_ec, ExeContext* after_ec ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   init_XError(&xe);
+   xe.tag = XE_LockOrder;
+   xe.XE.LockOrder.thr       = thr;
+   xe.XE.LockOrder.before_ga = before_ga;
+   xe.XE.LockOrder.before_ec = before_ec;
+   xe.XE.LockOrder.after_ga  = after_ga;
+   xe.XE.LockOrder.after_ec  = after_ec;
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_LockOrder, 0, NULL, &xe );
+}
+
+static 
+void record_error_PthAPIerror ( Thread* thr, HChar* fnname, 
+                                Word err, HChar* errstr ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   tl_assert(fnname);
+   tl_assert(errstr);
+   init_XError(&xe);
+   xe.tag = XE_PthAPIerror;
+   xe.XE.PthAPIerror.thr    = thr;
+   xe.XE.PthAPIerror.fnname = string_table_strdup(fnname);
+   xe.XE.PthAPIerror.err    = err;
+   xe.XE.PthAPIerror.errstr = string_table_strdup(errstr);
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_PthAPIerror, 0, NULL, &xe );
+}
+
+static void record_error_Misc ( Thread* thr, HChar* errstr ) {
+   XError xe;
+   tl_assert( is_sane_Thread(thr) );
+   tl_assert(errstr);
+   init_XError(&xe);
+   xe.tag = XE_Misc;
+   xe.XE.Misc.thr    = thr;
+   xe.XE.Misc.errstr = string_table_strdup(errstr);
+   // FIXME: tid vs thr
+   VG_(maybe_record_error)( map_threads_reverse_lookup_SLOW(thr),
+                            XE_Misc, 0, NULL, &xe );
+}
+
+static Bool hg_eq_Error ( VgRes not_used, Error* e1, Error* e2 )
+{
+   XError *xe1, *xe2;
+
+   tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
+
+   xe1 = (XError*)VG_(get_error_extra)(e1);
+   xe2 = (XError*)VG_(get_error_extra)(e2);
+   tl_assert(xe1);
+   tl_assert(xe2);
+
+   switch (VG_(get_error_kind)(e1)) {
+      case XE_Race:
+         return xe1->XE.Race.szB == xe2->XE.Race.szB
+                && xe1->XE.Race.isWrite == xe2->XE.Race.isWrite
+                && (clo_cmp_race_err_addrs 
+                       ? xe1->XE.Race.data_addr == xe2->XE.Race.data_addr
+                       : True);
+      case XE_FreeMemLock:
+         return xe1->XE.FreeMemLock.thr == xe2->XE.FreeMemLock.thr
+                && xe1->XE.FreeMemLock.lock == xe2->XE.FreeMemLock.lock;
+      case XE_UnlockUnlocked:
+         return xe1->XE.UnlockUnlocked.thr == xe2->XE.UnlockUnlocked.thr
+                && xe1->XE.UnlockUnlocked.lock == xe2->XE.UnlockUnlocked.lock;
+      case XE_UnlockForeign:
+         return xe1->XE.UnlockForeign.thr == xe2->XE.UnlockForeign.thr
+                && xe1->XE.UnlockForeign.owner == xe2->XE.UnlockForeign.owner
+                && xe1->XE.UnlockForeign.lock == xe2->XE.UnlockForeign.lock;
+      case XE_UnlockBogus:
+         return xe1->XE.UnlockBogus.thr == xe2->XE.UnlockBogus.thr
+                && xe1->XE.UnlockBogus.lock_ga == xe2->XE.UnlockBogus.lock_ga;
+      case XE_PthAPIerror:
+         return xe1->XE.PthAPIerror.thr == xe2->XE.PthAPIerror.thr
+                && 0==VG_(strcmp)(xe1->XE.PthAPIerror.fnname,
+                                  xe2->XE.PthAPIerror.fnname)
+                && xe1->XE.PthAPIerror.err == xe2->XE.PthAPIerror.err;
+      case XE_LockOrder:
+         return xe1->XE.LockOrder.thr == xe2->XE.LockOrder.thr;
+      case XE_Misc:
+         return xe1->XE.Misc.thr == xe2->XE.Misc.thr
+                && 0==VG_(strcmp)(xe1->XE.Misc.errstr, xe2->XE.Misc.errstr);
+      default:
+         tl_assert(0);
+   }
+
+   /*NOTREACHED*/
+   tl_assert(0);
+}
+
+/* Given a WordSetID in univ_tsets (that is, a Thread set ID), produce
+   an XArray* with the corresponding Thread*'s sorted by their
+   errmsg_index fields.  This is for printing out thread sets in
+   repeatable orders, which is important for for repeatable regression
+   testing.  The returned XArray* is dynamically allocated (of course)
+   and so must be hg_freed by the caller. */
+static Int cmp_Thread_by_errmsg_index ( void* thr1V, void* thr2V ) {
+   Thread* thr1 = *(Thread**)thr1V;
+   Thread* thr2 = *(Thread**)thr2V;
+   if (thr1->errmsg_index < thr2->errmsg_index) return -1;
+   if (thr1->errmsg_index > thr2->errmsg_index) return  1;
+   return 0;
+}
+static XArray* /* of Thread* */ get_sorted_thread_set ( WordSetID tset )
+{
+   XArray* xa;
+   Word*   ts_words;
+   Word    ts_size, i;
+   xa = VG_(newXA)( hg_zalloc, hg_free, sizeof(Thread*) );
+   tl_assert(xa);
+   HG_(getPayloadWS)( &ts_words, &ts_size, univ_tsets, tset );
+   tl_assert(ts_words);
+   tl_assert(ts_size >= 0);
+   /* This isn't a very clever scheme, but we don't expect this to be
+      called very often. */
+   for (i = 0; i < ts_size; i++) {
+      Thread* thr = (Thread*)ts_words[i];
+      tl_assert(is_sane_Thread(thr));
+      VG_(addToXA)( xa, (void*)&thr );
+   }
+   tl_assert(ts_size == VG_(sizeXA)( xa ));
+   VG_(setCmpFnXA)( xa, cmp_Thread_by_errmsg_index );
+   VG_(sortXA)( xa );
+   return xa;
+}
+
+
+/* Announce (that is, print the point-of-creation) of the threads in
+   'tset'.  Only do this once, as we only want to see these
+   announcements once each.  Also, first sort the threads by their
+   errmsg_index fields, and show only the first N_THREADS_TO_ANNOUNCE.
+   That's because we only want to bother to announce threads
+   enumerated by summarise_threadset() below, and that in turn does
+   the same: it sorts them and then only shows the first
+   N_THREADS_TO_ANNOUNCE. */
+
+static void announce_threadset ( WordSetID tset )
+{
+   const Word limit = N_THREADS_TO_ANNOUNCE;
+   Thread* thr;
+   XArray* sorted;
+   Word    ts_size, i, loopmax;
+   sorted = get_sorted_thread_set( tset );
+   ts_size = VG_(sizeXA)( sorted );
+   tl_assert(ts_size >= 0);
+   loopmax = limit < ts_size  ? limit  : ts_size; /* min(limit, ts_size) */
+   tl_assert(loopmax >= 0 && loopmax <= limit);
+   for (i = 0; i < loopmax; i++) {
+      thr = *(Thread**)VG_(indexXA)( sorted, i );
+      tl_assert(is_sane_Thread(thr));
+      tl_assert(thr->errmsg_index >= 1);
+      if (thr->announced)
+         continue;
+      if (thr->errmsg_index == 1/*FIXME: this hardwires an assumption
+                                  about the identity of the root
+                                  thread*/) {
+         tl_assert(thr->created_at == NULL);
+         VG_(message)(Vg_UserMsg, "Thread #%d is the program's root thread",
+                                  thr->errmsg_index);
+      } else {
+         tl_assert(thr->created_at != NULL);
+         VG_(message)(Vg_UserMsg, "Thread #%d was created",
+                                  thr->errmsg_index);
+         VG_(pp_ExeContext)( thr->created_at );
+      }
+      VG_(message)(Vg_UserMsg, "");
+      thr->announced = True;
+   }
+   VG_(deleteXA)( sorted );
+}
+static void announce_one_thread ( Thread* thr ) {
+   announce_threadset( HG_(singletonWS)(univ_tsets, (Word)thr ));
+}
+
+/* Generate into buf[0 .. nBuf-1] a 1-line summary of a thread set, of
+   the form "#1, #3, #77, #78, #79 and 42 others".  The first
+   N_THREADS_TO_ANNOUNCE are listed explicitly (as '#n') and the
+   leftovers lumped into the 'and n others' bit. */
+
+static void summarise_threadset ( WordSetID tset, Char* buf, UInt nBuf )
+{
+   const Word limit = N_THREADS_TO_ANNOUNCE;
+   Thread* thr;
+   XArray* sorted;
+   Word    ts_size, i, loopmax;
+   UInt    off = 0;
+   tl_assert(nBuf > 0);
+   tl_assert(nBuf >= 40 + 20*limit);
+   tl_assert(buf);
+   sorted = get_sorted_thread_set( tset );
+   ts_size = VG_(sizeXA)( sorted );
+   tl_assert(ts_size >= 0);
+   loopmax = limit < ts_size  ? limit  : ts_size; /* min(limit, ts_size) */
+   tl_assert(loopmax >= 0 && loopmax <= limit);
+   VG_(memset)(buf, 0, nBuf);
+   for (i = 0; i < loopmax; i++) {
+      thr = *(Thread**)VG_(indexXA)( sorted, i );
+      tl_assert(is_sane_Thread(thr));
+      tl_assert(thr->errmsg_index >= 1);
+      off += VG_(sprintf)(&buf[off], "#%d", (Int)thr->errmsg_index);
+      if (i < loopmax-1)
+         off += VG_(sprintf)(&buf[off], ", ");
+   }
+   if (limit < ts_size) {
+      Word others = ts_size - limit;
+      off += VG_(sprintf)(&buf[off], " and %d other%s", 
+                                     (Int)others, others > 1 ? "s" : "");
+   }
+   tl_assert(off < nBuf);
+   tl_assert(buf[nBuf-1] == 0);
+   VG_(deleteXA)( sorted );
+}
+
+static void hg_pp_Error ( Error* err )
+{
+   const Bool show_raw_states = False;
+   XError *xe = (XError*)VG_(get_error_extra)(err);
+
+   switch (VG_(get_error_kind)(err)) {
+
+   case XE_Misc: {
+      tl_assert(xe);
+      tl_assert( is_sane_Thread( xe->XE.Misc.thr ) );
+      announce_one_thread( xe->XE.Misc.thr );
+      VG_(message)(Vg_UserMsg,
+                  "Thread #%d: %s",
+                  (Int)xe->XE.Misc.thr->errmsg_index,
+                  xe->XE.Misc.errstr);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      break;
+   }
+
+   case XE_LockOrder: {
+      tl_assert(xe);
+      tl_assert( is_sane_Thread( xe->XE.LockOrder.thr ) );
+      announce_one_thread( xe->XE.LockOrder.thr );
+      VG_(message)(Vg_UserMsg,
+                  "Thread #%d: lock order \"%p before %p\" violated",
+                  (Int)xe->XE.LockOrder.thr->errmsg_index,
+                  (void*)xe->XE.LockOrder.before_ga,
+                  (void*)xe->XE.LockOrder.after_ga);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      if (xe->XE.LockOrder.before_ec && xe->XE.LockOrder.after_ec) {
+         VG_(message)(Vg_UserMsg,
+            "  Required order was established by acquisition of lock at %p",
+            (void*)xe->XE.LockOrder.before_ga);
+         VG_(pp_ExeContext)( xe->XE.LockOrder.before_ec );
+         VG_(message)(Vg_UserMsg,
+            "  followed by a later acquisition of lock at %p", 
+            (void*)xe->XE.LockOrder.after_ga);
+         VG_(pp_ExeContext)( xe->XE.LockOrder.after_ec );
+      }
+      break;
+   }
+
+   case XE_PthAPIerror: {
+      tl_assert(xe);
+      tl_assert( is_sane_Thread( xe->XE.PthAPIerror.thr ) );
+      announce_one_thread( xe->XE.PthAPIerror.thr );
+      VG_(message)(Vg_UserMsg,
+                  "Thread #%d's call to %s failed",
+                  (Int)xe->XE.PthAPIerror.thr->errmsg_index,
+                  xe->XE.PthAPIerror.fnname);
+      VG_(message)(Vg_UserMsg,
+                  "   with error code %ld (%s)",
+                  xe->XE.PthAPIerror.err,
+                  xe->XE.PthAPIerror.errstr);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      break;
+   }
+
+   case XE_UnlockBogus: {
+      tl_assert(xe);
+      tl_assert( is_sane_Thread( xe->XE.UnlockBogus.thr ) );
+      announce_one_thread( xe->XE.UnlockBogus.thr );
+      VG_(message)(Vg_UserMsg,
+                   "Thread #%d unlocked an invalid lock at %p ",
+                   (Int)xe->XE.UnlockBogus.thr->errmsg_index,
+                   (void*)xe->XE.UnlockBogus.lock_ga);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      break;
+   }
+
+   case XE_UnlockForeign: {
+      tl_assert(xe);
+      tl_assert( is_sane_LockP( xe->XE.UnlockForeign.lock ) );
+      tl_assert( is_sane_Thread( xe->XE.UnlockForeign.owner ) );
+      tl_assert( is_sane_Thread( xe->XE.UnlockForeign.thr ) );
+      announce_one_thread( xe->XE.UnlockForeign.thr );
+      announce_one_thread( xe->XE.UnlockForeign.owner );
+      VG_(message)(Vg_UserMsg,
+                   "Thread #%d unlocked lock at %p "
+                   "currently held by thread #%d",
+                   (Int)xe->XE.UnlockForeign.thr->errmsg_index,
+                   (void*)xe->XE.UnlockForeign.lock->guestaddr,
+                   (Int)xe->XE.UnlockForeign.owner->errmsg_index );
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      if (xe->XE.UnlockForeign.lock->appeared_at) {
+         VG_(message)(Vg_UserMsg,
+                      "  Lock at %p was first observed",
+                      (void*)xe->XE.UnlockForeign.lock->guestaddr);
+         VG_(pp_ExeContext)( xe->XE.UnlockForeign.lock->appeared_at );
+      }
+      break;
+   }
+
+   case XE_UnlockUnlocked: {
+      tl_assert(xe);
+      tl_assert( is_sane_LockP( xe->XE.UnlockUnlocked.lock ) );
+      tl_assert( is_sane_Thread( xe->XE.UnlockUnlocked.thr ) );
+      announce_one_thread( xe->XE.UnlockUnlocked.thr );
+      VG_(message)(Vg_UserMsg,
+                   "Thread #%d unlocked a not-locked lock at %p ",
+                   (Int)xe->XE.UnlockUnlocked.thr->errmsg_index,
+                   (void*)xe->XE.UnlockUnlocked.lock->guestaddr);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      if (xe->XE.UnlockUnlocked.lock->appeared_at) {
+         VG_(message)(Vg_UserMsg,
+                      "  Lock at %p was first observed",
+                      (void*)xe->XE.UnlockUnlocked.lock->guestaddr);
+         VG_(pp_ExeContext)( xe->XE.UnlockUnlocked.lock->appeared_at );
+      }
+      break;
+   }
+
+   case XE_FreeMemLock: {
+      tl_assert(xe);
+      tl_assert( is_sane_LockP( xe->XE.FreeMemLock.lock ) );
+      tl_assert( is_sane_Thread( xe->XE.FreeMemLock.thr ) );
+      announce_one_thread( xe->XE.FreeMemLock.thr );
+      VG_(message)(Vg_UserMsg,
+                   "Thread #%d deallocated location %p "
+                   "containing a locked lock",
+                   (Int)xe->XE.FreeMemLock.thr->errmsg_index,
+                   (void*)xe->XE.FreeMemLock.lock->guestaddr);
+      VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+      if (xe->XE.FreeMemLock.lock->appeared_at) {
+         VG_(message)(Vg_UserMsg,
+                      "  Lock at %p was first observed",
+                      (void*)xe->XE.FreeMemLock.lock->guestaddr);
+         VG_(pp_ExeContext)( xe->XE.FreeMemLock.lock->appeared_at );
+      }
+      break;
+   }
+
+   case XE_Race: {
+      Addr      err_ga;
+      Char      old_buf[100], new_buf[100];
+      Char      old_tset_buf[140], new_tset_buf[140];
+      UInt      old_state, new_state;
+      Thread*   thr_acc;
+      HChar*    what;
+      Int       szB;
+      WordSetID tset_to_announce = HG_(emptyWS)( univ_tsets );
+
+      /* First extract some essential info */
+      tl_assert(xe);
+      old_state = xe->XE.Race.old_state;
+      new_state = xe->XE.Race.new_state;
+      thr_acc   = xe->XE.Race.thr;
+      what      = xe->XE.Race.isWrite ? "write" : "read";
+      szB       = xe->XE.Race.szB;
+      tl_assert(is_sane_Thread(thr_acc));
+      err_ga = VG_(get_error_address)(err);
+
+      /* Format the low level state print descriptions */
+      show_shadow_w32(old_buf, sizeof(old_buf), old_state);
+      show_shadow_w32(new_buf, sizeof(new_buf), new_state);
+
+      /* Now we have to 'announce' the threadset mentioned in the
+         error message, if it hasn't already been announced.
+         Unfortunately the precise threadset and error message text
+         depends on the nature of the transition involved.  So now
+         fall into a case analysis of the error state transitions. */
+
+      /* CASE of Excl -> ShM */
+      if (is_SHVAL_Excl(old_state) && is_SHVAL_ShM(new_state)) {
+         SegmentID old_segid;
+         Segment*  old_seg;
+         Thread*   old_thr; 
+         WordSetID new_tset;
+         old_segid = un_SHVAL_Excl( old_state );
+         tl_assert(is_sane_SegmentID(old_segid));
+         old_seg = map_segments_lookup( old_segid );
+         tl_assert(is_sane_Segment(old_seg));
+         tl_assert(old_seg->thr);
+         old_thr = old_seg->thr;
+         tl_assert(is_sane_Thread(old_thr));
+
+         new_tset = un_SHVAL_ShM_tset(new_state);
+         tset_to_announce = HG_(addToWS)( univ_tsets,
+                                          new_tset, (Word)old_thr );
+         announce_threadset( tset_to_announce );
+
+         VG_(message)(Vg_UserMsg,
+                      "Possible data race during %s of size %d at %p",
+                      what, szB, err_ga);
+         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+         /* pp_AddrInfo(err_addr, &extra->addrinfo); */
+         if (show_raw_states)
+         VG_(message)(Vg_UserMsg,
+                      "  Old state 0x%08x=%s, new state 0x%08x=%s",
+                      old_state, old_buf, new_state, new_buf);
+         VG_(message)(Vg_UserMsg,
+                      "  Old state: owned exclusively by thread #%d",
+                      old_thr->errmsg_index);
+         // This should always show exactly 2 threads
+         summarise_threadset( new_tset, new_tset_buf, sizeof(new_tset_buf) );
+         VG_(message)(Vg_UserMsg,
+                      "  New state: shared-modified by threads %s",
+                      new_tset_buf );
+         VG_(message)(Vg_UserMsg,
+                      "  Reason:    this thread, #%d, holds no locks at all",
+                      thr_acc->errmsg_index);
+      }
+      else 
+      /* Case of ShR/M -> ShM */
+      if (is_SHVAL_Sh(old_state) && is_SHVAL_ShM(new_state)) {
+         WordSetID old_tset = un_SHVAL_Sh_tset(old_state);
+         WordSetID new_tset = un_SHVAL_Sh_tset(new_state);
+
+         tset_to_announce = HG_(unionWS)( univ_tsets, old_tset, new_tset );
+         announce_threadset( tset_to_announce );
+
+         VG_(message)(Vg_UserMsg,
+                      "Possible data race during %s of size %d at %p",
+                      what, szB, err_ga);
+         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+         /* pp_AddrInfo(err_addr, &extra->addrinfo); */
+         if (show_raw_states)
+         VG_(message)(Vg_UserMsg,
+                      "  Old state 0x%08x=%s, new state 0x%08x=%s",
+                      old_state, old_buf, new_state, new_buf);
+
+         summarise_threadset( old_tset, old_tset_buf, sizeof(old_tset_buf) );
+         summarise_threadset( new_tset, new_tset_buf, sizeof(new_tset_buf) );
+
+         VG_(message)(Vg_UserMsg,
+                      "  Old state: shared-%s by threads %s", 
+                      is_SHVAL_ShM(old_state) ? "modified" : "readonly", 
+                      old_tset_buf);
+         VG_(message)(Vg_UserMsg,
+                      "  New state: shared-modified by threads %s", 
+                      new_tset_buf);
+         VG_(message)(Vg_UserMsg,
+                      "  Reason:    this thread, #%d, holds no "
+                      "consistent locks",
+                      thr_acc->errmsg_index);
+         if (xe->XE.Race.mb_lastlock) {
+            VG_(message)(Vg_UserMsg, "  Last consistently used lock for %p was "
+                                     "first observed", err_ga);
+            VG_(pp_ExeContext)(xe->XE.Race.mb_lastlock);
+         } else {
+            VG_(message)(Vg_UserMsg, "  Location %p has never been protected "
+                                     "by any lock", err_ga);
+         }
+      }
+      /* Hmm, unknown transition.  Just print what we do know. */
+      else {
+         VG_(message)(Vg_UserMsg,
+                      "Possible data race during %s of size %d at %p",
+                      what, szB, err_ga);
+         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+
+         //pp_AddrInfo(err_addr, &extra->addrinfo);
+         VG_(message)(Vg_UserMsg,
+                      "  Old state 0x%08x=%s, new state 0x%08x=%s",
+                      old_state, old_buf, new_state, new_buf);
+      }
+
+      break; /* case XE_Race */
+   } /* case XE_Race */
+
+   default:
+      tl_assert(0);
+   } /* switch (VG_(get_error_kind)(err)) */
+}
+
+static Char* hg_get_error_name ( Error* err )
+{
+   switch (VG_(get_error_kind)(err)) {
+      case XE_Race:           return "Race";
+      case XE_FreeMemLock:    return "FreeMemLock";
+      case XE_UnlockUnlocked: return "UnlockUnlocked";
+      case XE_UnlockForeign:  return "UnlockForeign";
+      case XE_UnlockBogus:    return "UnlockBogus";
+      case XE_PthAPIerror:    return "PthAPIerror";
+      case XE_LockOrder:      return "LockOrder";
+      case XE_Misc:           return "Misc";
+      default: tl_assert(0); /* fill in missing case */
+   }
+}
+
+static Bool hg_recognised_suppression ( Char* name, Supp *su )
+{
+#  define TRY(_name,_xskind)                   \
+      if (0 == VG_(strcmp)(name, (_name))) {   \
+         VG_(set_supp_kind)(su, (_xskind));    \
+         return True;                          \
+      }
+   TRY("Race",           XS_Race);
+   TRY("FreeMemLock",    XS_FreeMemLock);
+   TRY("UnlockUnlocked", XS_UnlockUnlocked);
+   TRY("UnlockForeign",  XS_UnlockForeign);
+   TRY("UnlockBogus",    XS_UnlockBogus);
+   TRY("PthAPIerror",    XS_PthAPIerror);
+   TRY("LockOrder",      XS_LockOrder);
+   TRY("Misc",           XS_Misc);
+   return False;
+#  undef TRY
+}
+
+static Bool hg_read_extra_suppression_info ( Int fd, Char* buf, Int nBuf,
+                                             Supp* su )
+{
+   /* do nothing -- no extra suppression info present.  Return True to
+      indicate nothing bad happened. */
+   return True;
+}
+
+static Bool hg_error_matches_suppression ( Error* err, Supp* su )
+{
+   switch (VG_(get_supp_kind)(su)) {
+   case XS_Race:           return VG_(get_error_kind)(err) == XE_Race;
+   case XS_FreeMemLock:    return VG_(get_error_kind)(err) == XE_FreeMemLock;
+   case XS_UnlockUnlocked: return VG_(get_error_kind)(err) == XE_UnlockUnlocked;
+   case XS_UnlockForeign:  return VG_(get_error_kind)(err) == XE_UnlockForeign;
+   case XS_UnlockBogus:    return VG_(get_error_kind)(err) == XE_UnlockBogus;
+   case XS_PthAPIerror:    return VG_(get_error_kind)(err) == XE_PthAPIerror;
+   case XS_LockOrder:      return VG_(get_error_kind)(err) == XE_LockOrder;
+   case XS_Misc:           return VG_(get_error_kind)(err) == XE_Misc;
+   //case XS_: return VG_(get_error_kind)(err) == XE_;
+   default: tl_assert(0); /* fill in missing cases */
+   }
+}
+
+static void hg_print_extra_suppression_info ( Error* err )
+{
+   /* Do nothing */
+}
+
+
+/*----------------------------------------------------------------*/
+/*--- Setup                                                    ---*/
+/*----------------------------------------------------------------*/
+
+static Bool hg_process_cmd_line_option ( Char* arg )
+{
+   if      (VG_CLO_STREQ(arg, "--happens-before=none"))
+      clo_happens_before = 0;
+   else if (VG_CLO_STREQ(arg, "--happens-before=threads"))
+      clo_happens_before = 1;
+   else if (VG_CLO_STREQ(arg, "--happens-before=all"))
+      clo_happens_before = 2;
+
+   else if (VG_CLO_STREQ(arg, "--gen-vcg=no"))
+      clo_gen_vcg = 0;
+   else if (VG_CLO_STREQ(arg, "--gen-vcg=yes"))
+      clo_gen_vcg = 1;
+   else if (VG_CLO_STREQ(arg, "--gen-vcg=yes-w-vts"))
+      clo_gen_vcg = 2;
+
+   else if (VG_CLO_STREQ(arg, "--cmp-race-err-addrs=no"))
+      clo_cmp_race_err_addrs = False;
+   else if (VG_CLO_STREQ(arg, "--cmp-race-err-addrs=yes"))
+      clo_cmp_race_err_addrs = True;
+
+   else if (VG_CLO_STREQN(13, arg, "--trace-addr=")) {
+      clo_trace_addr = VG_(atoll16)(&arg[13]);
+      if (clo_trace_level == 0)
+         clo_trace_level = 1;
+   }
+   else VG_BNUM_CLO(arg, "--trace-level", clo_trace_level, 0, 2)
+
+   /* "stuvw" --> stuvw (binary) */
+   else if (VG_CLO_STREQN(18, arg, "--tc-sanity-flags=")) {
+      Int j;
+      char* opt = & arg[18];
+   
+      if (5 != VG_(strlen)(opt)) {
+         VG_(message)(Vg_UserMsg, 
+                      "--tc-sanity-flags argument must have 5 digits");
+         return False;
+      }
+      for (j = 0; j < 5; j++) {
+         if      ('0' == opt[j]) { /* do nothing */ }
+         else if ('1' == opt[j]) clo_sanity_flags |= (1 << (5-1-j));
+         else {
+            VG_(message)(Vg_UserMsg, "--tc-sanity-flags argument can "
+                                     "only contain 0s and 1s");
+            return False;
+         }
+      }
+      if (0) VG_(printf)("XXX sanity flags: 0x%x\n", clo_sanity_flags);
+   }
+
+   else 
+      return VG_(replacement_malloc_process_cmd_line_option)(arg);
+
+   return True;
+}
+
+static void hg_print_usage ( void )
+{
+   VG_(printf)(
+"    --happens-before=none|threads|all   [all] consider no events, thread\n"
+"      create/join, create/join/cvsignal/cvwait/semwait/post as sync points\n"
+"    --trace-addr=0xXXYYZZ     show all state changes for address 0xXXYYZZ\n"
+"    --trace-level=0|1|2       verbosity level of --trace-addr [1]\n"
+   );
+   VG_(replacement_malloc_print_usage)();
+}
+
+static void hg_print_debug_usage ( void )
+{
+   VG_(replacement_malloc_print_debug_usage)();
+   VG_(printf)("    --gen-vcg=no|yes|yes-w-vts   show happens-before graph "
+               "in .vcg format [no]\n");
+   VG_(printf)("    --cmp-race-err-addrs=no|yes  are data addresses in "
+               "race errors significant? [no]\n");
+   VG_(printf)("    --tc-sanity-flags=<XXXXX> sanity check "
+               "  at events (X = 0|1) [00000]\n");
+   VG_(printf)("    --tc-sanity-flags values:\n");
+   VG_(printf)("       10000   after changes to "
+               "lock-order-acquisition-graph\n");
+   VG_(printf)("       01000   at memory accesses (NB: not curently used)\n");
+   VG_(printf)("       00100   at mem permission setting for "
+               "ranges >= %d bytes\n", SCE_BIGRANGE_T);
+   VG_(printf)("       00010   at lock/unlock events\n");
+   VG_(printf)("       00001   at thread create/join events\n");
+}
+
+static void hg_post_clo_init ( void )
+{
+}
+
+static void hg_fini ( Int exitcode )
+{
+   if (SHOW_DATA_STRUCTURES)
+      pp_everything( PP_ALL, "SK_(fini)" );
+   if (clo_sanity_flags)
+      all__sanity_check("SK_(fini)");
+
+   if (clo_gen_vcg > 0)
+      segments__generate_vcg();
+
+   if (VG_(clo_verbosity) >= 2) {
+
+      if (1) {
+         VG_(printf)("\n");
+         HG_(ppWSUstats)( univ_tsets, "univ_tsets" );
+         VG_(printf)("\n");
+         HG_(ppWSUstats)( univ_lsets, "univ_lsets" );
+         VG_(printf)("\n");
+         HG_(ppWSUstats)( univ_laog,  "univ_laog" );
+      }
+
+      VG_(printf)("\n");
+      VG_(printf)(" hbefore: %,10lu queries\n",        stats__hbefore_queries);
+      VG_(printf)(" hbefore: %,10lu cache 0 hits\n",   stats__hbefore_cache0s);
+      VG_(printf)(" hbefore: %,10lu cache > 0 hits\n", stats__hbefore_cacheNs);
+      VG_(printf)(" hbefore: %,10lu graph searches\n", stats__hbefore_gsearches);
+      VG_(printf)(" hbefore: %,10lu   of which slow\n",
+                  stats__hbefore_gsearches - stats__hbefore_gsearchFs);
+      VG_(printf)(" hbefore: %,10lu stack high water mark\n",
+                  stats__hbefore_stk_hwm);
+      VG_(printf)(" hbefore: %,10lu cache invals\n",   stats__hbefore_invals);
+      VG_(printf)(" hbefore: %,10lu probes\n",         stats__hbefore_probes);
+
+      VG_(printf)("\n");
+      VG_(printf)("        segments: %,8lu Segment objects allocated\n", 
+                  stats__mk_Segment);
+      VG_(printf)("        locksets: %,8d unique lock sets\n",
+                  (Int)HG_(cardinalityWSU)( univ_lsets ));
+      VG_(printf)("      threadsets: %,8d unique thread sets\n",
+                  (Int)HG_(cardinalityWSU)( univ_tsets ));
+      VG_(printf)("       univ_laog: %,8d unique lock sets\n",
+                  (Int)HG_(cardinalityWSU)( univ_laog ));
+
+      VG_(printf)("L(ast)L(ock) map: %,8lu inserts (%d map size)\n", 
+                  stats__ga_LL_adds,
+                  (Int)(ga_to_lastlock ? HG_(sizeFM)( ga_to_lastlock ) : 0) );
+
+      VG_(printf)("  LockN-to-P map: %,8lu queries (%d map size)\n", 
+                  stats__ga_LockN_to_P_queries,
+                  (Int)(yaWFM ? HG_(sizeFM)( yaWFM ) : 0) );
+
+      VG_(printf)("string table map: %,8lu queries (%d map size)\n", 
+                  stats__string_table_queries,
+                  (Int)(string_table ? HG_(sizeFM)( string_table ) : 0) );
+      VG_(printf)("            LAOG: %,8d map size\n", 
+                  (Int)(laog ? HG_(sizeFM)( laog ) : 0));
+      VG_(printf)(" LAOG exposition: %,8d map size\n", 
+                  (Int)(laog_exposition ? HG_(sizeFM)( laog_exposition ) : 0));
+      VG_(printf)("           locks: %,8lu acquires, "
+                  "%,lu releases\n",
+                  stats__lockN_acquires,
+                  stats__lockN_releases
+                 );
+      VG_(printf)("   sanity checks: %,8lu\n", stats__sanity_checks);
+
+      VG_(printf)("\n");
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_Excl_nochange\n",
+                  stats__msm_read_Excl_nochange, stats__msm_write_Excl_nochange);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_Excl_transfer\n",
+                  stats__msm_read_Excl_transfer, stats__msm_write_Excl_transfer);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_Excl_to_ShR/ShM\n",
+                  stats__msm_read_Excl_to_ShR,   stats__msm_write_Excl_to_ShM);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_ShR_to_ShR/ShM\n",
+                  stats__msm_read_ShR_to_ShR,    stats__msm_write_ShR_to_ShM);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_ShM_to_ShM\n",
+                  stats__msm_read_ShM_to_ShM,    stats__msm_write_ShM_to_ShM);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_New_to_Excl\n",
+                  stats__msm_read_New_to_Excl,   stats__msm_write_New_to_Excl);
+      VG_(printf)("     msm: %,12lu %,12lu rd/wr_NoAccess\n",
+                  stats__msm_read_NoAccess,      stats__msm_write_NoAccess);
+
+      VG_(printf)("\n");
+      VG_(printf)(" secmaps: %,10lu allocd (%,12lu g-a-range)\n",
+                  stats__secmaps_allocd,
+                  stats__secmap_ga_space_covered);
+      VG_(printf)("  linesZ: %,10lu allocd (%,12lu bytes occupied)\n",
+                  stats__secmap_linesZ_allocd,
+                  stats__secmap_linesZ_bytes);
+      VG_(printf)("  linesF: %,10lu allocd (%,12lu bytes occupied)\n",
+                  stats__secmap_linesF_allocd,
+                  stats__secmap_linesF_bytes);
+      VG_(printf)(" secmaps: %,10lu iterator steppings\n",
+                  stats__secmap_iterator_steppings);
+
+      VG_(printf)("\n");
+      VG_(printf)("   cache: %,lu totrefs (%,lu misses)\n",
+                  stats__cache_totrefs, stats__cache_totmisses );
+      VG_(printf)("   cache: %,12lu Z-fetch, %,12lu F-fetch\n",
+                  stats__cache_Z_fetches, stats__cache_F_fetches );
+      VG_(printf)("   cache: %,12lu Z-wback, %,12lu F-wback\n",
+                  stats__cache_Z_wbacks, stats__cache_F_wbacks );
+      VG_(printf)("   cache: %,12lu invals,  %,12lu flushes\n",
+                  stats__cache_invals, stats__cache_flushes );
+
+      VG_(printf)("\n");
+      VG_(printf)("   cline: %,10lu normalises\n",
+                  stats__cline_normalises );
+      VG_(printf)("   cline:  reads 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+                  stats__cline_read64s,
+                  stats__cline_read32s,
+                  stats__cline_read16s,
+                  stats__cline_read8s );
+      VG_(printf)("   cline: writes 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+                  stats__cline_write64s,
+                  stats__cline_write32s,
+                  stats__cline_write16s,
+                  stats__cline_write8s );
+      VG_(printf)("   cline:   sets 8/4/2/1: %,12lu %,12lu %,12lu %,12lu\n",
+                  stats__cline_set64s,
+                  stats__cline_set32s,
+                  stats__cline_set16s,
+                  stats__cline_set8s );
+      VG_(printf)("   cline: get1s %,lu, copy1s %,lu\n",
+                  stats__cline_get8s, stats__cline_copy8s );
+      VG_(printf)("   cline:    splits: 8to4 %,12lu    4to2 %,12lu    2to1 %,12lu\n",
+                 stats__cline_64to32splits,
+                 stats__cline_32to16splits,
+                 stats__cline_16to8splits );
+      VG_(printf)("   cline: pulldowns: 8to4 %,12lu    4to2 %,12lu    2to1 %,12lu\n",
+                 stats__cline_64to32pulldown,
+                 stats__cline_32to16pulldown,
+                 stats__cline_16to8pulldown );
+
+      VG_(printf)("\n");
+   }
+}
+
+static void hg_pre_clo_init ( void )
+{
+   VG_(details_name)            ("Helgrind");
+   VG_(details_version)         (NULL);
+   VG_(details_description)     ("a thread error detector");
+   VG_(details_copyright_author)(
+      "Copyright (C) 2007-2007, and GNU GPL'd, by OpenWorks LLP et al.");
+   VG_(details_bug_reports_to)  (VG_BUGS_TO);
+   VG_(details_avg_translation_sizeB) ( 200 );
+
+   VG_(basic_tool_funcs)          (hg_post_clo_init,
+                                   hg_instrument,
+                                   hg_fini);
+
+   VG_(needs_core_errors)         ();
+   VG_(needs_tool_errors)         (hg_eq_Error,
+                                   hg_pp_Error,
+                                   False,/*show TIDs for errors*/
+                                   hg_update_extra,
+                                   hg_recognised_suppression,
+                                   hg_read_extra_suppression_info,
+                                   hg_error_matches_suppression,
+                                   hg_get_error_name,
+                                   hg_print_extra_suppression_info);
+
+   VG_(needs_command_line_options)(hg_process_cmd_line_option,
+                                   hg_print_usage,
+                                   hg_print_debug_usage);
+   VG_(needs_client_requests)     (hg_handle_client_request);
+
+   // FIXME?
+   //VG_(needs_sanity_checks)       (hg_cheap_sanity_check,
+   //                                hg_expensive_sanity_check);
+
+   VG_(needs_malloc_replacement)  (hg_cli__malloc,
+                                   hg_cli____builtin_new,
+                                   hg_cli____builtin_vec_new,
+                                   hg_cli__memalign,
+                                   hg_cli__calloc,
+                                   hg_cli__free,
+                                   hg_cli____builtin_delete,
+                                   hg_cli____builtin_vec_delete,
+                                   hg_cli__realloc,
+                                   HG_CLI__MALLOC_REDZONE_SZB );
+
+   VG_(needs_data_syms)();
+
+   //VG_(needs_xml_output)          ();
+
+   VG_(track_new_mem_startup)     ( evh__new_mem_w_perms );
+   VG_(track_new_mem_stack_signal)( evh__die_mem );
+   VG_(track_new_mem_brk)         ( evh__new_mem );
+   VG_(track_new_mem_mmap)        ( evh__new_mem_w_perms );
+   VG_(track_new_mem_stack)       ( evh__new_mem );
+
+   // FIXME: surely this isn't thread-aware
+   VG_(track_copy_mem_remap)      ( shadow_mem_copy_range );
+
+   VG_(track_change_mem_mprotect) ( evh__set_perms );
+
+   VG_(track_die_mem_stack_signal)( evh__die_mem );
+   VG_(track_die_mem_brk)         ( evh__die_mem );
+   VG_(track_die_mem_munmap)      ( evh__die_mem );
+   VG_(track_die_mem_stack)       ( evh__die_mem );
+
+   // FIXME: what is this for?
+   VG_(track_ban_mem_stack)       (NULL);
+
+   VG_(track_pre_mem_read)        ( evh__pre_mem_read );
+   VG_(track_pre_mem_read_asciiz) ( evh__pre_mem_read_asciiz );
+   VG_(track_pre_mem_write)       ( evh__pre_mem_write );
+   VG_(track_post_mem_write)      (NULL);
+
+   /////////////////
+
+   VG_(track_pre_thread_ll_create)( evh__pre_thread_ll_create );
+   VG_(track_pre_thread_ll_exit)  ( evh__pre_thread_ll_exit );
+
+   VG_(track_start_client_code)( evh__start_client_code );
+   VG_(track_stop_client_code)( evh__stop_client_code );
+
+   initialise_data_structures();
+
+   /* Ensure that requirements for "dodgy C-as-C++ style inheritance"
+      as described in comments at the top of pub_tool_hashtable.h, are
+      met.  Blargh. */
+   tl_assert( sizeof(void*) == sizeof(struct _MallocMeta*) );
+   tl_assert( sizeof(UWord) == sizeof(Addr) );
+   hg_mallocmeta_table
+      = VG_(HT_construct)( "hg_malloc_metadata_table" );
+
+   /* a SecMap must contain an integral number of CacheLines */
+   tl_assert(0 == (N_SECMAP_ARANGE % N_LINE_ARANGE));
+   /* also ... a CacheLine holds an integral number of trees */
+   tl_assert(0 == (N_LINE_ARANGE % 8));
+}
+
+VG_DETERMINE_INTERFACE_VERSION(hg_pre_clo_init)
+
+/*--------------------------------------------------------------------*/
+/*--- end                                                hg_main.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordfm.c b/helgrind/hg_wordfm.c
new file mode 100644
index 0000000..b839a38
--- /dev/null
+++ b/helgrind/hg_wordfm.c
@@ -0,0 +1,834 @@
+
+/*--------------------------------------------------------------------*/
+/*--- An AVL tree based finite map for word keys and word values.  ---*/
+/*--- Inspired by Haskell's "FiniteMap" library.                   ---*/
+/*---                                                  hg_wordfm.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 Julian Seward
+      jseward@acm.org
+
+   This code is based on previous work by Nicholas Nethercote
+   (coregrind/m_oset.c) which is
+
+   Copyright (C) 2005-2007 Nicholas Nethercote
+       njn@valgrind.org
+
+   which in turn was derived partially from:
+
+      AVL C library
+      Copyright (C) 2000,2002  Daniel Nagy
+
+      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 2 of
+      the License, or (at your option) any later version.
+      [...]
+
+      (taken from libavl-0.4/debian/copyright)
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+
+//------------------------------------------------------------------//
+//---                           WordFM                           ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+/* One element of the AVL tree */
+typedef
+   struct _AvlNode {
+      Word key;
+      Word val;
+      struct _AvlNode* child[2]; /* [0] is left subtree, [1] is right */
+      Char balance; /* do not make this unsigned */
+   }
+   AvlNode;
+
+typedef 
+   struct {
+      Word w;
+      Bool b;
+   }
+   MaybeWord;
+
+#define WFM_STKMAX    32    // At most 2**32 entries can be iterated over
+
+struct _WordFM {
+   AvlNode* root;
+   void*    (*alloc_nofail)( SizeT );
+   void     (*dealloc)(void*);
+   Word     (*kCmp)(Word,Word);
+   AvlNode* nodeStack[WFM_STKMAX]; // Iterator node stack
+   Int      numStack[WFM_STKMAX];  // Iterator num stack
+   Int      stackTop;              // Iterator stack pointer, one past end
+}; 
+
+/* forward */
+static Bool avl_removeroot_wrk(AvlNode** t, Word(*kCmp)(Word,Word));
+
+/* Swing to the left.  Warning: no balance maintainance. */
+static void avl_swl ( AvlNode** root )
+{
+   AvlNode* a  = *root;
+   AvlNode* b  = a->child[1];
+   *root       = b;
+   a->child[1] = b->child[0];
+   b->child[0] = a;
+}
+
+/* Swing to the right.  Warning: no balance maintainance. */
+static void avl_swr ( AvlNode** root )
+{
+   AvlNode* a  = *root;
+   AvlNode* b  = a->child[0];
+   *root       = b;
+   a->child[0] = b->child[1];
+   b->child[1] = a;
+}
+
+/* Balance maintainance after especially nasty swings. */
+static void avl_nasty ( AvlNode* root )
+{
+   switch (root->balance) {
+      case -1: 
+         root->child[0]->balance = 0;
+         root->child[1]->balance = 1;
+         break;
+      case 1:
+         root->child[0]->balance = -1;
+         root->child[1]->balance = 0;
+         break;
+      case 0:
+         root->child[0]->balance = 0;
+         root->child[1]->balance = 0;
+         break;
+      default:
+         tl_assert(0);
+   }
+   root->balance=0;
+}
+
+/* Find size of a non-NULL tree. */
+static Word size_avl_nonNull ( AvlNode* nd )
+{
+   return 1 + (nd->child[0] ? size_avl_nonNull(nd->child[0]) : 0)
+            + (nd->child[1] ? size_avl_nonNull(nd->child[1]) : 0);
+}
+
+/* Insert element a into the AVL tree t.  Returns True if the depth of
+   the tree has grown.  If element with that key is already present,
+   just copy a->val to existing node, first returning old ->val field
+   of existing node in *oldV, so that the caller can finalize it
+   however it wants.
+*/
+static 
+Bool avl_insert_wrk ( AvlNode**         rootp, 
+                      /*OUT*/MaybeWord* oldV,
+                      AvlNode*          a, 
+                      Word              (*kCmp)(Word,Word) )
+{
+   Word cmpres;
+
+   /* initialize */
+   a->child[0] = 0;
+   a->child[1] = 0;
+   a->balance  = 0;
+   oldV->b     = False;
+
+   /* insert into an empty tree? */
+   if (!(*rootp)) {
+      (*rootp) = a;
+      return True;
+   }
+
+   cmpres = kCmp ? /*boxed*/   kCmp( (*rootp)->key, a->key )
+                 : /*unboxed*/ ((Word)(*rootp)->key) - ((Word)a->key);
+
+   if (cmpres > 0) {
+      /* insert into the left subtree */
+      if ((*rootp)->child[0]) {
+         AvlNode* left_subtree = (*rootp)->child[0];
+         if (avl_insert_wrk(&left_subtree, oldV, a, kCmp)) {
+            switch ((*rootp)->balance--) {
+               case  1: return False;
+               case  0: return True;
+               case -1: break;
+               default: tl_assert(0);
+            }
+            if ((*rootp)->child[0]->balance < 0) {
+               avl_swr( rootp );
+               (*rootp)->balance = 0;
+               (*rootp)->child[1]->balance = 0;
+            } else {
+               avl_swl( &((*rootp)->child[0]) );
+               avl_swr( rootp );
+               avl_nasty( *rootp );
+            }
+         } else {
+            (*rootp)->child[0] = left_subtree;
+         }
+         return False;
+      } else {
+         (*rootp)->child[0] = a;
+         if ((*rootp)->balance--) 
+            return False;
+         return True;
+      }
+      tl_assert(0);/*NOTREACHED*/
+   }
+   else 
+   if (cmpres < 0) {
+      /* insert into the right subtree */
+      if ((*rootp)->child[1]) {
+         AvlNode* right_subtree = (*rootp)->child[1];
+         if (avl_insert_wrk(&right_subtree, oldV, a, kCmp)) {
+            switch((*rootp)->balance++){
+               case -1: return False;
+               case  0: return True;
+               case  1: break;
+               default: tl_assert(0);
+            }
+            if ((*rootp)->child[1]->balance > 0) {
+               avl_swl( rootp );
+               (*rootp)->balance = 0;
+               (*rootp)->child[0]->balance = 0;
+            } else {
+               avl_swr( &((*rootp)->child[1]) );
+               avl_swl( rootp );
+               avl_nasty( *rootp );
+            }
+         } else {
+            (*rootp)->child[1] = right_subtree;
+         }
+         return False;
+      } else {
+         (*rootp)->child[1] = a;
+         if ((*rootp)->balance++) 
+            return False;
+         return True;
+      }
+      tl_assert(0);/*NOTREACHED*/
+   }
+   else {
+      /* cmpres == 0, a duplicate - replace the val, but don't
+         incorporate the node in the tree */
+      oldV->b = True;
+      oldV->w = (*rootp)->val;
+      (*rootp)->val = a->val;
+      return False;
+   }
+}
+
+/* Remove an element a from the AVL tree t.  a must be part of
+   the tree.  Returns True if the depth of the tree has shrunk. 
+*/
+static
+Bool avl_remove_wrk ( AvlNode** rootp, 
+                      AvlNode*  a, 
+                      Word(*kCmp)(Word,Word) )
+{
+   Bool ch;
+   Word cmpres;
+   cmpres = kCmp ? /*boxed*/   kCmp( (*rootp)->key, a->key )
+                 : /*unboxed*/ ((Word)(*rootp)->key) - ((Word)a->key);
+
+   if (cmpres > 0){
+      /* remove from the left subtree */
+      AvlNode* left_subtree = (*rootp)->child[0];
+      tl_assert(left_subtree);
+      ch = avl_remove_wrk(&left_subtree, a, kCmp);
+      (*rootp)->child[0]=left_subtree;
+      if (ch) {
+         switch ((*rootp)->balance++) {
+            case -1: return True;
+            case  0: return False;
+            case  1: break;
+            default: tl_assert(0);
+         }
+         switch ((*rootp)->child[1]->balance) {
+            case 0:
+               avl_swl( rootp );
+               (*rootp)->balance = -1;
+               (*rootp)->child[0]->balance = 1;
+               return False;
+            case 1: 
+               avl_swl( rootp );
+               (*rootp)->balance = 0;
+               (*rootp)->child[0]->balance = 0;
+               return True;
+            case -1:
+               break;
+            default:
+               tl_assert(0);
+         }
+         avl_swr( &((*rootp)->child[1]) );
+         avl_swl( rootp );
+         avl_nasty( *rootp );
+         return True;
+      }
+   }
+   else
+   if (cmpres < 0) {
+      /* remove from the right subtree */
+      AvlNode* right_subtree = (*rootp)->child[1];
+      tl_assert(right_subtree);
+      ch = avl_remove_wrk(&right_subtree, a, kCmp);
+      (*rootp)->child[1] = right_subtree;
+      if (ch) {
+         switch ((*rootp)->balance--) {
+            case  1: return True;
+            case  0: return False;
+            case -1: break;
+            default: tl_assert(0);
+         }
+         switch ((*rootp)->child[0]->balance) {
+            case 0:
+               avl_swr( rootp );
+               (*rootp)->balance = 1;
+               (*rootp)->child[1]->balance = -1;
+               return False;
+            case -1:
+               avl_swr( rootp );
+               (*rootp)->balance = 0;
+               (*rootp)->child[1]->balance = 0;
+               return True;
+            case 1:
+               break;
+            default:
+               tl_assert(0);
+         }
+         avl_swl( &((*rootp)->child[0]) );
+         avl_swr( rootp );
+         avl_nasty( *rootp );
+         return True;
+      }
+   }
+   else {
+      tl_assert(cmpres == 0);
+      tl_assert((*rootp)==a);
+      return avl_removeroot_wrk(rootp, kCmp);
+   }
+   return 0;
+}
+
+/* Remove the root of the AVL tree *rootp.
+ * Warning: dumps core if *rootp is empty
+ */
+static 
+Bool avl_removeroot_wrk ( AvlNode** rootp, 
+                          Word(*kCmp)(Word,Word) )
+{
+   Bool     ch;
+   AvlNode* a;
+   if (!(*rootp)->child[0]) {
+      if (!(*rootp)->child[1]) {
+         (*rootp) = 0;
+         return True;
+      }
+      (*rootp) = (*rootp)->child[1];
+      return True;
+   }
+   if (!(*rootp)->child[1]) {
+      (*rootp) = (*rootp)->child[0];
+      return True;
+   }
+   if ((*rootp)->balance < 0) {
+      /* remove from the left subtree */
+      a = (*rootp)->child[0];
+      while (a->child[1]) a = a->child[1];
+   } else {
+      /* remove from the right subtree */
+      a = (*rootp)->child[1];
+      while (a->child[0]) a = a->child[0];
+   }
+   ch = avl_remove_wrk(rootp, a, kCmp);
+   a->child[0] = (*rootp)->child[0];
+   a->child[1] = (*rootp)->child[1];
+   a->balance  = (*rootp)->balance;
+   (*rootp)    = a;
+   if(a->balance == 0) return ch;
+   return False;
+}
+
+static 
+AvlNode* avl_find_node ( AvlNode* t, Word k, Word(*kCmp)(Word,Word) )
+{
+   if (kCmp) {
+      /* Boxed comparisons */
+      Word cmpres;
+      while (True) {
+         if (t == NULL) return NULL;
+         cmpres = kCmp(t->key, k);
+         if (cmpres > 0) t = t->child[0];  else
+         if (cmpres < 0) t = t->child[1]; else
+         return t;
+      }
+   } else {
+      /* Unboxed comparisons */
+      Word  cmpres; /* signed */
+      UWord cmpresU; /* unsigned */
+      while (True) {
+         if (t == NULL) return NULL; /* unlikely ==> predictable */
+         cmpres = ((Word)t->key) - ((Word)k);
+         if (cmpres == 0) return t; /* unlikely ==> predictable */
+         cmpresU = (UWord)cmpres;
+         cmpresU >>=/*unsigned*/ (8 * sizeof(cmpres) - 1);
+         t = t->child[cmpresU];
+      }
+   }
+}
+
+// Clear the iterator stack.
+static void stackClear(WordFM* fm)
+{
+   Int i;
+   tl_assert(fm);
+   for (i = 0; i < WFM_STKMAX; i++) {
+      fm->nodeStack[i] = NULL;
+      fm->numStack[i]  = 0;
+   }
+   fm->stackTop = 0;
+}
+
+// Push onto the iterator stack.
+static inline void stackPush(WordFM* fm, AvlNode* n, Int i)
+{
+   tl_assert(fm->stackTop < WFM_STKMAX);
+   tl_assert(1 <= i && i <= 3);
+   fm->nodeStack[fm->stackTop] = n;
+   fm-> numStack[fm->stackTop] = i;
+   fm->stackTop++;
+}
+
+// Pop from the iterator stack.
+static inline Bool stackPop(WordFM* fm, AvlNode** n, Int* i)
+{
+   tl_assert(fm->stackTop <= WFM_STKMAX);
+
+   if (fm->stackTop > 0) {
+      fm->stackTop--;
+      *n = fm->nodeStack[fm->stackTop];
+      *i = fm-> numStack[fm->stackTop];
+      tl_assert(1 <= *i && *i <= 3);
+      fm->nodeStack[fm->stackTop] = NULL;
+      fm-> numStack[fm->stackTop] = 0;
+      return True;
+   } else {
+      return False;
+   }
+}
+
+static 
+AvlNode* avl_dopy ( AvlNode* nd, 
+                    Word(*dopyK)(Word), 
+                    Word(*dopyV)(Word),
+                    void*(alloc_nofail)(SizeT) )
+{
+   AvlNode* nyu;
+   if (! nd)
+      return NULL;
+   nyu = alloc_nofail(sizeof(AvlNode));
+   tl_assert(nyu);
+   
+   nyu->child[0] = nd->child[0];
+   nyu->child[1] = nd->child[1];
+   nyu->balance = nd->balance;
+
+   /* Copy key */
+   if (dopyK) {
+      nyu->key = dopyK( nd->key );
+      if (nd->key != 0 && nyu->key == 0)
+         return NULL; /* oom in key dcopy */
+   } else {
+      /* copying assumedly unboxed keys */
+      nyu->key = nd->key;
+   }
+
+   /* Copy val */
+   if (dopyV) {
+      nyu->val = dopyV( nd->val );
+      if (nd->val != 0 && nyu->val == 0)
+         return NULL; /* oom in val dcopy */
+   } else {
+      /* copying assumedly unboxed vals */
+      nyu->val = nd->val;
+   }
+
+   /* Copy subtrees */
+   if (nyu->child[0]) {
+      nyu->child[0] = avl_dopy( nyu->child[0], dopyK, dopyV, alloc_nofail );
+      if (! nyu->child[0])
+         return NULL;
+   }
+   if (nyu->child[1]) {
+      nyu->child[1] = avl_dopy( nyu->child[1], dopyK, dopyV, alloc_nofail );
+      if (! nyu->child[1])
+         return NULL;
+   }
+
+   return nyu;
+}
+
+/* Initialise a WordFM. */
+static void initFM ( WordFM* fm,
+                     void*   (*alloc_nofail)( SizeT ),
+                     void    (*dealloc)(void*),
+                     Word    (*kCmp)(Word,Word) )
+{
+   fm->root         = 0;
+   fm->kCmp         = kCmp;
+   fm->alloc_nofail = alloc_nofail;
+   fm->dealloc      = dealloc;
+   fm->stackTop     = 0;
+}
+
+/* --- Public interface functions --- */
+
+/* Allocate and Initialise a WordFM. */
+WordFM* HG_(newFM) ( void* (*alloc_nofail)( SizeT ),
+                     void  (*dealloc)(void*),
+                     Word  (*kCmp)(Word,Word) )
+{
+   WordFM* fm = alloc_nofail(sizeof(WordFM));
+   tl_assert(fm);
+   initFM(fm, alloc_nofail, dealloc, kCmp);
+   return fm;
+}
+
+static void avl_free ( AvlNode* nd, 
+                       void(*kFin)(Word),
+                       void(*vFin)(Word),
+                       void(*dealloc)(void*) )
+{
+   if (!nd)
+      return;
+   if (nd->child[0])
+      avl_free(nd->child[0], kFin, vFin, dealloc);
+   if (nd->child[1])
+      avl_free(nd->child[1], kFin, vFin, dealloc);
+   if (kFin)
+      kFin( nd->key );
+   if (vFin)
+      vFin( nd->val );
+   VG_(memset)(nd, 0, sizeof(AvlNode));
+   dealloc(nd);
+}
+
+/* Free up the FM.  If kFin is non-NULL, it is applied to keys
+   before the FM is deleted; ditto with vFin for vals. */
+void HG_(deleteFM) ( WordFM* fm, void(*kFin)(Word), void(*vFin)(Word) )
+{
+   void(*dealloc)(void*) = fm->dealloc;
+   avl_free( fm->root, kFin, vFin, dealloc );
+   VG_(memset)(fm, 0, sizeof(WordFM) );
+   dealloc(fm);
+}
+
+/* Add (k,v) to fm. */
+void HG_(addToFM) ( WordFM* fm, Word k, Word v )
+{
+   MaybeWord oldV;
+   AvlNode* node;
+   node = fm->alloc_nofail( sizeof(struct _AvlNode) );
+   node->key = k;
+   node->val = v;
+   oldV.b = False;
+   oldV.w = 0;
+   avl_insert_wrk( &fm->root, &oldV, node, fm->kCmp );
+   //if (oldV.b && fm->vFin)
+   //   fm->vFin( oldV.w );
+   if (oldV.b)
+      fm->dealloc(node);
+}
+
+// Delete key from fm, returning associated key and val if found
+Bool HG_(delFromFM) ( WordFM* fm,
+                      /*OUT*/Word* oldK, /*OUT*/Word* oldV, Word key )
+{
+   AvlNode* node = avl_find_node( fm->root, key, fm->kCmp );
+   if (node) {
+      avl_remove_wrk( &fm->root, node, fm->kCmp );
+      if (oldK)
+         *oldK = node->key;
+      if (oldV)
+         *oldV = node->val;
+      fm->dealloc(node);
+      return True;
+   } else {
+      return False;
+   }
+}
+
+// Look up in fm, assigning found key & val at spec'd addresses
+Bool HG_(lookupFM) ( WordFM* fm, 
+                     /*OUT*/Word* keyP, /*OUT*/Word* valP, Word key )
+{
+   AvlNode* node = avl_find_node( fm->root, key, fm->kCmp );
+   if (node) {
+      if (keyP)
+         *keyP = node->key;
+      if (valP)
+         *valP = node->val;
+      return True;
+   } else {
+      return False;
+   }
+}
+
+Word HG_(sizeFM) ( WordFM* fm )
+{
+   // Hmm, this is a bad way to do this
+   return fm->root ? size_avl_nonNull( fm->root ) : 0;
+}
+
+// set up FM for iteration
+void HG_(initIterFM) ( WordFM* fm )
+{
+   tl_assert(fm);
+   stackClear(fm);
+   if (fm->root)
+      stackPush(fm, fm->root, 1);
+}
+
+// get next key/val pair.  Will tl_assert if fm has been modified
+// or looked up in since initIterFM was called.
+Bool HG_(nextIterFM) ( WordFM* fm, /*OUT*/Word* pKey, /*OUT*/Word* pVal )
+{
+   Int i = 0;
+   AvlNode* n = NULL;
+   
+   tl_assert(fm);
+
+   // This in-order traversal requires each node to be pushed and popped
+   // three times.  These could be avoided by updating nodes in-situ on the
+   // top of the stack, but the push/pop cost is so small that it's worth
+   // keeping this loop in this simpler form.
+   while (stackPop(fm, &n, &i)) {
+      switch (i) {
+      case 1: case_1:
+         stackPush(fm, n, 2);
+         /* if (n->child[0])  stackPush(fm, n->child[0], 1); */
+         if (n->child[0]) { n = n->child[0]; goto case_1; }
+         break;
+      case 2: 
+         stackPush(fm, n, 3);
+         if (pKey) *pKey = n->key;
+         if (pVal) *pVal = n->val;
+         return True;
+      case 3:
+         /* if (n->child[1]) stackPush(fm, n->child[1], 1); */
+         if (n->child[1]) { n = n->child[1]; goto case_1; }
+         break;
+      default:
+         tl_assert(0);
+      }
+   }
+
+   // Stack empty, iterator is exhausted, return NULL
+   return False;
+}
+
+// clear the I'm iterating flag
+void HG_(doneIterFM) ( WordFM* fm )
+{
+}
+
+WordFM* HG_(dopyFM) ( WordFM* fm, Word(*dopyK)(Word), Word(*dopyV)(Word) )
+{
+   WordFM* nyu; 
+
+   /* can't clone the fm whilst iterating on it */
+   tl_assert(fm->stackTop == 0);
+
+   nyu = fm->alloc_nofail( sizeof(WordFM) );
+   tl_assert(nyu);
+
+   *nyu = *fm;
+
+   fm->stackTop = 0;
+   VG_(memset)(fm->nodeStack, 0, sizeof(fm->nodeStack));
+   VG_(memset)(fm->numStack, 0,  sizeof(fm->numStack));
+
+   if (nyu->root) {
+      nyu->root = avl_dopy( nyu->root, dopyK, dopyV, fm->alloc_nofail );
+      if (! nyu->root)
+         return NULL;
+   }
+
+   return nyu;
+}
+
+//------------------------------------------------------------------//
+//---                         end WordFM                         ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+//------------------------------------------------------------------//
+//---                WordBag (unboxed words only)                ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+/* A trivial container, to make it opaque. */
+struct _WordBag { 
+   WordFM* fm; 
+};
+
+WordBag* HG_(newBag) ( void* (*alloc_nofail)( SizeT ),
+                       void  (*dealloc)(void*) )
+{
+   WordBag* bag = alloc_nofail(sizeof(WordBag));
+   bag->fm = HG_(newFM)( alloc_nofail, dealloc, NULL );
+   return bag;
+}
+
+void HG_(deleteBag) ( WordBag* bag )
+{
+   void (*dealloc)(void*) = bag->fm->dealloc;
+   HG_(deleteFM)( bag->fm, NULL, NULL );
+   VG_(memset)(bag, 0, sizeof(WordBag));
+   dealloc(bag);
+}
+
+void HG_(addToBag)( WordBag* bag, Word w )
+{
+   Word key, count;
+   if (HG_(lookupFM)(bag->fm, &key, &count, w)) {
+      tl_assert(key == w);
+      tl_assert(count >= 1);
+      HG_(addToFM)(bag->fm, w, count+1);
+   } else {
+      HG_(addToFM)(bag->fm, w, 1);
+   }
+}
+
+Word HG_(elemBag) ( WordBag* bag, Word w )
+{
+   Word key, count;
+   if (HG_(lookupFM)( bag->fm, &key, &count, w)) {
+      tl_assert(key == w);
+      tl_assert(count >= 1);
+      return count;
+   } else {
+      return 0;
+   }
+}
+
+Word HG_(sizeUniqueBag) ( WordBag* bag )
+{
+   return HG_(sizeFM)( bag->fm );
+}
+
+static Word sizeTotalBag_wrk ( AvlNode* nd )
+{
+   /* unchecked pre: nd is non-NULL */
+   Word w = nd->val;
+   tl_assert(w >= 1);
+   if (nd->child[0])
+      w += sizeTotalBag_wrk(nd->child[0]);
+   if (nd->child[1])
+      w += sizeTotalBag_wrk(nd->child[1]);
+   return w;
+}
+Word HG_(sizeTotalBag)( WordBag* bag )
+{
+   if (bag->fm->root)
+      return sizeTotalBag_wrk(bag->fm->root);
+   else
+      return 0;
+}
+
+Bool HG_(delFromBag)( WordBag* bag, Word w )
+{
+   Word key, count;
+   if (HG_(lookupFM)(bag->fm, &key, &count, w)) {
+      tl_assert(key == w);
+      tl_assert(count >= 1);
+      if (count > 1) {
+         HG_(addToFM)(bag->fm, w, count-1);
+      } else {
+         tl_assert(count == 1);
+         HG_(delFromFM)( bag->fm, NULL, NULL, w );
+      }
+      return True;
+   } else {
+      return False;
+   }
+}
+
+Bool HG_(isEmptyBag)( WordBag* bag )
+{
+   return HG_(sizeFM)(bag->fm) == 0;
+}
+
+Bool HG_(isSingletonTotalBag)( WordBag* bag )
+{
+   AvlNode* nd;
+   if (HG_(sizeFM)(bag->fm) != 1)
+      return False;
+   nd = bag->fm->root;
+   tl_assert(nd);
+   tl_assert(!nd->child[0]);
+   tl_assert(!nd->child[1]);
+   return nd->val == 1;
+}
+
+Word HG_(anyElementOfBag)( WordBag* bag )
+{
+   /* Return an arbitrarily chosen element in the bag.  We might as
+      well return the one at the root of the underlying AVL tree. */
+   AvlNode* nd = bag->fm->root;
+   tl_assert(nd); /* if this fails, 'bag' is empty - caller is in error. */
+   tl_assert(nd->val >= 1);
+   return nd->key;
+}
+
+void HG_(initIterBag)( WordBag* bag )
+{
+   HG_(initIterFM)(bag->fm);
+}
+
+Bool HG_(nextIterBag)( WordBag* bag, /*OUT*/Word* pVal, /*OUT*/Word* pCount )
+{
+   return HG_(nextIterFM)( bag->fm, pVal, pCount );
+}
+
+void HG_(doneIterBag)( WordBag* bag )
+{
+   HG_(doneIterFM)( bag->fm );
+}
+
+//------------------------------------------------------------------//
+//---             end WordBag (unboxed words only)               ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+/*--------------------------------------------------------------------*/
+/*--- end                                              hg_wordfm.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordfm.h b/helgrind/hg_wordfm.h
new file mode 100644
index 0000000..cd8f542
--- /dev/null
+++ b/helgrind/hg_wordfm.h
@@ -0,0 +1,162 @@
+
+/*--------------------------------------------------------------------*/
+/*--- An AVL tree based finite map for word keys and word values.  ---*/
+/*--- Inspired by Haskell's "FiniteMap" library.                   ---*/
+/*---                                                  hg_wordfm.h ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 Julian Seward
+      jseward@acm.org
+
+   This code is based on previous work by Nicholas Nethercote
+   (coregrind/m_oset.c) which is
+
+   Copyright (C) 2005-2007 Nicholas Nethercote
+       njn@valgrind.org
+
+   which in turn was derived partially from:
+
+      AVL C library
+      Copyright (C) 2000,2002  Daniel Nagy
+
+      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 2 of
+      the License, or (at your option) any later version.
+      [...]
+
+      (taken from libavl-0.4/debian/copyright)
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+*/
+
+#ifndef __HG_WORDFM_H
+#define __HG_WORDFM_H
+
+//------------------------------------------------------------------//
+//---                           WordFM                           ---//
+//---                      Public interface                      ---//
+//------------------------------------------------------------------//
+
+typedef  struct _WordFM  WordFM; /* opaque */
+
+/* Allocate and initialise a WordFM */
+WordFM* HG_(newFM) ( void* (*alloc_nofail)( SizeT ),
+                     void  (*dealloc)(void*),
+                     Word  (*kCmp)(Word,Word) );
+
+/* Free up the FM.  If kFin is non-NULL, it is applied to keys
+   before the FM is deleted; ditto with vFin for vals. */
+void HG_(deleteFM) ( WordFM*, void(*kFin)(Word), void(*vFin)(Word) );
+
+/* Add (k,v) to fm.  If a binding for k already exists, it is updated
+   to map to this new v.  In that case we should really return the
+   previous v so that caller can finalise it.  Oh well. */
+void HG_(addToFM) ( WordFM* fm, Word k, Word v );
+
+// Delete key from fm, returning associated key and val if found
+Bool HG_(delFromFM) ( WordFM* fm,
+                      /*OUT*/Word* oldK, /*OUT*/Word* oldV, Word key );
+
+// Look up in fm, assigning found key & val at spec'd addresses
+Bool HG_(lookupFM) ( WordFM* fm, 
+                     /*OUT*/Word* keyP, /*OUT*/Word* valP, Word key );
+
+// How many elements are there in fm?
+Word HG_(sizeFM) ( WordFM* fm );
+
+// set up FM for iteration
+void HG_(initIterFM) ( WordFM* fm );
+
+// get next key/val pair.  Will assert if fm has been modified
+// or looked up in since initIterFM was called.
+Bool HG_(nextIterFM) ( WordFM* fm,
+                       /*OUT*/Word* pKey, /*OUT*/Word* pVal );
+
+// clear the I'm iterating flag
+void HG_(doneIterFM) ( WordFM* fm );
+
+// Deep copy a FM.  If dopyK is NULL, keys are copied verbatim.
+// If non-null, dopyK is applied to each key to generate the
+// version in the new copy.  In that case, if the argument to dopyK
+// is non-NULL but the result is NULL, it is assumed that dopyK
+// could not allocate memory, in which case the copy is abandoned
+// and NULL is returned.  Ditto with dopyV for values.
+WordFM* HG_(dopyFM) ( WordFM* fm,
+                      Word(*dopyK)(Word), Word(*dopyV)(Word) );
+
+//------------------------------------------------------------------//
+//---                         end WordFM                         ---//
+//---                      Public interface                      ---//
+//------------------------------------------------------------------//
+
+//------------------------------------------------------------------//
+//---                WordBag (unboxed words only)                ---//
+//---                      Public interface                      ---//
+//------------------------------------------------------------------//
+
+typedef  struct _WordBag  WordBag; /* opaque */
+
+/* Allocate and initialise a WordBag */
+WordBag* HG_(newBag) ( void* (*alloc_nofail)( SizeT ),
+                       void  (*dealloc)(void*) );
+
+/* Free up the Bag. */
+void HG_(deleteBag) ( WordBag* );
+
+/* Add a word. */
+void HG_(addToBag)( WordBag*, Word );
+
+/* Find out how many times the given word exists in the bag. */
+Word HG_(elemBag) ( WordBag*, Word );
+
+/* Delete a word from the bag. */
+Bool HG_(delFromBag)( WordBag*, Word );
+
+/* Is the bag empty? */
+Bool HG_(isEmptyBag)( WordBag* );
+
+/* Does the bag have exactly one element? */
+Bool HG_(isSingletonTotalBag)( WordBag* );
+
+/* Return an arbitrary element from the bag. */
+Word HG_(anyElementOfBag)( WordBag* );
+
+/* How many different / total elements are in the bag? */
+Word HG_(sizeUniqueBag)( WordBag* ); /* fast */
+Word HG_(sizeTotalBag)( WordBag* );  /* warning: slow */
+
+/* Iterating over the elements of a bag. */
+void HG_(initIterBag)( WordBag* );
+Bool HG_(nextIterBag)( WordBag*, /*OUT*/Word* pVal, /*OUT*/Word* pCount );
+void HG_(doneIterBag)( WordBag* );
+
+//------------------------------------------------------------------//
+//---             end WordBag (unboxed words only)               ---//
+//---                      Public interface                      ---//
+//------------------------------------------------------------------//
+
+#endif /* ! __HG_WORDFM_H */
+
+/*--------------------------------------------------------------------*/
+/*--- end                                              hg_wordfm.h ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordset.c b/helgrind/hg_wordset.c
new file mode 100644
index 0000000..ed9a5b8
--- /dev/null
+++ b/helgrind/hg_wordset.c
@@ -0,0 +1,854 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Sets of words, with unique set identifiers.                  ---*/
+/*---                                                 hg_wordset.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 OpenWorks LLP
+       info@open-works.co.uk
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+
+   Neither the names of the U.S. Department of Energy nor the
+   University of California nor the names of its contributors may be
+   used to endorse or promote products derived from this software
+   without prior written permission.
+*/
+
+#include "pub_tool_basics.h"
+#include "pub_tool_libcassert.h"
+#include "pub_tool_libcbase.h"
+#include "pub_tool_libcprint.h"
+
+#define HG_(str) VGAPPEND(vgHelgrind_,str)
+#include "hg_wordfm.h"
+#include "hg_wordset.h"
+
+//------------------------------------------------------------------//
+//--- Word Cache                                                 ---//
+//------------------------------------------------------------------//
+
+typedef
+   struct { UWord arg1; UWord arg2; UWord res; }
+   WCacheEnt;
+
+/* Each cache is a fixed sized array of N_WCACHE_STAT_MAX entries.
+   However only the first .dynMax are used.  This is because at some
+   point, expanding the cache further overall gives a slowdown because
+   searching more entries more than negates any performance advantage
+   from caching those entries in the first place.  Hence use .dynMax
+   to allow the size of the cache(s) to be set differently for each
+   different WordSetU. */
+#define N_WCACHE_STAT_MAX 32
+typedef
+   struct {
+      WCacheEnt ent[N_WCACHE_STAT_MAX];
+      Word      dynMax; /* 1 .. N_WCACHE_STAT_MAX inclusive */
+      Word      inUse;  /* 0 .. dynMax inclusive */
+   }
+   WCache;
+
+#define WCache_INIT(_zzcache,_zzdynmax)                              \
+   do {                                                              \
+      tl_assert((_zzdynmax) >= 1);                                   \
+      tl_assert((_zzdynmax) <= N_WCACHE_STAT_MAX);                   \
+      (_zzcache).dynMax = (_zzdynmax);                               \
+      (_zzcache).inUse = 0;                                          \
+   } while (0)
+
+#define WCache_LOOKUP_AND_RETURN(_retty,_zzcache,_zzarg1,_zzarg2)    \
+   do {                                                              \
+      Word    _i;                                                    \
+      UWord   _arg1  = (UWord)(_zzarg1);                             \
+      UWord   _arg2  = (UWord)(_zzarg2);                             \
+      WCache* _cache = &(_zzcache);                                  \
+      tl_assert(_cache->dynMax >= 1);                                \
+      tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX);                \
+      tl_assert(_cache->inUse >= 0);                                 \
+      tl_assert(_cache->inUse <= _cache->dynMax);                    \
+      if (_cache->inUse > 0) {                                       \
+         if (_cache->ent[0].arg1 == _arg1                            \
+             && _cache->ent[0].arg2 == _arg2)                        \
+            return (_retty)_cache->ent[0].res;                       \
+         for (_i = 1; _i < _cache->inUse; _i++) {                    \
+            if (_cache->ent[_i].arg1 == _arg1                        \
+                && _cache->ent[_i].arg2 == _arg2) {                  \
+               WCacheEnt tmp     = _cache->ent[_i-1];                \
+               _cache->ent[_i-1] = _cache->ent[_i];                  \
+               _cache->ent[_i]   = tmp;                              \
+               return (_retty)_cache->ent[_i-1].res;                 \
+            }                                                        \
+         }                                                           \
+      }                                                              \
+   } while (0)
+
+#define WCache_UPDATE(_zzcache,_zzarg1,_zzarg2,_zzresult)            \
+   do {                                                              \
+      Word    _i;                                                    \
+      UWord   _arg1  = (UWord)(_zzarg1);                             \
+      UWord   _arg2  = (UWord)(_zzarg2);                             \
+      UWord   _res   = (UWord)(_zzresult);                           \
+      WCache* _cache = &(_zzcache);                                  \
+      tl_assert(_cache->dynMax >= 1);                                \
+      tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX);                \
+      tl_assert(_cache->inUse >= 0);                                 \
+      tl_assert(_cache->inUse <= _cache->dynMax);                    \
+      if (_cache->inUse < _cache->dynMax)                            \
+         _cache->inUse++;                                            \
+      for (_i = _cache->inUse-1; _i >= 1; _i--)                      \
+         _cache->ent[_i] = _cache->ent[_i-1];                        \
+      _cache->ent[0].arg1 = _arg1;                                   \
+      _cache->ent[0].arg2 = _arg2;                                   \
+      _cache->ent[0].res  = _res;                                    \
+   } while (0)
+
+
+//------------------------------------------------------------------//
+//---                          WordSet                           ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+typedef
+   struct {
+      WordSetU* owner; /* for sanity checking */
+      Word*     words;
+      Int       size; /* Really this should be SizeT */
+   }
+   WordVec;
+
+/* ix2vec[0 .. ix2vec_used-1] are pointers to the lock sets (WordVecs)
+   really.  vec2ix is the inverse mapping, mapping WordVec* to the
+   corresponding ix2vec entry number.  The two mappings are mutually
+   redundant. */
+struct _WordSetU {
+      void*     (*alloc)(SizeT);
+      void      (*dealloc)(void*);
+      WordFM*   vec2ix; /* WordVec-to-WordSet mapping tree */
+      WordVec** ix2vec; /* WordSet-to-WordVec mapping array */
+      UInt      ix2vec_size;
+      UInt      ix2vec_used;
+      WordSet   empty; /* cached, for speed */
+      /* Caches for some operations */
+      WCache    cache_addTo;
+      WCache    cache_delFrom;
+      WCache    cache_intersect;
+      WCache    cache_minus;
+      /* Stats */
+      UWord     n_add;
+      UWord     n_add_uncached;
+      UWord     n_del;
+      UWord     n_del_uncached;
+      UWord     n_union;
+      UWord     n_intersect;
+      UWord     n_intersect_uncached;
+      UWord     n_minus;
+      UWord     n_minus_uncached;
+      UWord     n_elem;
+      UWord     n_doubleton;
+      UWord     n_isEmpty;
+      UWord     n_isSingleton;
+      UWord     n_anyElementOf;
+      UWord     n_isSubsetOf;
+   };
+
+/* Create a new WordVec of the given size. */
+
+static WordVec* new_WV_of_size ( WordSetU* wsu, Int sz )
+{
+   WordVec* wv;
+   tl_assert(sz >= 0);
+   wv = wsu->alloc( sizeof(WordVec) );
+   wv->owner = wsu;
+   wv->words = NULL;
+   wv->size = sz;
+   if (sz > 0) {
+     wv->words = wsu->alloc( (SizeT)sz * sizeof(Word) );
+   }
+   return wv;
+}
+
+static void delete_WV ( WordVec* wv )
+{
+   void (*dealloc)(void*) = wv->owner->dealloc;
+   if (wv->words) {
+      dealloc(wv->words);
+   }
+   dealloc(wv);
+}
+static void delete_WV_for_FM ( Word wv ) {
+   delete_WV( (WordVec*)wv );
+}
+
+static Word cmp_WordVecs_for_FM ( Word wv1W, Word wv2W )
+{
+   Int      i;
+   WordVec* wv1    = (WordVec*)wv1W;
+   WordVec* wv2    = (WordVec*)wv2W;
+   Int      common = wv1->size < wv2->size ? wv1->size : wv2->size;
+   for (i = 0; i < common; i++) {
+      if (wv1->words[i] == wv2->words[i])
+         continue;
+      if (wv1->words[i] < wv2->words[i])
+         return -1;
+      if (wv1->words[i] > wv2->words[i])
+         return 1;
+      tl_assert(0);
+   }
+   /* Ok, the common sections are identical.  So now consider the
+      tails.  Both sets are considered to finish in an implied
+      sequence of -infinity. */
+   if (wv1->size < wv2->size) {
+      tl_assert(common == wv1->size);
+      return -1; /* impliedly, wv1 contains some -infinitys in places
+                    where wv2 doesn't. */
+   }
+   if (wv1->size > wv2->size) {
+      tl_assert(common == wv2->size);
+      return 1;
+   }
+   tl_assert(common == wv1->size);
+   return 0; /* identical */
+}
+
+static void ensure_ix2vec_space ( WordSetU* wsu )
+{
+   UInt      i, new_sz;
+   WordVec** new_vec;
+   tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+   if (wsu->ix2vec_used < wsu->ix2vec_size)
+      return;
+   new_sz = 2 * wsu->ix2vec_size;
+   if (new_sz == 0) new_sz = 2;
+   new_vec = wsu->alloc( new_sz * sizeof(WordVec*) );
+   tl_assert(new_vec);
+   for (i = 0; i < wsu->ix2vec_size; i++)
+      new_vec[i] = wsu->ix2vec[i];
+   if (wsu->ix2vec)
+      wsu->dealloc(wsu->ix2vec);
+   wsu->ix2vec = new_vec;
+   wsu->ix2vec_size = new_sz;
+}
+
+/* Index into a WordSetU, doing the obvious range check.  Failure of
+   the assertions marked XXX and YYY is an indication of passing the
+   wrong WordSetU* in the public API of this module. */
+static WordVec* do_ix2vec ( WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv;
+   tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+   if (wsu->ix2vec_used > 0)
+      tl_assert(wsu->ix2vec);
+   /* If this assertion fails, it may mean you supplied a 'ws'
+      that does not come from the 'wsu' universe. */
+   tl_assert(ws < wsu->ix2vec_used); /* XXX */
+   wv = wsu->ix2vec[ws];
+   /* Make absolutely sure that 'ws' is a member of 'wsu'. */
+   tl_assert(wv);
+   tl_assert(wv->owner == wsu); /* YYY */
+   return wv;
+}
+
+/* See if wv is contained within wsu.  If so, deallocate wv and return
+   the index of the already-present copy.  If not, add wv to both the
+   vec2ix and ix2vec mappings and return its index. 
+*/
+static WordSet add_or_dealloc_WordVec( WordSetU* wsu, WordVec* wv_new )
+{
+   Bool     have;
+   WordVec* wv_old;
+   Word/*Set*/ ix_old = -1;
+   /* Really WordSet, but need something that can safely be casted to
+      a Word* in the lookupFM.  Making it WordSet (which is 32 bits)
+      causes failures on a 64-bit platform. */
+   tl_assert(wv_new->owner == wsu);
+   have = HG_(lookupFM)( wsu->vec2ix, 
+                         (Word*)(void*)&wv_old, (Word*)&ix_old,
+                         (Word)wv_new );
+   if (have) {
+      tl_assert(wv_old != wv_new);
+      tl_assert(wv_old);
+      tl_assert(wv_old->owner == wsu);
+      tl_assert(ix_old < wsu->ix2vec_used);
+      tl_assert(wsu->ix2vec[ix_old] == wv_old);
+      delete_WV( wv_new );
+      return (WordSet)ix_old;
+   } else {
+      ensure_ix2vec_space( wsu );
+      tl_assert(wsu->ix2vec);
+      tl_assert(wsu->ix2vec_used < wsu->ix2vec_size);
+      wsu->ix2vec[wsu->ix2vec_used] = wv_new;
+      HG_(addToFM)( wsu->vec2ix, (Word)wv_new, (Word)wsu->ix2vec_used );
+      if (0) VG_(printf)("aodW %d\n", (Int)wsu->ix2vec_used );
+      wsu->ix2vec_used++;
+      tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
+      return (WordSet)(wsu->ix2vec_used - 1);
+   }
+}
+
+
+WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( SizeT ),
+                             void  (*dealloc)(void*),
+                             Word  cacheSize )
+{
+   WordSetU* wsu;
+   WordVec*  empty;
+
+   wsu          = alloc_nofail( sizeof(WordSetU) );
+   VG_(memset)( wsu, 0, sizeof(WordSetU) );
+   wsu->alloc   = alloc_nofail;
+   wsu->dealloc = dealloc;
+   wsu->vec2ix  = HG_(newFM)( alloc_nofail, dealloc, cmp_WordVecs_for_FM );
+   wsu->ix2vec_used = 0;
+   wsu->ix2vec_size = 0;
+   wsu->ix2vec      = NULL;
+   WCache_INIT(wsu->cache_addTo,     cacheSize);
+   WCache_INIT(wsu->cache_delFrom,   cacheSize);
+   WCache_INIT(wsu->cache_intersect, cacheSize);
+   WCache_INIT(wsu->cache_minus,     cacheSize);
+   empty = new_WV_of_size( wsu, 0 );
+   wsu->empty = add_or_dealloc_WordVec( wsu, empty );
+
+   return wsu;
+}
+
+void HG_(deleteWordSetU) ( WordSetU* wsu )
+{
+   void (*dealloc)(void*) = wsu->dealloc;
+   tl_assert(wsu->vec2ix);
+   HG_(deleteFM)( wsu->vec2ix, delete_WV_for_FM, NULL/*val-finalizer*/ );
+   if (wsu->ix2vec)
+      dealloc(wsu->ix2vec);
+   dealloc(wsu);
+}
+
+WordSet HG_(emptyWS) ( WordSetU* wsu )
+{
+   return wsu->empty;
+}
+
+Bool HG_(isEmptyWS) ( WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv = do_ix2vec( wsu, ws );
+   wsu->n_isEmpty++;
+   if (wv->size == 0) {
+      tl_assert(ws == wsu->empty);
+      return True;
+   } else {
+      tl_assert(ws != wsu->empty);
+      return False;
+   }
+}
+
+Bool HG_(isSingletonWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+   WordVec* wv;
+   tl_assert(wsu);
+   wsu->n_isSingleton++;
+   wv = do_ix2vec( wsu, ws );
+   return (Bool)(wv->size == 1 && wv->words[0] == w);
+}
+
+Int HG_(cardinalityWS) ( WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv;
+   tl_assert(wsu);
+   wv = do_ix2vec( wsu, ws );
+   tl_assert(wv->size >= 0);
+   return wv->size;
+}
+
+Word HG_(anyElementOfWS) ( WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv;
+   tl_assert(wsu);
+   wsu->n_anyElementOf++;
+   wv = do_ix2vec( wsu, ws );
+   tl_assert(wv->size >= 1);
+   return wv->words[0];
+}
+
+Int HG_(cardinalityWSU) ( WordSetU* wsu )
+{
+   tl_assert(wsu);
+   return (Int)wsu->ix2vec_used;
+}
+
+void HG_(getPayloadWS) ( /*OUT*/Word** words, /*OUT*/Word* nWords, 
+                         WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv;
+   tl_assert(wsu);
+   wv = do_ix2vec( wsu, ws );
+   tl_assert(wv->size >= 0);
+   *nWords = wv->size;
+   *words  = wv->words;
+}
+
+Bool HG_(plausibleWS) ( WordSetU* wsu, WordSet ws )
+{
+   if (wsu == NULL) return False;
+   if (ws < 0 || ws >= wsu->ix2vec_used)
+      return False;
+   return True;
+}
+
+Bool HG_(saneWS_SLOW) ( WordSetU* wsu, WordSet ws )
+{
+   WordVec* wv;
+   Int      i;
+   if (wsu == NULL) return False;
+   if (ws < 0 || ws >= wsu->ix2vec_used)
+      return False;
+   wv = do_ix2vec( wsu, ws );
+   /* can never happen .. do_ix2vec will assert instead.  Oh well. */
+   if (wv->owner != wsu) return False;
+   if (wv->size < 0) return False;
+   if (wv->size > 0) {
+      for (i = 0; i < wv->size-1; i++) {
+         if (wv->words[i] >= wv->words[i+1])
+            return False;
+      }
+   }
+   return True;
+}
+
+Bool HG_(elemWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+   Int      i;
+   WordVec* wv = do_ix2vec( wsu, ws );
+   wsu->n_elem++;
+   for (i = 0; i < wv->size; i++) {
+      if (wv->words[i] == w)
+         return True;
+   }
+   return False;
+}
+
+WordSet HG_(doubletonWS) ( WordSetU* wsu, Word w1, Word w2 )
+{
+   WordVec* wv;
+   wsu->n_doubleton++;
+   if (w1 == w2) {
+      wv = new_WV_of_size(wsu, 1);
+      wv->words[0] = w1;
+   }
+   else if (w1 < w2) {
+      wv = new_WV_of_size(wsu, 2);
+      wv->words[0] = w1;
+      wv->words[1] = w2;
+   }
+   else {
+      tl_assert(w1 > w2);
+      wv = new_WV_of_size(wsu, 2);
+      wv->words[0] = w2;
+      wv->words[1] = w1;
+   }
+   return add_or_dealloc_WordVec( wsu, wv );
+}
+
+WordSet HG_(singletonWS) ( WordSetU* wsu, Word w )
+{
+   return HG_(doubletonWS)( wsu, w, w );
+}
+
+WordSet HG_(isSubsetOf) ( WordSetU* wsu, WordSet small, WordSet big )
+{
+   wsu->n_isSubsetOf++;
+   return small == HG_(intersectWS)( wsu, small, big );
+}
+
+void HG_(ppWS) ( WordSetU* wsu, WordSet ws )
+{
+   Int      i;
+   WordVec* wv;
+   tl_assert(wsu);
+   wv = do_ix2vec( wsu, ws );
+   VG_(printf)("{");
+   for (i = 0; i < wv->size; i++) {
+      VG_(printf)("%p", (void*)wv->words[i]);
+      if (i < wv->size-1)
+         VG_(printf)(",");
+   }
+   VG_(printf)("}");
+}
+
+void HG_(ppWSUstats) ( WordSetU* wsu, HChar* name )
+{
+   VG_(printf)("   WordSet \"%s\":\n", name);
+   VG_(printf)("      addTo        %10u (%u uncached)\n",
+               wsu->n_add, wsu->n_add_uncached);
+   VG_(printf)("      delFrom      %10u (%u uncached)\n", 
+               wsu->n_del, wsu->n_del_uncached);
+   VG_(printf)("      union        %10u\n", wsu->n_union);
+   VG_(printf)("      intersect    %10u (%u uncached) [nb. incl isSubsetOf]\n", 
+               wsu->n_intersect, wsu->n_intersect_uncached);
+   VG_(printf)("      minus        %10u (%u uncached)\n",
+               wsu->n_minus, wsu->n_minus_uncached);
+   VG_(printf)("      elem         %10u\n",   wsu->n_elem);
+   VG_(printf)("      doubleton    %10u\n",   wsu->n_doubleton);
+   VG_(printf)("      isEmpty      %10u\n",   wsu->n_isEmpty);
+   VG_(printf)("      isSingleton  %10u\n",   wsu->n_isSingleton);
+   VG_(printf)("      anyElementOf %10u\n",   wsu->n_anyElementOf);
+   VG_(printf)("      isSubsetOf   %10u\n",   wsu->n_isSubsetOf);
+}
+
+WordSet HG_(addToWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+   Int      k, j;
+   WordVec* wv_new;
+   WordVec* wv;
+   WordSet  result = (WordSet)(-1); /* bogus */
+
+   wsu->n_add++;
+   WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_addTo, ws, w);
+   wsu->n_add_uncached++;
+
+   /* If already present, this is a no-op. */
+   wv = do_ix2vec( wsu, ws );
+   for (k = 0; k < wv->size; k++) {
+      if (wv->words[k] == w) {
+         result = ws;
+         goto out;
+      }
+   }
+   /* Ok, not present.  Build a new one ... */
+   wv_new = new_WV_of_size( wsu, wv->size + 1 );
+   k = j = 0;
+   for (; k < wv->size && wv->words[k] < w; k++) {
+      wv_new->words[j++] = wv->words[k];
+   }
+   wv_new->words[j++] = w;
+   for (; k < wv->size; k++) {
+      tl_assert(wv->words[k] > w);
+      wv_new->words[j++] = wv->words[k];
+   }
+   tl_assert(j == wv_new->size);
+
+   /* Find any existing copy, or add the new one. */
+   result = add_or_dealloc_WordVec( wsu, wv_new );
+   tl_assert(result != (WordSet)(-1));
+
+  out:
+   WCache_UPDATE(wsu->cache_addTo, ws, w, result);
+   return result;
+}
+
+WordSet HG_(delFromWS) ( WordSetU* wsu, WordSet ws, Word w )
+{
+   Int      i, j, k;
+   WordVec* wv_new;
+   WordSet  result = (WordSet)(-1); /* bogus */
+   WordVec* wv = do_ix2vec( wsu, ws );
+
+   wsu->n_del++;
+
+   /* special case empty set */
+   if (wv->size == 0) {
+      tl_assert(ws == wsu->empty);
+      return ws;
+   }
+
+   WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_delFrom, ws, w);
+   wsu->n_del_uncached++;
+
+   /* If not already present, this is a no-op. */
+   for (i = 0; i < wv->size; i++) {
+      if (wv->words[i] == w)
+         break;
+   }
+   if (i == wv->size) {
+      result = ws;
+      goto out;
+   }
+   /* So w is present in ws, and the new set will be one element
+      smaller. */
+   tl_assert(i >= 0 && i < wv->size);
+   tl_assert(wv->size > 0);
+
+   wv_new = new_WV_of_size( wsu, wv->size - 1 );
+   j = k = 0;
+   for (; j < wv->size; j++) {
+      if (j == i)
+         continue;
+      wv_new->words[k++] = wv->words[j];
+   }
+   tl_assert(k == wv_new->size);
+
+   result = add_or_dealloc_WordVec( wsu, wv_new );
+   if (wv->size == 1) {
+      tl_assert(result == wsu->empty);
+   }
+
+  out:
+   WCache_UPDATE(wsu->cache_delFrom, ws, w, result);
+   return result;
+}
+
+WordSet HG_(unionWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+   Int      i1, i2, k, sz;
+   WordVec* wv_new;
+   WordVec* wv1 = do_ix2vec( wsu, ws1 );
+   WordVec* wv2 = do_ix2vec( wsu, ws2 );
+   wsu->n_union++;
+   sz = 0;
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      sz++;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         i2++;
+      } else {
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+   if (i1 == wv1->size && i2 < wv2->size) {
+      sz += (wv2->size - i2);
+   }
+   if (i2 == wv2->size && i1 < wv1->size) {
+      sz += (wv1->size - i1);
+   }
+
+   wv_new = new_WV_of_size( wsu, sz );
+   k = 0;
+
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         wv_new->words[k++] = wv1->words[i1];
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         wv_new->words[k++] = wv2->words[i2];
+         i2++;
+      } else {
+         wv_new->words[k++] = wv1->words[i1];
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+   if (i1 == wv1->size && i2 < wv2->size) {
+      while (i2 < wv2->size)
+         wv_new->words[k++] = wv2->words[i2++];
+   }
+   if (i2 == wv2->size && i1 < wv1->size) {
+      while (i1 < wv1->size)
+         wv_new->words[k++] = wv1->words[i1++];
+   }
+
+   tl_assert(k == sz);
+
+   return add_or_dealloc_WordVec( wsu, wv_new );
+}
+
+WordSet HG_(intersectWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+   Int      i1, i2, k, sz;
+   WordSet  ws_new = (WordSet)(-1); /* bogus */
+   WordVec* wv_new;
+   WordVec* wv1; 
+   WordVec* wv2; 
+
+   wsu->n_intersect++;
+
+   /* Deal with an obvious case fast. */
+   if (ws1 == ws2)
+      return ws1;
+
+   /* Since intersect(x,y) == intersect(y,x), convert both variants to
+      the same query.  This reduces the number of variants the cache
+      has to deal with. */
+   if (ws1 > ws2) {
+      WordSet wst = ws1; ws1 = ws2; ws2 = wst;
+   }
+
+   WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_intersect, ws1, ws2);
+   wsu->n_intersect_uncached++;
+
+   wv1 = do_ix2vec( wsu, ws1 );
+   wv2 = do_ix2vec( wsu, ws2 );
+   sz = 0;
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         i2++;
+      } else {
+         sz++;
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+
+   wv_new = new_WV_of_size( wsu, sz );
+   k = 0;
+
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         i2++;
+      } else {
+         wv_new->words[k++] = wv1->words[i1];
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+
+   tl_assert(k == sz);
+
+   ws_new = add_or_dealloc_WordVec( wsu, wv_new );
+   if (sz == 0) {
+      tl_assert(ws_new == wsu->empty);
+   }
+
+   tl_assert(ws_new != (WordSet)(-1));
+   WCache_UPDATE(wsu->cache_intersect, ws1, ws2, ws_new);
+
+   return ws_new;
+}
+
+WordSet HG_(minusWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
+{
+   Int      i1, i2, k, sz;
+   WordSet  ws_new = (WordSet)(-1); /* bogus */
+   WordVec* wv_new;
+   WordVec* wv1;
+   WordVec* wv2;
+   
+   wsu->n_minus++;
+   WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_minus, ws1, ws2);
+   wsu->n_minus_uncached++;
+
+   wv1 = do_ix2vec( wsu, ws1 );
+   wv2 = do_ix2vec( wsu, ws2 );
+   sz = 0;
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         sz++;
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         i2++;
+      } else {
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+   if (i2 == wv2->size && i1 < wv1->size) {
+      sz += (wv1->size - i1);
+   }
+
+   wv_new = new_WV_of_size( wsu, sz );
+   k = 0;
+
+   i1 = i2 = 0;
+   while (1) {
+      if (i1 >= wv1->size || i2 >= wv2->size)
+         break;
+      if (wv1->words[i1] < wv2->words[i2]) {
+         wv_new->words[k++] = wv1->words[i1];
+         i1++;
+      } else 
+      if (wv1->words[i1] > wv2->words[i2]) {
+         i2++;
+      } else {
+         i1++;
+         i2++;
+      }
+   }
+   tl_assert(i1 <= wv1->size);
+   tl_assert(i2 <= wv2->size);
+   tl_assert(i1 == wv1->size || i2 == wv2->size);
+   if (i2 == wv2->size && i1 < wv1->size) {
+      while (i1 < wv1->size)
+         wv_new->words[k++] = wv1->words[i1++];
+   }
+
+   tl_assert(k == sz);
+
+   ws_new = add_or_dealloc_WordVec( wsu, wv_new );
+   if (sz == 0) {
+      tl_assert(ws_new == wsu->empty);
+   }
+
+   tl_assert(ws_new != (WordSet)(-1));
+   WCache_UPDATE(wsu->cache_minus, ws1, ws2, ws_new);
+
+   return ws_new;
+}
+
+static __attribute__((unused))
+void show_WS ( WordSetU* wsu, WordSet ws )
+{
+   Int i;
+   WordVec* wv = do_ix2vec( wsu, ws );
+   VG_(printf)("#%u{", ws);
+   for (i = 0; i < wv->size; i++) {
+      VG_(printf)("%lu", wv->words[i]);
+      if (i < wv->size-1)
+         VG_(printf)(",");
+   }
+   VG_(printf)("}\n");
+}
+
+//------------------------------------------------------------------//
+//---                        end WordSet                         ---//
+//---                       Implementation                       ---//
+//------------------------------------------------------------------//
+
+/*--------------------------------------------------------------------*/
+/*--- end                                             hg_wordset.c ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/hg_wordset.h b/helgrind/hg_wordset.h
new file mode 100644
index 0000000..5c40ef4
--- /dev/null
+++ b/helgrind/hg_wordset.h
@@ -0,0 +1,100 @@
+
+/*--------------------------------------------------------------------*/
+/*--- Sets of words, with unique set identifiers.                  ---*/
+/*---                                                 hg_wordset.h ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+   This file is part of Helgrind, a Valgrind tool for detecting errors
+   in threaded programs.
+
+   Copyright (C) 2007-2007 OpenWorks LLP
+       info@open-works.co.uk
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307, USA.
+
+   The GNU General Public License is contained in the file COPYING.
+
+   Neither the names of the U.S. Department of Energy nor the
+   University of California nor the names of its contributors may be
+   used to endorse or promote products derived from this software
+   without prior written permission.
+*/
+
+#ifndef __HG_WORDSET_H
+#define __HG_WORDSET_H
+
+//------------------------------------------------------------------//
+//---                          WordSet                           ---//
+//---                      Public Interface                      ---//
+//------------------------------------------------------------------//
+
+typedef  struct _WordSetU  WordSetU;  /* opaque */
+
+typedef  UInt              WordSet;   /* opaque, small int index */
+
+/* Allocate and initialise a WordSetU */
+WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( SizeT ),
+                             void  (*dealloc)(void*),
+                             Word  cacheSize );
+
+/* Free up the WordSetU. */
+void HG_(deleteWordSetU) ( WordSetU* );
+
+/* Get the number of elements in this WordSetU. */
+Int HG_(cardinalityWSU) ( WordSetU* );
+
+/* Show performance stats for this WordSetU. */
+void HG_(ppWSUstats) ( WordSetU* wsu, HChar* name );
+
+
+/* Element-level operations on WordSets.  Note that the WordSet
+   numbers given out are 0, 1, 2, 3, etc, and as it happens 0 always
+   represents the empty set. */
+
+WordSet HG_(emptyWS)        ( WordSetU* );
+WordSet HG_(addToWS)        ( WordSetU*, WordSet, Word );
+WordSet HG_(delFromWS)      ( WordSetU*, WordSet, Word );
+WordSet HG_(unionWS)        ( WordSetU*, WordSet, WordSet );
+WordSet HG_(intersectWS)    ( WordSetU*, WordSet, WordSet );
+WordSet HG_(minusWS)        ( WordSetU*, WordSet, WordSet );
+Bool    HG_(isEmptyWS)      ( WordSetU*, WordSet );
+Bool    HG_(isSingletonWS)  ( WordSetU*, WordSet, Word );
+Word    HG_(anyElementOfWS) ( WordSetU*, WordSet );
+Int     HG_(cardinalityWS)  ( WordSetU*, WordSet );
+Bool    HG_(elemWS)         ( WordSetU*, WordSet, Word );
+WordSet HG_(doubletonWS)    ( WordSetU*, Word, Word );
+WordSet HG_(singletonWS)    ( WordSetU*, Word );
+WordSet HG_(isSubsetOf)     ( WordSetU*, WordSet, WordSet );
+
+Bool    HG_(plausibleWS)    ( WordSetU*, WordSet );
+Bool    HG_(saneWS_SLOW)    ( WordSetU*, WordSet );
+
+void    HG_(ppWS)           ( WordSetU*, WordSet );
+void    HG_(getPayloadWS)   ( /*OUT*/Word** words, /*OUT*/Word* nWords, 
+                             WordSetU*, WordSet );
+
+
+//------------------------------------------------------------------//
+//---                        end WordSet                         ---//
+//---                      Public Interface                      ---//
+//------------------------------------------------------------------//
+
+#endif /* ! __HG_WORDSET_H */
+
+/*--------------------------------------------------------------------*/
+/*--- end                                             hg_wordset.h ---*/
+/*--------------------------------------------------------------------*/
diff --git a/helgrind/tests/Makefile.am b/helgrind/tests/Makefile.am
new file mode 100644
index 0000000..ac84a96
--- /dev/null
+++ b/helgrind/tests/Makefile.am
@@ -0,0 +1,124 @@
+
+# For AM_FLAG_M3264_PRI
+include $(top_srcdir)/Makefile.flags.am
+
+noinst_SCRIPTS = filter_stderr
+
+EXTRA_DIST = $(noinst_SCRIPTS) \
+	hg01_all_ok.vgtest hg01_all_ok.stdout.exp \
+		hg01_all_ok.stderr.exp-glibc25-amd64 \
+	hg02_deadlock.vgtest hg02_deadlock.stdout.exp \
+		hg02_deadlock.stderr.exp-glibc25-amd64 \
+		hg02_deadlock.stderr.exp-glibc25-x86 \
+	hg03_inherit.vgtest hg03_inherit.stdout.exp \
+		hg03_inherit.stderr.exp-glibc25-amd64 \
+		hg03_inherit.stderr.exp-glibc25-x86 \
+	hg04_race.vgtest hg04_race.stdout.exp \
+		hg04_race.stderr.exp-glibc25-amd64 \
+		hg04_race.stderr.exp-glibc25-x86 \
+	hg05_race2.vgtest hg05_race2.stdout.exp \
+		hg05_race2.stderr.exp-glibc25-amd64 \
+		hg05_race2.stderr.exp-glibc25-x86 \
+	hg06_readshared.vgtest hg06_readshared.stdout.exp \
+		hg06_readshared.stderr.exp-glibc25-amd64 \
+	tc01_simple_race.vgtest tc01_simple_race.stdout.exp \
+		tc01_simple_race.stderr.exp-glibc25-amd64 \
+		tc01_simple_race.stderr.exp-glibc25-x86 \
+	tc02_simple_tls.vgtest tc02_simple_tls.stdout.exp \
+		tc02_simple_tls.stderr.exp-glibc25-amd64 \
+	tc03_re_excl.vgtest tc03_re_excl.stdout.exp \
+		tc03_re_excl.stderr.exp-glibc25-amd64 \
+	tc04_free_lock.vgtest tc04_free_lock.stdout.exp \
+		tc04_free_lock.stderr.exp-glibc25-amd64 \
+	tc05_simple_race.vgtest tc05_simple_race.stdout.exp \
+		tc05_simple_race.stderr.exp-glibc25-amd64 \
+		tc05_simple_race.stderr.exp-glibc25-x86 \
+	tc06_two_races.vgtest tc06_two_races.stdout.exp \
+		tc06_two_races.stderr.exp-glibc25-amd64 \
+		tc06_two_races.stderr.exp-glibc25-x86 \
+	tc07_hbl1.vgtest tc07_hbl1.stdout.exp \
+		tc07_hbl1.stderr.exp-glibc25-amd64 \
+	tc08_hbl2.vgtest tc08_hbl2.stdout.exp \
+		tc08_hbl2.stderr.exp-glibc25-amd64 \
+	tc09_bad_unlock.vgtest tc09_bad_unlock.stdout.exp \
+		tc09_bad_unlock.stderr.exp-glibc23-amd64 \
+		tc09_bad_unlock.stderr.exp-glibc25-amd64 \
+		tc09_bad_unlock.stderr.exp-glibc25-x86 \
+	tc10_rec_lock.vgtest tc10_rec_lock.stdout.exp \
+		tc10_rec_lock.stderr.exp-glibc25-amd64 \
+	tc11_XCHG.vgtest tc11_XCHG.stdout.exp \
+		tc11_XCHG.stderr.exp-glibc25-amd64 \
+	tc12_rwl_trivial.vgtest tc12_rwl_trivial.stdout.exp \
+		tc12_rwl_trivial.stderr.exp-glibc25-amd64 \
+	tc13_laog1.vgtest tc13_laog1.stdout.exp \
+		tc13_laog1.stderr.exp-glibc25-amd64 \
+	tc14_laog_dinphils.vgtest tc14_laog_dinphils.stdout.exp \
+		tc14_laog_dinphils.stderr.exp-glibc25-amd64 \
+		tc14_laog_dinphils.stderr.exp-glibc25-x86 \
+	tc15_laog_lockdel.vgtest tc15_laog_lockdel.stdout.exp \
+		tc15_laog_lockdel.stderr.exp-glibc25-amd64 \
+	tc16_byterace.vgtest tc16_byterace.stdout.exp \
+		tc16_byterace.stderr.exp-glibc25-amd64 \
+		tc16_byterace.stderr.exp-glibc25-x86 \
+	tc17_sembar.vgtest tc17_sembar.stdout.exp \
+		tc17_sembar.stderr.exp-glibc25-amd64 \
+		tc17_sembar.stderr.exp-glibc25-x86 \
+	tc18_semabuse.vgtest tc18_semabuse.stdout.exp \
+		tc18_semabuse.stderr.exp-glibc25-amd64 \
+		tc18_semabuse.stderr.exp-glibc25-x86 \
+	tc19_shadowmem.vgtest tc19_shadowmem.stdout.exp \
+		tc19_shadowmem.stderr.exp-glibc25-amd64 \
+		tc19_shadowmem.stderr.exp-glibc25-x86 \
+	tc20_verifywrap.vgtest tc20_verifywrap.stdout.exp \
+		tc20_verifywrap.stderr.exp-glibc23-amd64 \
+		tc20_verifywrap.stderr.exp-glibc25-amd64 \
+		tc20_verifywrap.stderr.exp-glibc25-x86 \
+	tc21_pthonce.vgtest tc21_pthonce.stdout.exp \
+		tc21_pthonce.stderr.exp-glibc25-amd64 \
+		tc21_pthonce.stderr.exp-glibc25-x86 \
+	tc22_exit_w_lock.vgtest tc22_exit_w_lock.stdout.exp \
+		tc22_exit_w_lock.stderr.exp-glibc25-amd64 \
+		tc22_exit_w_lock.stderr.exp-glibc25-x86 \
+	tc23_bogus_condwait.vgtest tc23_bogus_condwait.stdout.exp \
+		tc23_bogus_condwait.stderr.exp-glibc25-amd64 \
+		tc23_bogus_condwait.stderr.exp-glibc25-x86
+
+check_PROGRAMS = \
+	hg01_all_ok \
+	hg02_deadlock \
+	hg03_inherit \
+	hg04_race \
+	hg05_race2 \
+	hg06_readshared \
+	tc01_simple_race \
+	tc02_simple_tls \
+	tc03_re_excl \
+	tc04_free_lock \
+	tc05_simple_race \
+	tc06_two_races \
+	tc07_hbl1 \
+	tc08_hbl2 \
+	tc09_bad_unlock \
+	tc10_rec_lock \
+	tc11_XCHG \
+	tc12_rwl_trivial \
+	tc13_laog1 \
+	tc14_laog_dinphils \
+	tc15_laog_lockdel \
+	tc16_byterace \
+	tc17_sembar \
+	tc18_semabuse \
+	tc19_shadowmem \
+	tc20_verifywrap \
+	tc21_pthonce \
+	tc22_exit_w_lock \
+	tc23_bogus_condwait
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/include \
+                -I$(top_srcdir)/coregrind -I$(top_builddir)/include \
+                -I@VEX_DIR@/pub
+
+# are these necessary?
+AM_CFLAGS	= $(WERROR) -Winline -Wall -Wshadow -g $(AM_FLAG_M3264_PRI)
+
+LDADD		= -lpthread
diff --git a/helgrind/tests/filter_stderr b/helgrind/tests/filter_stderr
new file mode 100755
index 0000000..f2b45d7
--- /dev/null
+++ b/helgrind/tests/filter_stderr
@@ -0,0 +1,30 @@
+#! /bin/sh
+
+dir=`dirname $0`
+
+$dir/../../tests/filter_stderr_basic                    |
+
+# Anonymise addresses
+$dir/../../tests/filter_addresses                       |
+
+# Remove "Helgrind, ..." line and the following copyright line.
+sed "/^Helgrind, a thread error detector/ , /./ d" |
+
+# Anonymise line numbers in hg_intercepts.c
+sed "s/hg_intercepts.c:[0-9]*/hg_intercepts.c:.../g"  |
+
+# Change (eg) "/lib64/libpthread-2.5.so" into "/lib/libpthread..."
+sed "s/lib64/lib/g" | 
+sed "s/libpthread.*so/libpthread\.\.\./g" |
+
+# Change (eg) "pthread_create@@GLIBC_2.2.5" into "pthread_create@GLIBC"
+#    and (eg) "pthread_create@GLIBC_2.1"    into "pthread_create@GLIBC"
+sed "s/@@*GLIBC_2[0123456789\.]*/@GLIBC_/g" |
+
+# Tidy up in cases where glibc (+ libdl + libpthread + ld) have
+# been built with debugging information, hence source locs are present
+sed "s/(createthread.c:[0-9]*)/(in \/lib\/libpthread...)/g" |
+sed "s/(clone.S:[0-9]*)/(in \/...libc...)/g" |
+sed "s/start_thread (pthread_create.c:[0-9]*)$/start_thread (in \/lib\/libpthread...)/g" |
+
+$dir/../../tests/filter_test_paths
diff --git a/helgrind/tests/hg01_all_ok.c b/helgrind/tests/hg01_all_ok.c
new file mode 100644
index 0000000..144ce60
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.c
@@ -0,0 +1,32 @@
+/* All OK */
+
+#include <pthread.h>
+
+static pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+
+static int shared;
+
+static void *th(void *v)
+{
+	pthread_mutex_lock(&mx);
+	shared++;
+	pthread_mutex_unlock(&mx);
+
+	return 0;
+}
+
+int main()
+{
+	pthread_t a, b;
+
+	pthread_mutex_lock(&mx);
+	pthread_mutex_unlock(&mx);
+
+	pthread_create(&a, NULL, th, NULL);	
+	pthread_create(&b, NULL, th, NULL);
+
+	pthread_join(a, NULL);
+	pthread_join(b, NULL);
+
+	return 0;
+}
diff --git a/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64 b/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg01_all_ok.stdout.exp b/helgrind/tests/hg01_all_ok.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.stdout.exp
diff --git a/helgrind/tests/hg01_all_ok.vgtest b/helgrind/tests/hg01_all_ok.vgtest
new file mode 100644
index 0000000..9524976
--- /dev/null
+++ b/helgrind/tests/hg01_all_ok.vgtest
@@ -0,0 +1 @@
+prog: hg01_all_ok
diff --git a/helgrind/tests/hg02_deadlock.c b/helgrind/tests/hg02_deadlock.c
new file mode 100644
index 0000000..1142f5c
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.c
@@ -0,0 +1,43 @@
+/* Simple possible deadlock */
+#include <pthread.h>
+
+static pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
+
+static void *t1(void *v)
+{
+	pthread_mutex_lock(&m1);
+	pthread_mutex_lock(&m2);
+	pthread_mutex_unlock(&m1);
+	pthread_mutex_unlock(&m2);
+
+	return 0;
+}
+
+static void *t2(void *v)
+{
+	pthread_mutex_lock(&m2);
+	pthread_mutex_lock(&m1);
+	pthread_mutex_unlock(&m1);
+	pthread_mutex_unlock(&m2);
+
+	return 0;
+}
+
+int main()
+{
+	pthread_t a, b;
+	
+	/* prevent spurious messages from the dynamic linker */
+	pthread_mutex_lock(&m1);
+	pthread_mutex_unlock(&m1);
+
+	pthread_create(&a, NULL, t1, NULL);	
+	pthread_create(&b, NULL, t2, NULL);
+
+	pthread_join(a, NULL);
+	pthread_join(b, NULL);
+
+	return 0;
+}
+
diff --git a/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64 b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8fe4ea4
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-amd64
@@ -0,0 +1,28 @@
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg02_deadlock.c:36)
+
+Thread #3: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t2 (hg02_deadlock.c:20)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Required order was established by acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t1 (hg02_deadlock.c:9)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  followed by a later acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t1 (hg02_deadlock.c:10)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86 b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..6f7fa48
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stderr.exp-glibc25-x86
@@ -0,0 +1,27 @@
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg02_deadlock.c:36)
+
+Thread #3: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t2 (hg02_deadlock.c:20)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Required order was established by acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t1 (hg02_deadlock.c:9)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  followed by a later acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: t1 (hg02_deadlock.c:10)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg02_deadlock.stdout.exp b/helgrind/tests/hg02_deadlock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.stdout.exp
diff --git a/helgrind/tests/hg02_deadlock.vgtest b/helgrind/tests/hg02_deadlock.vgtest
new file mode 100644
index 0000000..ff0deb7
--- /dev/null
+++ b/helgrind/tests/hg02_deadlock.vgtest
@@ -0,0 +1 @@
+prog: hg02_deadlock
diff --git a/helgrind/tests/hg03_inherit.c b/helgrind/tests/hg03_inherit.c
new file mode 100644
index 0000000..7c429f8
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.c
@@ -0,0 +1,67 @@
+
+/* I don't think this is a very good test .. all this
+   sleepery is highly confusing. */
+
+/* test child thread inheriting data */
+
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+static volatile int shared[2];
+
+static void *t1(void *v)
+{
+	volatile int *ip = (int *)v;
+	if (0) printf("ta W\n");
+	*ip += 44;
+	*ip *= 2;
+	sleep(1);
+	return 0;
+}
+
+static void *t2(void *v)
+{
+	volatile int *ip = (int *)v;
+	sleep(2);
+	if (0) printf("tb W\n");
+	*ip += 88;
+	*ip *= 3;
+	sleep(1);
+	return 0;
+}
+
+int main(void)
+{
+	pthread_t a, b;
+	volatile int ret = 0;
+
+	sleep(0);
+
+	shared[0] = 22;
+	shared[1] = 77;
+
+	pthread_create(&a, NULL, t1, (void *)&shared[0]);
+	// a steals shared[0] from root thread, so is excl(a)	
+	pthread_create(&b, NULL, t2, (void *)&shared[1]);
+	// b steals shared[1] from root thread, so is excl(b)	
+
+	pthread_join(a, NULL);
+	// b's stuff (shared[1]) still belongs to b, so is excl(b)
+
+	// ret is excl(root), and shared[0] is re-acquired as excl(root)
+	// since a joined to root
+	if (0) printf("r R1\n");
+	ret += shared[0];	/* no error - a is finished */
+
+	// but shared[1] is excl(b); hence we're reading excl(b)
+	// without a lock and without a dependency edge
+	if (0) printf("r R2\n");
+	ret += shared[1];	/* expect error - b has not finished,
+				   so we can't touch shared[1] yet */
+
+	pthread_join(b, NULL);
+
+
+	return ret;
+}
diff --git a/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64 b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..3cf4b5e
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-amd64
@@ -0,0 +1,21 @@
+
+Thread #1 is the program's root thread
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg03_inherit.c:46)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: t2 (hg03_inherit.c:28)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #1, #3
+  New state: shared-modified by threads #1, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86 b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..a7e4407
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stderr.exp-glibc25-x86
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg03_inherit.c:46)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: t2 (hg03_inherit.c:28)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #1, #3
+  New state: shared-modified by threads #1, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg03_inherit.stdout.exp b/helgrind/tests/hg03_inherit.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.stdout.exp
diff --git a/helgrind/tests/hg03_inherit.vgtest b/helgrind/tests/hg03_inherit.vgtest
new file mode 100644
index 0000000..b3ac039
--- /dev/null
+++ b/helgrind/tests/hg03_inherit.vgtest
@@ -0,0 +1 @@
+prog: hg03_inherit
diff --git a/helgrind/tests/hg04_race.c b/helgrind/tests/hg04_race.c
new file mode 100644
index 0000000..111195b
--- /dev/null
+++ b/helgrind/tests/hg04_race.c
@@ -0,0 +1,27 @@
+/* A simple race */
+
+#include <pthread.h>
+#include <unistd.h>
+
+static int shared;
+
+static void *th(void *v)
+{
+	shared++;
+
+	return 0;
+}
+
+int main()
+{
+	pthread_t a, b;
+
+	pthread_create(&a, NULL, th, NULL);	
+	sleep(1);		/* force ordering */
+	pthread_create(&b, NULL, th, NULL);
+
+	pthread_join(a, NULL);
+	pthread_join(b, NULL);
+
+	return 0;
+}
diff --git a/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64 b/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..6ec1ac3
--- /dev/null
+++ b/helgrind/tests/hg04_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg04_race.c:19)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg04_race.c:21)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: th (hg04_race.c:10)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg04_race.stderr.exp-glibc25-x86 b/helgrind/tests/hg04_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..3d28bd8
--- /dev/null
+++ b/helgrind/tests/hg04_race.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg04_race.c:19)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg04_race.c:21)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: th (hg04_race.c:10)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg04_race.stdout.exp b/helgrind/tests/hg04_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg04_race.stdout.exp
diff --git a/helgrind/tests/hg04_race.vgtest b/helgrind/tests/hg04_race.vgtest
new file mode 100644
index 0000000..92b7099
--- /dev/null
+++ b/helgrind/tests/hg04_race.vgtest
@@ -0,0 +1 @@
+prog: hg04_race
diff --git a/helgrind/tests/hg05_race2.c b/helgrind/tests/hg05_race2.c
new file mode 100644
index 0000000..de01f2c
--- /dev/null
+++ b/helgrind/tests/hg05_race2.c
@@ -0,0 +1,35 @@
+/* A simple race - test symaddr */
+
+#include <pthread.h>
+#include <unistd.h>
+
+struct foo {
+	struct bar {
+		int plop[22];
+		char biff;
+	} poot[11];
+};
+
+static void *th(void *v)
+{
+	struct foo *f = (struct foo *)v;
+
+	f->poot[5].plop[11]++;
+
+	return 0;
+}
+
+int main()
+{
+	struct foo foo;
+	pthread_t a, b;
+
+	pthread_create(&a, NULL, th, &foo);	
+	sleep(1);		/* force ordering */
+	pthread_create(&b, NULL, th, &foo);
+
+	pthread_join(a, NULL);
+	pthread_join(b, NULL);
+
+	return 0;
+}
diff --git a/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64 b/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..b6dc2e9
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg05_race2.c:27)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg05_race2.c:29)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: th (hg05_race2.c:17)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86 b/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..285efeb
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg05_race2.c:27)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (hg05_race2.c:29)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: th (hg05_race2.c:17)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg05_race2.stdout.exp b/helgrind/tests/hg05_race2.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg05_race2.stdout.exp
diff --git a/helgrind/tests/hg05_race2.vgtest b/helgrind/tests/hg05_race2.vgtest
new file mode 100644
index 0000000..a93db5e
--- /dev/null
+++ b/helgrind/tests/hg05_race2.vgtest
@@ -0,0 +1 @@
+prog: hg05_race2
diff --git a/helgrind/tests/hg06_readshared.c b/helgrind/tests/hg06_readshared.c
new file mode 100644
index 0000000..3904b44
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.c
@@ -0,0 +1,33 @@
+/* All OK - test allowed read sharing */
+
+#include <pthread.h>
+#include <assert.h>
+
+static int shared;
+
+static void *t1(void *v)
+{
+	return (void *)(long)(shared + 44);
+}
+
+static void *t2(void *v)
+{
+	return (void *)(long)(shared + 55);
+}
+
+int main()
+{
+	pthread_t a, b;
+
+	shared = 22;
+
+	pthread_create(&a, NULL, t1, NULL);	
+	pthread_create(&b, NULL, t2, NULL);
+
+	pthread_join(a, NULL);
+	pthread_join(b, NULL);
+
+	assert(shared == 22);
+
+	return 0;
+}
diff --git a/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64 b/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/hg06_readshared.stdout.exp b/helgrind/tests/hg06_readshared.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.stdout.exp
diff --git a/helgrind/tests/hg06_readshared.vgtest b/helgrind/tests/hg06_readshared.vgtest
new file mode 100644
index 0000000..c5accee
--- /dev/null
+++ b/helgrind/tests/hg06_readshared.vgtest
@@ -0,0 +1 @@
+prog: hg06_readshared
diff --git a/helgrind/tests/tc01_simple_race.c b/helgrind/tests/tc01_simple_race.c
new file mode 100644
index 0000000..abf37b5
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.c
@@ -0,0 +1,36 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has a race.  Parent and child both modify x
+   with no locking. */
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+   /* Unprotected relative to parent */
+   x++;
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   /* Unprotected relative to child */
+   x++;
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   return 0;
+}
diff --git a/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64 b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..a5b31c3
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc01_simple_race.c:22)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc01_simple_race.c:28)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86 b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..ba37641
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc01_simple_race.c:22)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc01_simple_race.c:28)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc01_simple_race.stdout.exp b/helgrind/tests/tc01_simple_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.stdout.exp
diff --git a/helgrind/tests/tc01_simple_race.vgtest b/helgrind/tests/tc01_simple_race.vgtest
new file mode 100644
index 0000000..44f3045
--- /dev/null
+++ b/helgrind/tests/tc01_simple_race.vgtest
@@ -0,0 +1 @@
+prog: tc01_simple_race
diff --git a/helgrind/tests/tc02_simple_tls.c b/helgrind/tests/tc02_simple_tls.c
new file mode 100644
index 0000000..a23b14c
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.c
@@ -0,0 +1,39 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race: parent only modified x after child
+   has modified it and then joined with the parent.  Tests simple
+   thread lifetime segment handling. */
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+   /* Unprotected relative to parent, but in child's segment only */
+   x++;
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+
+   x++; /* happens in parent's segment */
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   /* Now back in parent's segment */
+   x++;
+
+   return 0;
+}
diff --git a/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64 b/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc02_simple_tls.stdout.exp b/helgrind/tests/tc02_simple_tls.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.stdout.exp
diff --git a/helgrind/tests/tc02_simple_tls.vgtest b/helgrind/tests/tc02_simple_tls.vgtest
new file mode 100644
index 0000000..57db35c
--- /dev/null
+++ b/helgrind/tests/tc02_simple_tls.vgtest
@@ -0,0 +1 @@
+prog: tc02_simple_tls
diff --git a/helgrind/tests/tc03_re_excl.c b/helgrind/tests/tc03_re_excl.c
new file mode 100644
index 0000000..4f3ce51
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.c
@@ -0,0 +1,44 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race: parent only modifies x after child
+   has modified it and then joined with the parent.  Tests simple
+   thread lifetime segment handling. */
+
+/* A simple function to "use" a value, so that gcc can't
+   possibly optimise it into nothing. */
+static void use ( int x ) {
+   __asm__ __volatile__( "nop" : : "r"(x) : "cc","memory" );
+}
+
+static void* worker_thread ( void* argV )
+{
+  int* arg = (int*)argV;
+  use(arg[5]); /* read access */
+  return NULL;
+}
+
+int main ( void )
+{
+   pthread_t thread_id;
+   volatile int* x = malloc(10 * sizeof(int));
+   x[5] = 1;
+   /* x[5] is Excl(parent) */
+
+   pthread_create(&thread_id, 0, worker_thread, (void*)x);
+
+   use(x[5]); /* read access */
+
+   /* Just before the threads join, x[5] is ShR (read by both parent
+      and child) */
+   pthread_join(thread_id, 0);
+   /* x[5] is Excl(parent), because only parent and child accessed it
+      and child has merged to parent.  So now it's ok for parent to
+      access it without locking. */
+
+   x[5] = 0; /* write access */
+
+   return x[5];
+}
diff --git a/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64 b/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc03_re_excl.stdout.exp b/helgrind/tests/tc03_re_excl.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.stdout.exp
diff --git a/helgrind/tests/tc03_re_excl.vgtest b/helgrind/tests/tc03_re_excl.vgtest
new file mode 100644
index 0000000..e12924a
--- /dev/null
+++ b/helgrind/tests/tc03_re_excl.vgtest
@@ -0,0 +1 @@
+prog: tc03_re_excl
diff --git a/helgrind/tests/tc04_free_lock.c b/helgrind/tests/tc04_free_lock.c
new file mode 100644
index 0000000..c1ffa25
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.c
@@ -0,0 +1,50 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Delete memory that has a held lock and see what happens. */
+
+typedef struct { int stuff[2000]; 
+                 pthread_mutex_t lock; int morestuff[2000]; } XX;
+
+void bar ( void );
+void foo ( void );
+
+int main ( void )
+{
+   XX* xx = malloc(sizeof(XX));
+   assert(xx);
+
+   pthread_mutex_init( &xx->lock, NULL );
+
+   pthread_mutex_lock( &xx->lock );
+
+   free(xx);
+
+   bar();
+   foo();
+   bar();
+
+   return 0;
+}
+
+/* Try the same, on the stack */
+void bar ( void )
+{
+  pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
+  //  pthread_mutex_init( &mx, NULL );
+  pthread_mutex_lock( &mx );
+  /* now just abandon mx */
+}
+
+/* and again ... */
+void foo ( void )
+{
+  pthread_mutex_t mx;
+  pthread_mutex_init( &mx, NULL );
+  pthread_mutex_lock( &mx );
+  /* now just abandon mx */
+}
+
diff --git a/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..b14e3b6
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,35 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: free (vg_replace_malloc.c:...)
+   by 0x........: main (tc04_free_lock.c:24)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: main (tc04_free_lock.c:20)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: bar (tc04_free_lock.c:40)
+   by 0x........: main (tc04_free_lock.c:26)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: bar (tc04_free_lock.c:38)
+   by 0x........: main (tc04_free_lock.c:26)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: foo (tc04_free_lock.c:49)
+   by 0x........: main (tc04_free_lock.c:27)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: foo (tc04_free_lock.c:46)
+   by 0x........: main (tc04_free_lock.c:27)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: bar (tc04_free_lock.c:40)
+   by 0x........: main (tc04_free_lock.c:28)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: bar (tc04_free_lock.c:38)
+   by 0x........: main (tc04_free_lock.c:28)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc04_free_lock.stdout.exp b/helgrind/tests/tc04_free_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.stdout.exp
diff --git a/helgrind/tests/tc04_free_lock.vgtest b/helgrind/tests/tc04_free_lock.vgtest
new file mode 100644
index 0000000..27d28bf
--- /dev/null
+++ b/helgrind/tests/tc04_free_lock.vgtest
@@ -0,0 +1 @@
+prog: tc04_free_lock
diff --git a/helgrind/tests/tc05_simple_race.c b/helgrind/tests/tc05_simple_race.c
new file mode 100644
index 0000000..287c12c
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.c
@@ -0,0 +1,44 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has a race.  Parent and child both modify y
+   with no locking.  This is the program shown in Fig 2 of the
+   original Eraser paper by Savage et al. */
+
+int y = 0, v = 0;
+pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
+
+void* child_fn ( void* arg )
+{
+   /* "Thread 2" in the paper */
+   pthread_mutex_lock( &mu );
+   v = v + 1;
+   pthread_mutex_unlock( &mu );
+   y = y + 1;
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   /* "Thread 1" in the paper */
+   y = y + 1;
+   pthread_mutex_lock( &mu );
+   v = v + 1;
+   pthread_mutex_unlock( &mu );
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   return 0;
+}
diff --git a/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64 b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8c15d1a
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc05_simple_race.c:27)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc05_simple_race.c:33)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86 b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..fb6dccf
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc05_simple_race.c:27)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc05_simple_race.c:33)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc05_simple_race.stdout.exp b/helgrind/tests/tc05_simple_race.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.stdout.exp
diff --git a/helgrind/tests/tc05_simple_race.vgtest b/helgrind/tests/tc05_simple_race.vgtest
new file mode 100644
index 0000000..27f3881
--- /dev/null
+++ b/helgrind/tests/tc05_simple_race.vgtest
@@ -0,0 +1 @@
+prog: tc05_simple_race
diff --git a/helgrind/tests/tc06_two_races.c b/helgrind/tests/tc06_two_races.c
new file mode 100644
index 0000000..65c83ef
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.c
@@ -0,0 +1,43 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, has two races.  A happens-before detector can only
+   ever detect one of them, though. */
+
+int unprot1 = 0, unprot2 = 0, prot = 0;
+pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
+
+void* child_fn ( void* arg )
+{
+   unprot1 ++;
+   pthread_mutex_lock( &mu );
+   prot ++;
+   pthread_mutex_unlock( &mu );
+   unprot2 ++;
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   unprot1 ++;
+   pthread_mutex_lock( &mu );
+   prot ++;
+   pthread_mutex_unlock( &mu );
+   unprot2 ++;
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   return 0;
+}
diff --git a/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64 b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..db74a70
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-amd64
@@ -0,0 +1,25 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc06_two_races.c:26)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc06_two_races.c:31)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc06_two_races.c:35)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86 b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..34874fc
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc06_two_races.c:26)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc06_two_races.c:31)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: main (tc06_two_races.c:35)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc06_two_races.stdout.exp b/helgrind/tests/tc06_two_races.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.stdout.exp
diff --git a/helgrind/tests/tc06_two_races.vgtest b/helgrind/tests/tc06_two_races.vgtest
new file mode 100644
index 0000000..f6f5247
--- /dev/null
+++ b/helgrind/tests/tc06_two_races.vgtest
@@ -0,0 +1 @@
+prog: tc06_two_races
diff --git a/helgrind/tests/tc07_hbl1.c b/helgrind/tests/tc07_hbl1.c
new file mode 100644
index 0000000..58e6564
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.c
@@ -0,0 +1,77 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple test program, no race.  Parent and child both modify x and
+   use the hardware bus lock. */
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+#  define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+#  define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+#  define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+#  define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+#  define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+#  define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+#  define INC(_lval) \
+      __asm__ __volatile__ ( \
+      "lock ; incl (%0)" : /*out*/ : /*in*/"r"(&(_lval)) : "memory", "cc" )
+#elif defined(PLAT_ppc32_linux) || defined(PLAT_ppc64_linux)
+#  define INC(_lval)                      \
+   __asm__ __volatile__(                  \
+      "1:\n"                              \
+      "        lwarx 15,0,%0\n"           \
+      "        addi 15,15,1\n"            \
+      "        stwcx. 15,0,%0\n"          \
+      "        bne- 1b"                   \
+      : /*out*/ : /*in*/ "b"(&(_lval))    \
+      : /*trash*/ "r15", "cr0", "memory"  \
+   )
+#else
+#  error "Fix Me for this platform"
+#endif
+
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+   INC(x);
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   INC(x);
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   printf("x = %d\n", x);
+   return 0;
+}
diff --git a/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64 b/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc07_hbl1.stdout.exp b/helgrind/tests/tc07_hbl1.stdout.exp
new file mode 100644
index 0000000..407de30
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.stdout.exp
@@ -0,0 +1 @@
+x = 2
diff --git a/helgrind/tests/tc07_hbl1.vgtest b/helgrind/tests/tc07_hbl1.vgtest
new file mode 100644
index 0000000..71c463f
--- /dev/null
+++ b/helgrind/tests/tc07_hbl1.vgtest
@@ -0,0 +1 @@
+prog: tc07_hbl1
diff --git a/helgrind/tests/tc08_hbl2.c b/helgrind/tests/tc08_hbl2.c
new file mode 100644
index 0000000..5362faa
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.c
@@ -0,0 +1,117 @@
+
+/* FIXME: this is basically a bad test as it is scheduling-
+   sensitive.  Sometimes the output is:
+
+   child: new value 6
+   child: new value 10
+   done, x = 10
+
+   and sometimes
+
+   child: new value 10
+   done, x = 10
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Simple test program, no race.  Parent writes atomically to a counter
+   whilst child reads it.  When counter reaches a prearranged value, 
+   child joins back to parent.  Parent (writer) uses hardware bus lock;
+   child is only reading and so does not need to use a bus lock. */
+
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+#  define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+#  define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+#  define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+#  define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+#  define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+#  define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+#  define INC(_lval) \
+      __asm__ __volatile__ ( \
+      "lock ; incl (%0)" : /*out*/ : /*in*/"r"(&(_lval)) : "memory", "cc" )
+#elif defined(PLAT_ppc32_linux) || defined(PLAT_ppc64_linux)
+#  define INC(_lval)                      \
+   __asm__ __volatile__(                  \
+      "1:\n"                              \
+      "        lwarx 15,0,%0\n"           \
+      "        addi 15,15,1\n"            \
+      "        stwcx. 15,0,%0\n"          \
+      "        bne- 1b"                   \
+      : /*out*/ : /*in*/ "b"(&(_lval))    \
+      : /*trash*/ "r15", "cr0", "memory"  \
+   )
+#else
+#  error "Fix Me for this platform"
+#endif
+
+
+
+#define LIMIT 10
+
+volatile int x = 0;
+
+void* child_fn ( void* arg )
+{
+   int q = 0;
+   int oldx = 0;
+   int ctr = 0;
+   while (1) {
+      q = (x >= LIMIT);
+      if (x != oldx) {
+         oldx = x;
+         printf("child: new value %d\n", oldx);
+         fflush(stdout);
+      }
+      if (q) break;
+      /* Make sure the parent doesn't starve.  Seems to be a problem
+	 on very slow machines. */
+      ctr++;
+      if (ctr == 2000000) sleep(1);
+   }
+   return NULL;
+}
+
+int main ( void )
+{
+   pthread_t child;
+   int i;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   for (i = 0; i < LIMIT; i++) {
+      INC(x);
+      if (i == 5) sleep(1); /* make sure child doesn't starve */
+   }
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   printf("done, x = %d\n", x);
+
+   return 0;
+}
diff --git a/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64 b/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc08_hbl2.stdout.exp b/helgrind/tests/tc08_hbl2.stdout.exp
new file mode 100644
index 0000000..ce39ad5
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.stdout.exp
@@ -0,0 +1,3 @@
+child: new value 6
+child: new value 10
+done, x = 10
diff --git a/helgrind/tests/tc08_hbl2.vgtest b/helgrind/tests/tc08_hbl2.vgtest
new file mode 100644
index 0000000..6d0a2cb
--- /dev/null
+++ b/helgrind/tests/tc08_hbl2.vgtest
@@ -0,0 +1 @@
+prog: tc08_hbl2
diff --git a/helgrind/tests/tc09_bad_unlock.c b/helgrind/tests/tc09_bad_unlock.c
new file mode 100644
index 0000000..bb44eb3
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.c
@@ -0,0 +1,52 @@
+
+/* Check that an error is reported for various kinds of bogus
+   pthread_mutex_unlock calls. */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void* child_fn ( void* arg )
+{
+   pthread_mutex_unlock( (pthread_mutex_t*)arg ); /* ERROR */
+   return NULL;
+}
+
+void nearly_main ( void )
+{
+   pthread_t child;
+   pthread_mutex_t mx1, mx2;
+   int bogus[100], i;
+   /* fill bogus with values which will cause glibc's pth_mx_unlock to fail */
+   for (i = 0; i < 100; i++) bogus[i] = 0xFFFFFFFF;
+   /* Unlocking a lock that is already unlocked */
+   pthread_mutex_init( &mx1, NULL );
+   pthread_mutex_lock( &mx1 );
+   pthread_mutex_unlock( &mx1 );
+
+   pthread_mutex_unlock( &mx1 ); /* ERROR */
+
+   /* Unlocking a lock that is held by a different thread */
+
+   pthread_mutex_init( &mx2, NULL );
+   pthread_mutex_lock( &mx2 );
+   // start child and get it to unlock this lock
+
+   pthread_create( &child, NULL, child_fn, (void*)&mx2 );
+      /* child runs and attempts to unlock our lock.  Error 
+         is reported in child_fn. */
+   pthread_join(child, NULL );
+
+   /* Unlocking a totally bogus lock. */
+   pthread_mutex_unlock( (pthread_mutex_t*) &bogus[50] ); /* ERROR */
+
+   /* Now we get a freeing-locked-lock error, since the stack
+      frame is removed whilst mx2 is still locked. */
+}
+
+int main ( void )
+{
+   nearly_main();
+   nearly_main();
+   return 0;
+}
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64
new file mode 100644
index 0000000..dc6bf41
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc23-amd64
@@ -0,0 +1,86 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 8 errors from 8 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..e851dc2
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-amd64
@@ -0,0 +1,98 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 10 errors from 10 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86 b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..84601c4
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stderr.exp-glibc25-x86
@@ -0,0 +1,96 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #2 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:49)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:49)
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:27)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:23)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:35)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #3 unlocked lock at 0x........ currently held by thread #1
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: child_fn (tc09_bad_unlock.c:11)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:41)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: nearly_main (tc09_bad_unlock.c:45)
+   by 0x........: main (tc09_bad_unlock.c:50)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc09_bad_unlock.c:31)
+   by 0x........: main (tc09_bad_unlock.c:50)
+
+ERROR SUMMARY: 10 errors from 10 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc09_bad_unlock.stdout.exp b/helgrind/tests/tc09_bad_unlock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.stdout.exp
diff --git a/helgrind/tests/tc09_bad_unlock.vgtest b/helgrind/tests/tc09_bad_unlock.vgtest
new file mode 100644
index 0000000..d09a702
--- /dev/null
+++ b/helgrind/tests/tc09_bad_unlock.vgtest
@@ -0,0 +1 @@
+prog: tc09_bad_unlock
diff --git a/helgrind/tests/tc10_rec_lock.c b/helgrind/tests/tc10_rec_lock.c
new file mode 100644
index 0000000..648305c
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.c
@@ -0,0 +1,49 @@
+
+/* Do simple things with a recursive mutex. */
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+   otherwise "know" about pthread_rwlock_anything or about
+   PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+
+void nearly_main ( void )
+{
+   pthread_mutex_t mx1;
+   pthread_mutexattr_t attr;
+   int r;
+
+   r = pthread_mutexattr_init( &attr );
+   assert(r==0);
+   r = pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
+   assert(r==0);
+   r = pthread_mutex_init( &mx1, &attr );
+   assert(r==0);
+
+   fprintf(stderr, "before lock #1\n");
+   r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+   fprintf(stderr, "before lock #2\n");
+   r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+   fprintf(stderr, "before lock #3\n");
+   r = pthread_mutex_lock( &mx1 ); assert(r == 0);
+
+   fprintf(stderr, "before unlock #1\n");
+   r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+   fprintf(stderr, "before unlock #2\n");
+   r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+   fprintf(stderr, "before unlock #3\n");
+   r = pthread_mutex_unlock( &mx1 ); assert(r == 0);
+
+   fprintf(stderr, "before unlock #4\n");
+   r = pthread_mutex_unlock( &mx1 ); /* FAILS: assert(r == 0); */
+}
+
+int main ( void )
+{
+   nearly_main();
+   return 0;
+}
diff --git a/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..a301ee7
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+before lock #1
+before lock #2
+before lock #3
+before unlock #1
+before unlock #2
+before unlock #3
+before unlock #4
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc10_rec_lock.c:42)
+   by 0x........: main (tc10_rec_lock.c:47)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc10_rec_lock.c:24)
+   by 0x........: main (tc10_rec_lock.c:47)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 1 (EPERM: Operation not permitted)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: nearly_main (tc10_rec_lock.c:42)
+   by 0x........: main (tc10_rec_lock.c:47)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc10_rec_lock.stdout.exp b/helgrind/tests/tc10_rec_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.stdout.exp
diff --git a/helgrind/tests/tc10_rec_lock.vgtest b/helgrind/tests/tc10_rec_lock.vgtest
new file mode 100644
index 0000000..bfd0f89
--- /dev/null
+++ b/helgrind/tests/tc10_rec_lock.vgtest
@@ -0,0 +1 @@
+prog: tc10_rec_lock
diff --git a/helgrind/tests/tc11_XCHG.c b/helgrind/tests/tc11_XCHG.c
new file mode 100644
index 0000000..5b46c7e
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.c
@@ -0,0 +1,92 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Simple test program, no race.  Parent and child both modify x and
+   use the hardware bus lock (implicitly, since XCHG r,m on x86/amd64
+   does not require an explicit LOCK prefix.). */
+
+#undef PLAT_x86_linux
+#undef PLAT_amd64_linux
+#undef PLAT_ppc32_linux
+#undef PLAT_ppc64_linux
+#undef PLAT_ppc32_aix5
+#undef PLAT_ppc64_aix5
+
+#if !defined(_AIX) && defined(__i386__)
+#  define PLAT_x86_linux 1
+#elif !defined(_AIX) && defined(__x86_64__)
+#  define PLAT_amd64_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && !defined(__powerpc64__)
+#  define PLAT_ppc32_linux 1
+#elif !defined(_AIX) && defined(__powerpc__) && defined(__powerpc64__)
+#  define PLAT_ppc64_linux 1
+#elif defined(_AIX) && defined(__64BIT__)
+#  define PLAT_ppc64_aix5 1
+#elif defined(_AIX) && !defined(__64BIT__)
+#  define PLAT_ppc32_aix5 1
+#endif
+
+
+#if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux)
+#  define XCHG_M_R(_addr,_lval) \
+     __asm__ __volatile__( \
+        "xchgl %0, %1" \
+        : /*out*/ "+r"(_lval) \
+        : /*in*/  "m"(_addr) \
+        : "memory", "cc" \
+     )
+#  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
+     __asm__ __volatile__( \
+        "lock xchgl %0, %1" \
+        : /*out*/ "+r"(_lval) \
+        : /*in*/  "m"(_addr) \
+        : "memory", "cc" \
+     )
+#else
+#  define XCHG_M_R(_addr,_lval) \
+      do { int tmp = *(int*)(& _addr); \
+           *(int*)(& _addr) = (_lval); \
+           _lval = tmp; \
+      } while (0)
+#  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
+      XCHG_M_R(_addr,_lval)
+#endif
+
+int x = 0;
+
+void* child_fn ( void* arg )
+{
+   int v = 12345;
+   XCHG_M_R_with_redundant_LOCK(x, v);
+   assert(v == 0 || v == 6789);
+   return NULL;
+}
+
+int main ( void )
+{
+   int v = 6789;
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   XCHG_M_R(x, v);
+   assert(v == 0 || v == 12345);
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   if (v == 0 || v == 12345)
+      printf("success\n");
+   else
+      printf("failure\n");
+
+   return v;
+}
diff --git a/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64 b/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..d18786f
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.stderr.exp-glibc25-amd64
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc11_XCHG.stdout.exp b/helgrind/tests/tc11_XCHG.stdout.exp
new file mode 100644
index 0000000..2e9ba47
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.stdout.exp
@@ -0,0 +1 @@
+success
diff --git a/helgrind/tests/tc11_XCHG.vgtest b/helgrind/tests/tc11_XCHG.vgtest
new file mode 100644
index 0000000..342199b
--- /dev/null
+++ b/helgrind/tests/tc11_XCHG.vgtest
@@ -0,0 +1 @@
+prog: tc11_XCHG
diff --git a/helgrind/tests/tc12_rwl_trivial.c b/helgrind/tests/tc12_rwl_trivial.c
new file mode 100644
index 0000000..9dc8e84
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.c
@@ -0,0 +1,34 @@
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+   otherwise "know" about pthread_rwlock_anything or about
+   PTHREAD_MUTEX_RECURSIVE (amongst things). */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <pthread.h>
+#include <assert.h>
+
+/* Do trivial stuff with a reader-writer lock. */
+
+int main ( void )
+{
+  int r;
+  pthread_rwlock_t rwl;
+
+  r = pthread_rwlock_init( &rwl, NULL );  assert(r == 0);
+
+  r = pthread_rwlock_wrlock( &rwl );      assert(r == 0);
+  r = pthread_rwlock_unlock( &rwl );      assert(r == 0);
+
+  r = pthread_rwlock_rdlock( &rwl );      assert(r == 0);
+  r = pthread_rwlock_rdlock( &rwl );      assert(r == 0);
+  r = pthread_rwlock_unlock( &rwl );      assert(r == 0);
+  r = pthread_rwlock_unlock( &rwl );      assert(r == 0);
+
+  /* this should fail - lock is unowned now */
+  r = pthread_rwlock_unlock( &rwl );      assert(r == 0);
+
+  r = pthread_rwlock_destroy( &rwl );     assert(r == 0);
+
+  return 0;
+}
diff --git a/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64 b/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..cbc403e
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.stderr.exp-glibc25-amd64
@@ -0,0 +1,11 @@
+
+Thread #1 is the program's root thread
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc12_rwl_trivial.c:29)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc12_rwl_trivial.c:18)
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc12_rwl_trivial.stdout.exp b/helgrind/tests/tc12_rwl_trivial.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.stdout.exp
diff --git a/helgrind/tests/tc12_rwl_trivial.vgtest b/helgrind/tests/tc12_rwl_trivial.vgtest
new file mode 100644
index 0000000..fdcd644
--- /dev/null
+++ b/helgrind/tests/tc12_rwl_trivial.vgtest
@@ -0,0 +1 @@
+prog: tc12_rwl_trivial
diff --git a/helgrind/tests/tc13_laog1.c b/helgrind/tests/tc13_laog1.c
new file mode 100644
index 0000000..e42ca98
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.c
@@ -0,0 +1,33 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* The simplest possible test that triggers a lock order acquisition
+   error. */
+
+int main ( void )
+{
+   int r;
+   pthread_mutex_t mx1, mx2;
+   r = pthread_mutex_init( &mx1, NULL ); assert(r==0);
+   r = pthread_mutex_init( &mx2, NULL ); assert(r==0);
+
+   r = pthread_mutex_lock( &mx1 ); assert(r==0);
+   r = pthread_mutex_lock( &mx2 ); assert(r==0);
+
+   r = pthread_mutex_unlock( &mx1 ); assert(r==0);
+   r = pthread_mutex_unlock( &mx2 ); assert(r==0);
+
+   r = pthread_mutex_lock( &mx2 ); assert(r==0); /* error */
+   r = pthread_mutex_lock( &mx1 ); assert(r==0);
+
+   r = pthread_mutex_unlock( &mx1 ); assert(r==0);
+   r = pthread_mutex_unlock( &mx2 ); assert(r==0);
+
+   r = pthread_mutex_destroy( &mx1 );
+   r = pthread_mutex_destroy( &mx2 );
+
+   return 0;
+}
diff --git a/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64 b/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..74aa263
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.stderr.exp-glibc25-amd64
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc13_laog1.c:24)
+  Required order was established by acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc13_laog1.c:17)
+  followed by a later acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc13_laog1.c:18)
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc13_laog1.stdout.exp b/helgrind/tests/tc13_laog1.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.stdout.exp
diff --git a/helgrind/tests/tc13_laog1.vgtest b/helgrind/tests/tc13_laog1.vgtest
new file mode 100644
index 0000000..9fa71cd
--- /dev/null
+++ b/helgrind/tests/tc13_laog1.vgtest
@@ -0,0 +1 @@
+prog: tc13_laog1
diff --git a/helgrind/tests/tc14_laog_dinphils.c b/helgrind/tests/tc14_laog_dinphils.c
new file mode 100644
index 0000000..c5af8c1
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.c
@@ -0,0 +1,42 @@
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Naive dining philosophers with inconsistent lock acquisition
+   ordering. */
+
+static pthread_t phil[5];
+static pthread_mutex_t chop[5];
+
+void* dine ( void* arg )
+{
+   int i;
+   long left = (long)arg;
+   long right = (left + 1) % 5;
+   for (i = 0; i < 1000/*arbitrary*/; i++) {
+      pthread_mutex_lock(&chop[left]);
+      pthread_mutex_lock(&chop[right]);
+      /* eating */
+      pthread_mutex_unlock(&chop[left]);
+      pthread_mutex_unlock(&chop[right]);
+   }
+   return NULL;
+}
+
+int main ( void )
+{
+   long i;
+   for (i = 0; i < 5; i++)
+      pthread_mutex_init( &chop[i], NULL);
+
+   for (i = 0; i < 5; i++)
+      pthread_create(&phil[i], NULL, dine, (void*)i );
+
+   sleep(1);
+
+   for (i = 0; i < 5; i++)
+      pthread_join(phil[i], NULL);
+
+   return 0;
+}
diff --git a/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64 b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..5cedeb8
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-amd64
@@ -0,0 +1,16 @@
+
+Thread #6 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc14_laog_dinphils.c:34)
+
+Thread #6: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: dine (tc14_laog_dinphils.c:19)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+
+ERROR SUMMARY: 1000 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86 b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..c4db6cf
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stderr.exp-glibc25-x86
@@ -0,0 +1,15 @@
+
+Thread #6 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc14_laog_dinphils.c:34)
+
+Thread #6: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: dine (tc14_laog_dinphils.c:19)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+
+ERROR SUMMARY: 1000 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc14_laog_dinphils.stdout.exp b/helgrind/tests/tc14_laog_dinphils.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.stdout.exp
diff --git a/helgrind/tests/tc14_laog_dinphils.vgtest b/helgrind/tests/tc14_laog_dinphils.vgtest
new file mode 100644
index 0000000..5871b73
--- /dev/null
+++ b/helgrind/tests/tc14_laog_dinphils.vgtest
@@ -0,0 +1 @@
+prog: tc14_laog_dinphils
diff --git a/helgrind/tests/tc15_laog_lockdel.c b/helgrind/tests/tc15_laog_lockdel.c
new file mode 100644
index 0000000..ff01605
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.c
@@ -0,0 +1,68 @@
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Test that locks, having entered the lock acquisition tracking
+   machinery, are forgotten by it when the memory they reside in
+   becomes inaccessible. */
+
+int main ( void )
+{
+   int r;
+   pthread_mutex_t *mx1, *mx2;
+
+   mx1 = malloc(sizeof(pthread_mutex_t));
+   mx2 = malloc(sizeof(pthread_mutex_t));
+
+   assert(mx1);
+   assert(mx2);
+
+   r = pthread_mutex_init( mx1, NULL ); assert(r==0);
+   r = pthread_mutex_init( mx2, NULL ); assert(r==0);
+
+   /* Establish order 1 -> 2 */
+   fprintf(stderr, "Establish order 1 -> 2\n");
+   r = pthread_mutex_lock( mx1 ); assert(r==0);
+   r = pthread_mutex_lock( mx2 ); assert(r==0);
+
+   r = pthread_mutex_unlock( mx1 ); assert(r==0);
+   r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+   /* Try order 2 -> 1.  This gives an error. */
+   fprintf(stderr, "Try order 2 -> 1.  This gives an error.\n");
+   r = pthread_mutex_lock( mx2 ); assert(r==0); /* error */
+   r = pthread_mutex_lock( mx1 ); assert(r==0);
+
+   r = pthread_mutex_unlock( mx1 ); assert(r==0);
+   r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+   /* Free 2 and re-allocate it.  This gives it a new identity, 
+      so a second locking sequence 2 -> 1 should now be OK. */
+   fprintf(stderr, 
+           "Free 2 and re-allocate it.  This gives it a new identity,\n");
+   fprintf(stderr, "so a second locking sequence 2 -> 1 should now be OK.\n");
+   pthread_mutex_destroy( mx2 );
+   free(mx2);
+   mx2 = malloc(sizeof(pthread_mutex_t));
+   assert(mx2);
+   r = pthread_mutex_init( mx2, NULL ); assert(r==0);
+
+   r = pthread_mutex_lock( mx2 ); assert(r==0); /* error */
+   r = pthread_mutex_lock( mx1 ); assert(r==0);
+
+   r = pthread_mutex_unlock( mx1 ); assert(r==0);
+   r = pthread_mutex_unlock( mx2 ); assert(r==0);
+
+   /* done */
+
+   fprintf(stderr, "done\n");
+   r = pthread_mutex_destroy( mx1 );
+   r = pthread_mutex_destroy( mx2 );
+
+   free( mx1 );
+   free( mx2 );
+
+   return 0;
+}
diff --git a/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64 b/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..4bab304
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.stderr.exp-glibc25-amd64
@@ -0,0 +1,19 @@
+
+Establish order 1 -> 2
+Try order 2 -> 1.  This gives an error.
+Thread #1 is the program's root thread
+
+Thread #1: lock order "0x........ before 0x........" violated
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc15_laog_lockdel.c:36)
+  Required order was established by acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc15_laog_lockdel.c:27)
+  followed by a later acquisition of lock at 0x........
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc15_laog_lockdel.c:28)
+Free 2 and re-allocate it.  This gives it a new identity,
+so a second locking sequence 2 -> 1 should now be OK.
+done
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc15_laog_lockdel.stdout.exp b/helgrind/tests/tc15_laog_lockdel.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.stdout.exp
diff --git a/helgrind/tests/tc15_laog_lockdel.vgtest b/helgrind/tests/tc15_laog_lockdel.vgtest
new file mode 100644
index 0000000..bd7a2ec
--- /dev/null
+++ b/helgrind/tests/tc15_laog_lockdel.vgtest
@@ -0,0 +1 @@
+prog: tc15_laog_lockdel
diff --git a/helgrind/tests/tc16_byterace.c b/helgrind/tests/tc16_byterace.c
new file mode 100644
index 0000000..1916c37
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.c
@@ -0,0 +1,42 @@
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Simple demonstration of lockset tracking at byte granularity. */
+
+char bytes[10];
+
+void* child_fn ( void* arg )
+{
+   int i;
+   for (i = 0; i < 5; i++)
+      bytes[2*i + 0] ++;
+   return NULL;
+}
+
+int main ( void )
+{
+   int i;
+   pthread_t child;
+
+   if (pthread_create(&child, NULL, child_fn, NULL)) {
+      perror("pthread_create");
+      exit(1);
+   }
+
+   /* Unprotected relative to child, but harmless, since different
+      bytes accessed */
+   for (i = 0; i < 5; i++)
+      bytes[2*i + 1] ++;
+
+   /* Unprotected relative to child, but harmful; same bytes */
+   for (i = 0; i < 3; i++)
+      bytes[3*i + 1] ++;
+
+   if (pthread_join(child, NULL)) {
+      perror("pthread join");
+      exit(1);
+   }
+
+   return 0;
+}
diff --git a/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64 b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..e4286bc
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-amd64
@@ -0,0 +1,18 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc16_byterace.c:22)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: main (tc16_byterace.c:34)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86 b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..d7ffb0a
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stderr.exp-glibc25-x86
@@ -0,0 +1,17 @@
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc16_byterace.c:22)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: main (tc16_byterace.c:34)
+  Old state: shared-readonly by threads #1, #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc16_byterace.stdout.exp b/helgrind/tests/tc16_byterace.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.stdout.exp
diff --git a/helgrind/tests/tc16_byterace.vgtest b/helgrind/tests/tc16_byterace.vgtest
new file mode 100644
index 0000000..a8bf0f1
--- /dev/null
+++ b/helgrind/tests/tc16_byterace.vgtest
@@ -0,0 +1 @@
+prog: tc16_byterace
diff --git a/helgrind/tests/tc17_sembar.c b/helgrind/tests/tc17_sembar.c
new file mode 100644
index 0000000..01af962
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.c
@@ -0,0 +1,212 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+/* This is really a test of semaphore handling
+   (sem_{init,destroy,post,wait}).  Using semaphores a barrier
+   function is created.  Thrcheck does understand the barrier
+   semantics implied by the barrier, as pieced together from
+   happens-before relationships obtained from the component
+   semaphores.  However, it does falsely report one race.  Ah well. */
+
+/* This code is derived from
+   gcc-4.3-20071012/libgomp/config/posix/bar.c, which is
+
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by Richard Henderson <rth@redhat.com>.
+
+   and available under version 2.1 or later of the GNU Lesser General
+   Public License.
+
+   Relative to the libgomp sources, the gomp_barrier_t type here has
+   an extra semaphore field, xxx.  This is not functionally useful,
+   but it is used to create enough extra inter-thread dependencies
+   that the barrier-like behaviour of gomp_barrier_t is evident to
+   Thrcheck.  There is no other purpose for the .xxx field. */
+
+typedef struct
+{
+  pthread_mutex_t mutex1;
+  pthread_mutex_t mutex2;
+  sem_t sem1;
+  sem_t sem2;
+  unsigned total;
+  unsigned arrived;
+  sem_t xxx;
+} gomp_barrier_t;
+
+typedef long bool;
+
+void
+gomp_barrier_init (gomp_barrier_t *bar, unsigned count)
+{
+  pthread_mutex_init (&bar->mutex1, NULL);
+  pthread_mutex_init (&bar->mutex2, NULL);
+  sem_init (&bar->sem1, 0, 0);
+  sem_init (&bar->sem2, 0, 0);
+  sem_init (&bar->xxx,  0, 0);
+  bar->total = count;
+  bar->arrived = 0;
+}
+
+void
+gomp_barrier_destroy (gomp_barrier_t *bar)
+{
+  /* Before destroying, make sure all threads have left the barrier.  */
+  pthread_mutex_lock (&bar->mutex1);
+  pthread_mutex_unlock (&bar->mutex1);
+
+  pthread_mutex_destroy (&bar->mutex1);
+  pthread_mutex_destroy (&bar->mutex2);
+  sem_destroy (&bar->sem1);
+  sem_destroy (&bar->sem2);
+  sem_destroy(&bar->xxx);
+}
+
+void
+gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)
+{
+  pthread_mutex_lock (&bar->mutex1);
+  bar->total = count;
+  pthread_mutex_unlock (&bar->mutex1);
+}
+
+void
+gomp_barrier_wait (gomp_barrier_t *bar)
+{
+  unsigned int n;
+  pthread_mutex_lock (&bar->mutex1);
+
+  ++bar->arrived;
+
+  if (bar->arrived == bar->total)
+    {
+      bar->arrived--;
+      n = bar->arrived;
+      if (n > 0) 
+        {
+          { unsigned int i;
+            for (i = 0; i < n; i++)
+              sem_wait(&bar->xxx); // acquire an obvious dependency from
+              // all other threads arriving at the barrier
+          }
+          // 1 up n times, 2 down once
+          // now let all the other threads past the barrier, giving them
+          // an obvious dependency with this thread.
+          do
+            sem_post (&bar->sem1); // 1 up
+          while (--n != 0);
+          // and wait till the last thread has left
+          sem_wait (&bar->sem2); // 2 down
+        }
+      pthread_mutex_unlock (&bar->mutex1);
+      /* «Résultats professionnels!»  First we made this thread have an
+         obvious (Thrcheck-visible) dependency on all other threads
+         calling gomp_barrier_wait.  Then, we released them all again,
+         so they all have a (visible) dependency on this thread.
+         Transitively, the result is that all threads leaving the
+         barrier have a a Thrcheck-visible dependency on all threads
+         arriving at the barrier.  As required. */
+    }
+  else
+    {
+      pthread_mutex_unlock (&bar->mutex1);
+      sem_post(&bar->xxx);
+      // first N-1 threads wind up waiting here
+      sem_wait (&bar->sem1); // 1 down 
+
+      pthread_mutex_lock (&bar->mutex2);
+      n = --bar->arrived; /* XXX see below */
+      pthread_mutex_unlock (&bar->mutex2);
+
+      if (n == 0)
+        sem_post (&bar->sem2); // 2 up
+    }
+}
+
+
+/* re XXX, thrcheck reports a race at this point.  It doesn't
+   understand that bar->arrived is protected by mutex1 whilst threads
+   are arriving at the barrier and by mutex2 whilst they are leaving,
+   but not consistently by either of them.  Oh well. */
+
+static gomp_barrier_t bar;
+
+/* What's with the volatile here?  It stops gcc compiling
+   "if (myid == 4) { unprotected = 99; }" and
+   "if (myid == 3) { unprotected = 88; }" into a conditional
+   load followed by a store.  The cmov/store sequence reads and
+   writes memory in all threads and cause Thrcheck to (correctly)
+   report a race, the underlying cause of which is that gcc is
+   generating non threadsafe code.  
+
+   (The lack of) thread safe code generation by gcc is currently a
+   hot topic.  See the following discussions:
+     http://gcc.gnu.org/ml/gcc/2007-10/msg00266.html
+     http://lkml.org/lkml/2007/10/24/673
+   and this is interesting background:
+     www.hpl.hp.com/techreports/2004/HPL-2004-209.pdf
+*/
+volatile static long unprotected = 0;
+
+void* child ( void* argV )
+{
+   long myid = (long)argV;
+   //   assert(myid >= 2 && myid <= 5);
+
+   /* First, we all wait to get to this point. */
+   gomp_barrier_wait( &bar );
+
+   /* Now, thread #4 writes to 'unprotected' and so becomes its
+      owner. */
+   if (myid == 4) {
+      unprotected = 99;
+   }
+
+   /* Now we all wait again. */
+   gomp_barrier_wait( &bar );
+
+   /* This time, thread #3 writes to 'unprotected'.  If all goes well,
+      Thrcheck sees the dependency through the barrier back to thread
+      #4 before it, and so thread #3 becomes the exclusive owner of
+      'unprotected'. */
+   if (myid == 3) {
+      unprotected = 88;
+   }
+
+   /* And just to be on the safe side ... */
+   gomp_barrier_wait( &bar );
+   return NULL;
+}
+
+
+int main (int argc, char *argv[])
+{
+   long i; int res;
+   pthread_t thr[4];
+   fprintf(stderr, "starting\n");
+
+   gomp_barrier_init( &bar, 4 );
+
+   for (i = 0; i < 4; i++) {
+      res = pthread_create( &thr[i], NULL, child, (void*)(i+2) );
+      assert(!res);
+   }
+
+   for (i = 0; i < 4; i++) {
+      res = pthread_join( thr[i], NULL );
+      assert(!res);
+   }
+
+   gomp_barrier_destroy( &bar );
+
+   /* And finally here, the root thread can get exclusive ownership
+      back from thread #4, because #4 has exited by this point and so
+      we have a dependency edge back to the write it did. */
+   fprintf(stderr, "done, result is %ld, should be 88\n", unprotected);
+
+   return 0;
+}
diff --git a/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64 b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..3600221
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-amd64
@@ -0,0 +1,46 @@
+
+starting
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #4 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #5 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Possible data race during read of size 4 at 0x........
+   at 0x........: gomp_barrier_wait (tc17_sembar.c:122)
+   by 0x........: child (tc17_sembar.c:161)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-modified by threads #2, #3, #4, #5
+  New state: shared-modified by threads #2, #3, #4, #5
+  Reason:    this thread, #2, holds no consistent locks
+  Last consistently used lock for 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: gomp_barrier_init (tc17_sembar.c:46)
+   by 0x........: main (tc17_sembar.c:192)
+done, result is 88, should be 88
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86 b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..7675dbb
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stderr.exp-glibc25-x86
@@ -0,0 +1,42 @@
+
+starting
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #4 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Thread #5 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc17_sembar.c:195)
+
+Possible data race during read of size 4 at 0x........
+   at 0x........: gomp_barrier_wait (tc17_sembar.c:122)
+   by 0x........: child (tc17_sembar.c:161)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-modified by threads #2, #3, #4, #5
+  New state: shared-modified by threads #2, #3, #4, #5
+  Reason:    this thread, #2, holds no consistent locks
+  Last consistently used lock for 0x........ was first observed
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: gomp_barrier_init (tc17_sembar.c:46)
+   by 0x........: main (tc17_sembar.c:192)
+done, result is 88, should be 88
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc17_sembar.stdout.exp b/helgrind/tests/tc17_sembar.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.stdout.exp
diff --git a/helgrind/tests/tc17_sembar.vgtest b/helgrind/tests/tc17_sembar.vgtest
new file mode 100644
index 0000000..643ed8a
--- /dev/null
+++ b/helgrind/tests/tc17_sembar.vgtest
@@ -0,0 +1 @@
+prog: tc17_sembar
diff --git a/helgrind/tests/tc18_semabuse.c b/helgrind/tests/tc18_semabuse.c
new file mode 100644
index 0000000..6e26ce4
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.c
@@ -0,0 +1,42 @@
+
+/* Do stupid things with semaphores, and check that Thrcheck doesn't
+   fall over and does report errors appropriately.  If nothing else
+   this just checks that the relevant functions are getting
+   intercepted. */
+
+/* This is pretty lame, because making the sem_ functions fail is
+   difficult.  Not sure it's really worth having. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <string.h>
+
+int main ( void )
+{
+  int r;
+  sem_t s1;
+
+  /* Do sem_init with huge initial count */
+  r= sem_init(&s1, 0, ~0);
+
+  /* initialise properly */
+  r= sem_init(&s1, 0, 0);
+
+  /* in glibc, sem_destroy is a no-op; making it fail is
+     impossible. */
+
+  /* Do 'wait' on a bogus semaphore.  This should fail, but on glibc
+     it succeeds. */
+  memset(&s1, 0x55, sizeof(s1));
+  r= sem_wait(&s1); /* assert(r != 0); */
+
+  /* this really ought to fail, but it doesn't. */
+  r= sem_post(&s1); assert(!r);
+
+  sem_destroy(&s1);
+
+  return 0;
+}
diff --git a/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64 b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..f0519c0
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-amd64
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1's call to sem_init failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: sem_init@* (hg_intercepts.c:...)
+   by 0x........: main (tc18_semabuse.c:23)
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+   at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+   by 0x........: sem_wait (hg_intercepts.c:...)
+   by 0x........: main (tc18_semabuse.c:34)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86 b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..82f30d4
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stderr.exp-glibc25-x86
@@ -0,0 +1,14 @@
+
+Thread #1 is the program's root thread
+
+Thread #1's call to sem_init failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: sem_init@* (hg_intercepts.c:...)
+   by 0x........: main (tc18_semabuse.c:23)
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+   at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+   by 0x........: sem_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc18_semabuse.c:34)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc18_semabuse.stdout.exp b/helgrind/tests/tc18_semabuse.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.stdout.exp
diff --git a/helgrind/tests/tc18_semabuse.vgtest b/helgrind/tests/tc18_semabuse.vgtest
new file mode 100644
index 0000000..fe4d22b
--- /dev/null
+++ b/helgrind/tests/tc18_semabuse.vgtest
@@ -0,0 +1 @@
+prog: tc18_semabuse
diff --git a/helgrind/tests/tc19_shadowmem.c b/helgrind/tests/tc19_shadowmem.c
new file mode 100644
index 0000000..d652fa9
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.c
@@ -0,0 +1,2291 @@
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "helgrind/helgrind.h"
+
+typedef
+   struct {
+      void* (*child)(void*);
+      char* arr;
+      int firstoff;
+      int lastoff;
+      int skipoff;
+   }
+   Info;
+
+pthread_mutex_t mx;
+
+void* child8 ( void* infoV )
+{
+   int r, i, firstoff, lastoff, skipoff;
+   char* arr;
+   Info* info = (Info*)infoV;
+   firstoff = info->firstoff;
+   lastoff  = info->lastoff;
+   skipoff  = info->skipoff;
+   arr      = info->arr;
+   assert( sizeof(char) == 1 );
+   assert( info->child == &child8 );
+   for (i = firstoff; i <= lastoff; i += 1) {
+      char* ptr = (char*)&arr[i];
+      if (i == skipoff) {
+        *ptr = 0;
+      } else {
+        r= pthread_mutex_lock( &mx ); assert(!r);
+        *ptr = 0;
+        r= pthread_mutex_unlock( &mx ); assert(!r);
+      }
+   }
+   return NULL;
+}
+
+void* child16 ( void* infoV )
+{
+   int r, i, firstoff, lastoff, skipoff;
+   char* arr;
+   Info* info = (Info*)infoV;
+   firstoff = info->firstoff;
+   lastoff  = info->lastoff;
+   skipoff  = info->skipoff;
+   arr      = info->arr;
+   assert( sizeof(short) == 2 );
+   assert( info->child == &child16 );
+   for (i = firstoff; i <= lastoff; i += 2) {
+      short* ptr = (short*)&arr[i];
+      if (i == skipoff) {
+        *ptr = 0;
+      } else {
+        r= pthread_mutex_lock( &mx ); assert(!r);
+        *ptr = 0;
+        r= pthread_mutex_unlock( &mx ); assert(!r);
+      }
+   }
+   return NULL;
+}
+
+void* child32 ( void* infoV )
+{
+   int r, i, firstoff, lastoff, skipoff;
+   char* arr;
+   Info* info = (Info*)infoV;
+   firstoff = info->firstoff;
+   lastoff  = info->lastoff;
+   skipoff  = info->skipoff;
+   arr      = info->arr;
+   assert( sizeof(int) == 4 );
+   assert( info->child == &child32 );
+   for (i = firstoff; i <= lastoff; i += 4) {
+      int* ptr = (int*)&arr[i];
+      if (i == skipoff) {
+        *ptr = 0;
+      } else {
+        r= pthread_mutex_lock( &mx ); assert(!r);
+        *ptr = 0;
+        r= pthread_mutex_unlock( &mx ); assert(!r);
+      }
+   }
+   return NULL;
+}
+
+void* child64 ( void* infoV )
+{
+   int r, i, firstoff, lastoff, skipoff;
+   char* arr;
+   Info* info = (Info*)infoV;
+   firstoff = info->firstoff;
+   lastoff  = info->lastoff;
+   skipoff  = info->skipoff;
+   arr      = info->arr;
+   assert( sizeof(double) == 8 );
+   assert( info->child == &child64 );
+   for (i = firstoff; i <= lastoff; i += 8) {
+      double* ptr = (double*)&arr[i];
+      if (i == skipoff) {
+        *ptr = 0;
+      } else {
+        r= pthread_mutex_lock( &mx ); assert(!r);
+        *ptr = 0;
+        r= pthread_mutex_unlock( &mx ); assert(!r);
+      }
+   }
+   return NULL;
+}
+
+
+void* steer ( void* infoV );
+
+#define MAXXX 100   /* re 100: should cover at least 2 cycles 
+of length 1 << N_LINE_BITS */
+/* This is all a bit subtle.  First, after every inner loop over the
+   data, we have to VALGRIND_TC_CLEAN_MEMORY it to get it back to a
+   decent starting state.  Because info.arr is 8-aligned (is asserted
+   for), the address range painter will paint at top level granularity
+   (8-byte), which means we are guaranteed to see any errors from the
+   next iteration at the maximum granularity that their alignment
+   allows.
+
+   Also, the pthread_joins cause the shadow mem cache to be flushed
+   each iteration.  Given that all trees are pulled up to 64-bit by
+   the abovementioned VALGRIND_TC_CLEAN_MEMORY, I think this
+   irrelevant.
+*/
+
+int main ( void )
+{
+  pthread_t t1, t2;
+  Info info;
+  int off;
+
+  pthread_mutex_init( &mx, NULL );
+
+  info.arr = malloc(MAXXX);
+  assert(info.arr);
+
+  /* ensure array is 8-aligned.  this is important, as per comment
+  above. */
+  assert(0 == (7 & (unsigned long)info.arr));
+
+#if 1
+  /* Test 8 bit granularity */
+
+  fprintf(stderr, "\n");
+  fprintf(stderr,
+          "===========================================================\n");
+  fprintf(stderr,
+          "=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===\n");
+  fprintf(stderr,
+          "===========================================================\n");
+  fprintf(stderr, "\n");
+  for (off = 0; off < MAXXX-1; off++) {
+
+     info.firstoff = off & 0;
+     info.lastoff  = MAXXX - 1;
+     info.skipoff  = off;
+     info.child    = child8;
+
+     fprintf(stderr, "---------- char gran, %d .. %d, skip %d ----------\n",
+             info.firstoff, info.lastoff, info.skipoff );
+
+     pthread_create( &t1, NULL, steer, (void*)&info );
+     pthread_create( &t2, NULL, steer, (void*)&info );
+
+     pthread_join( t1, NULL );
+     pthread_join( t2, NULL );
+
+     VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+  }
+#endif
+#if 1
+  /* Test 16 bit granularity */
+
+  fprintf(stderr, "\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr,
+          "=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr, "\n");
+  for (off = 0; off < MAXXX-2; off++) {
+
+     info.firstoff = off & 1;
+     info.lastoff  = MAXXX - 2;
+     info.skipoff  = off;
+     info.child    = child16;
+
+     fprintf(stderr, "---------- short gran, %d .. %d, skip %d ----------\n",
+             info.firstoff, info.lastoff, info.skipoff );
+
+     pthread_create( &t1, NULL, steer, (void*)&info );
+     pthread_create( &t2, NULL, steer, (void*)&info );
+
+     pthread_join( t1, NULL );
+     pthread_join( t2, NULL );
+
+     VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+  }
+#endif
+#if 1
+  /* Test 32 bit granularity */
+
+  fprintf(stderr, "\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr,
+          "=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr, "\n");
+  for (off = 0; off < MAXXX-4; off++) {
+
+     info.firstoff = off & 3;
+     info.lastoff  = MAXXX - 4;
+     info.skipoff  = off;
+     info.child    = child32;
+
+     fprintf(stderr, "---------- int gran, %d .. %d, skip %d ----------\n",
+             info.firstoff, info.lastoff, info.skipoff );
+
+     pthread_create( &t1, NULL, steer, (void*)&info );
+     pthread_create( &t2, NULL, steer, (void*)&info );
+
+     pthread_join( t1, NULL );
+     pthread_join( t2, NULL );
+
+     VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+  }
+#endif
+#if 1
+  /* Test 64 bit granularity */
+
+  fprintf(stderr, "\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr,
+          "=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===\n");
+  fprintf(stderr,
+          "==========================================================\n");
+  fprintf(stderr, "\n");
+  for (off = 0; off < MAXXX-8; off++) {
+
+     info.firstoff = off & 7;
+     info.lastoff  = MAXXX - 8;
+     info.skipoff  = off;
+     info.child    = child64;
+
+     fprintf(stderr, "---------- double gran, %d .. %d, skip %d ----------\n",
+             info.firstoff, info.lastoff, info.skipoff );
+
+     pthread_create( &t1, NULL, steer, (void*)&info );
+     pthread_create( &t2, NULL, steer, (void*)&info );
+
+     pthread_join( t1, NULL );
+     pthread_join( t2, NULL );
+
+     VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
+
+  }
+#endif
+  free(info.arr);
+
+  return 0;
+}
+
+void* steer ( void* infoV )
+{
+   Info* info = (Info*)infoV;
+   int   wot  = info->skipoff;
+   void*(*fn)(void*) = info->child;
+   if (wot >= 500) goto halfway;
+
+   __asm__ __volatile__("");
+   if (wot == 0) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 1) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 2) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 3) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 4) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 5) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 6) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 7) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 8) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 9) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 10) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 11) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 12) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 13) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 14) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 15) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 16) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 17) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 18) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 19) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 20) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 21) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 22) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 23) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 24) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 25) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 26) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 27) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 28) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 29) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 30) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 31) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 32) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 33) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 34) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 35) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 36) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 37) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 38) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 39) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 40) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 41) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 42) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 43) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 44) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 45) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 46) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 47) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 48) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 49) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 50) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 51) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 52) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 53) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 54) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 55) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 56) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 57) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 58) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 59) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 60) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 61) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 62) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 63) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 64) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 65) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 66) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 67) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 68) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 69) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 70) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 71) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 72) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 73) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 74) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 75) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 76) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 77) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 78) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 79) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 80) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 81) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 82) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 83) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 84) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 85) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 86) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 87) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 88) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 89) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 90) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 91) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 92) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 93) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 94) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 95) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 96) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 97) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 98) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 99) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 100) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 101) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 102) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 103) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 104) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 105) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 106) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 107) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 108) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 109) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 110) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 111) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 112) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 113) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 114) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 115) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 116) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 117) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 118) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 119) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 120) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 121) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 122) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 123) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 124) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 125) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 126) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 127) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 128) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 129) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 130) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 131) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 132) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 133) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 134) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 135) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 136) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 137) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 138) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 139) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 140) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 141) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 142) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 143) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 144) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 145) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 146) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 147) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 148) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 149) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 150) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 151) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 152) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 153) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 154) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 155) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 156) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 157) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 158) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 159) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 160) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 161) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 162) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 163) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 164) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 165) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 166) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 167) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 168) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 169) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 170) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 171) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 172) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 173) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 174) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 175) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 176) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 177) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 178) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 179) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 180) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 181) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 182) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 183) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 184) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 185) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 186) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 187) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 188) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 189) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 190) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 191) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 192) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 193) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 194) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 195) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 196) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 197) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 198) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 199) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 200) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 201) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 202) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 203) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 204) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 205) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 206) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 207) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 208) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 209) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 210) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 211) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 212) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 213) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 214) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 215) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 216) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 217) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 218) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 219) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 220) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 221) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 222) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 223) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 224) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 225) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 226) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 227) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 228) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 229) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 230) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 231) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 232) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 233) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 234) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 235) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 236) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 237) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 238) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 239) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 240) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 241) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 242) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 243) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 244) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 245) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 246) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 247) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 248) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 249) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 250) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 251) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 252) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 253) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 254) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 255) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 256) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 257) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 258) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 259) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 260) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 261) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 262) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 263) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 264) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 265) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 266) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 267) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 268) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 269) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 270) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 271) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 272) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 273) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 274) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 275) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 276) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 277) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 278) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 279) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 280) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 281) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 282) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 283) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 284) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 285) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 286) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 287) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 288) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 289) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 290) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 291) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 292) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 293) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 294) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 295) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 296) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 297) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 298) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 299) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 300) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 301) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 302) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 303) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 304) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 305) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 306) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 307) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 308) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 309) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 310) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 311) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 312) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 313) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 314) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 315) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 316) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 317) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 318) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 319) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 320) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 321) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 322) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 323) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 324) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 325) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 326) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 327) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 328) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 329) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 330) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 331) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 332) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 333) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 334) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 335) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 336) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 337) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 338) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 339) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 340) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 341) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 342) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 343) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 344) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 345) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 346) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 347) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 348) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 349) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 350) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 351) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 352) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 353) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 354) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 355) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 356) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 357) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 358) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 359) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 360) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 361) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 362) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 363) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 364) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 365) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 366) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 367) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 368) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 369) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 370) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 371) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 372) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 373) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 374) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 375) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 376) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 377) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 378) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 379) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 380) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 381) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 382) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 383) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 384) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 385) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 386) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 387) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 388) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 389) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 390) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 391) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 392) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 393) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 394) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 395) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 396) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 397) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 398) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 399) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 400) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 401) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 402) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 403) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 404) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 405) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 406) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 407) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 408) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 409) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 410) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 411) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 412) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 413) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 414) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 415) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 416) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 417) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 418) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 419) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 420) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 421) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 422) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 423) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 424) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 425) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 426) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 427) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 428) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 429) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 430) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 431) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 432) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 433) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 434) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 435) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 436) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 437) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 438) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 439) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 440) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 441) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 442) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 443) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 444) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 445) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 446) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 447) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 448) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 449) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 450) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 451) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 452) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 453) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 454) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 455) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 456) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 457) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 458) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 459) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 460) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 461) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 462) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 463) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 464) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 465) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 466) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 467) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 468) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 469) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 470) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 471) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 472) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 473) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 474) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 475) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 476) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 477) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 478) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 479) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 480) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 481) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 482) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 483) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 484) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 485) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 486) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 487) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 488) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 489) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 490) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 491) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 492) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 493) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 494) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 495) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 496) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 497) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 498) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 499) return fn(info);
+   __asm__ __volatile__("");
+  halfway:
+   if (wot == 500) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 501) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 502) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 503) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 504) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 505) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 506) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 507) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 508) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 509) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 510) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 511) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 512) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 513) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 514) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 515) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 516) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 517) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 518) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 519) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 520) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 521) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 522) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 523) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 524) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 525) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 526) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 527) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 528) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 529) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 530) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 531) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 532) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 533) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 534) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 535) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 536) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 537) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 538) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 539) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 540) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 541) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 542) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 543) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 544) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 545) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 546) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 547) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 548) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 549) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 550) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 551) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 552) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 553) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 554) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 555) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 556) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 557) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 558) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 559) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 560) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 561) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 562) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 563) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 564) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 565) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 566) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 567) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 568) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 569) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 570) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 571) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 572) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 573) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 574) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 575) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 576) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 577) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 578) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 579) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 580) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 581) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 582) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 583) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 584) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 585) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 586) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 587) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 588) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 589) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 590) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 591) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 592) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 593) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 594) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 595) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 596) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 597) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 598) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 599) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 600) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 601) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 602) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 603) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 604) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 605) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 606) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 607) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 608) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 609) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 610) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 611) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 612) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 613) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 614) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 615) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 616) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 617) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 618) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 619) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 620) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 621) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 622) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 623) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 624) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 625) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 626) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 627) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 628) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 629) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 630) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 631) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 632) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 633) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 634) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 635) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 636) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 637) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 638) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 639) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 640) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 641) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 642) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 643) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 644) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 645) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 646) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 647) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 648) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 649) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 650) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 651) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 652) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 653) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 654) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 655) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 656) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 657) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 658) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 659) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 660) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 661) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 662) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 663) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 664) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 665) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 666) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 667) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 668) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 669) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 670) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 671) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 672) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 673) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 674) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 675) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 676) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 677) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 678) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 679) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 680) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 681) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 682) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 683) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 684) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 685) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 686) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 687) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 688) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 689) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 690) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 691) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 692) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 693) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 694) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 695) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 696) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 697) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 698) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 699) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 700) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 701) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 702) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 703) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 704) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 705) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 706) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 707) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 708) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 709) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 710) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 711) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 712) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 713) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 714) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 715) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 716) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 717) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 718) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 719) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 720) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 721) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 722) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 723) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 724) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 725) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 726) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 727) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 728) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 729) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 730) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 731) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 732) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 733) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 734) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 735) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 736) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 737) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 738) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 739) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 740) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 741) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 742) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 743) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 744) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 745) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 746) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 747) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 748) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 749) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 750) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 751) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 752) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 753) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 754) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 755) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 756) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 757) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 758) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 759) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 760) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 761) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 762) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 763) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 764) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 765) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 766) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 767) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 768) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 769) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 770) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 771) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 772) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 773) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 774) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 775) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 776) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 777) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 778) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 779) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 780) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 781) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 782) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 783) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 784) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 785) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 786) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 787) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 788) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 789) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 790) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 791) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 792) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 793) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 794) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 795) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 796) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 797) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 798) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 799) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 800) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 801) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 802) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 803) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 804) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 805) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 806) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 807) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 808) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 809) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 810) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 811) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 812) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 813) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 814) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 815) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 816) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 817) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 818) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 819) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 820) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 821) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 822) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 823) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 824) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 825) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 826) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 827) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 828) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 829) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 830) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 831) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 832) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 833) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 834) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 835) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 836) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 837) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 838) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 839) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 840) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 841) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 842) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 843) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 844) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 845) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 846) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 847) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 848) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 849) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 850) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 851) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 852) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 853) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 854) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 855) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 856) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 857) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 858) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 859) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 860) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 861) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 862) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 863) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 864) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 865) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 866) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 867) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 868) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 869) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 870) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 871) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 872) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 873) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 874) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 875) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 876) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 877) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 878) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 879) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 880) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 881) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 882) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 883) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 884) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 885) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 886) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 887) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 888) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 889) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 890) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 891) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 892) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 893) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 894) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 895) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 896) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 897) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 898) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 899) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 900) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 901) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 902) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 903) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 904) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 905) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 906) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 907) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 908) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 909) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 910) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 911) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 912) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 913) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 914) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 915) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 916) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 917) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 918) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 919) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 920) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 921) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 922) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 923) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 924) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 925) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 926) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 927) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 928) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 929) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 930) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 931) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 932) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 933) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 934) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 935) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 936) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 937) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 938) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 939) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 940) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 941) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 942) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 943) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 944) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 945) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 946) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 947) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 948) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 949) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 950) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 951) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 952) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 953) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 954) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 955) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 956) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 957) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 958) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 959) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 960) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 961) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 962) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 963) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 964) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 965) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 966) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 967) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 968) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 969) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 970) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 971) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 972) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 973) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 974) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 975) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 976) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 977) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 978) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 979) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 980) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 981) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 982) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 983) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 984) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 985) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 986) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 987) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 988) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 989) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 990) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 991) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 992) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 993) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 994) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 995) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 996) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 997) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 998) return fn(info);
+   __asm__ __volatile__("");
+   if (wot == 999) return fn(info);
+   __asm__ __volatile__("");
+
+   assert(0);
+}
diff --git a/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64 b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..8f83732
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-amd64
@@ -0,0 +1,15840 @@
+
+
+===========================================================
+=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===
+===========================================================
+
+---------- char gran, 0 .. 99, skip 0 ----------
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #2
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no locks at all
+---------- char gran, 0 .. 99, skip 1 ----------
+
+Thread #4 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #5 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #4
+  New state: shared-modified by threads #4, #5
+  Reason:    this thread, #5, holds no locks at all
+---------- char gran, 0 .. 99, skip 2 ----------
+
+Thread #6 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #7 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #6
+  New state: shared-modified by threads #6, #7
+  Reason:    this thread, #7, holds no locks at all
+---------- char gran, 0 .. 99, skip 3 ----------
+
+Thread #8 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #9 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #8
+  New state: shared-modified by threads #8, #9
+  Reason:    this thread, #9, holds no locks at all
+---------- char gran, 0 .. 99, skip 4 ----------
+
+Thread #10 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #11 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #10
+  New state: shared-modified by threads #10, #11
+  Reason:    this thread, #11, holds no locks at all
+---------- char gran, 0 .. 99, skip 5 ----------
+
+Thread #12 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #13 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #12
+  New state: shared-modified by threads #12, #13
+  Reason:    this thread, #13, holds no locks at all
+---------- char gran, 0 .. 99, skip 6 ----------
+
+Thread #14 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #15 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #14
+  New state: shared-modified by threads #14, #15
+  Reason:    this thread, #15, holds no locks at all
+---------- char gran, 0 .. 99, skip 7 ----------
+
+Thread #16 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #17 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #16
+  New state: shared-modified by threads #16, #17
+  Reason:    this thread, #17, holds no locks at all
+---------- char gran, 0 .. 99, skip 8 ----------
+
+Thread #18 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #19 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #18
+  New state: shared-modified by threads #18, #19
+  Reason:    this thread, #19, holds no locks at all
+---------- char gran, 0 .. 99, skip 9 ----------
+
+Thread #20 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #21 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #20
+  New state: shared-modified by threads #20, #21
+  Reason:    this thread, #21, holds no locks at all
+---------- char gran, 0 .. 99, skip 10 ----------
+
+Thread #22 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #23 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #22
+  New state: shared-modified by threads #22, #23
+  Reason:    this thread, #23, holds no locks at all
+---------- char gran, 0 .. 99, skip 11 ----------
+
+Thread #24 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #25 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #24
+  New state: shared-modified by threads #24, #25
+  Reason:    this thread, #25, holds no locks at all
+---------- char gran, 0 .. 99, skip 12 ----------
+
+Thread #26 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #27 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #26
+  New state: shared-modified by threads #26, #27
+  Reason:    this thread, #27, holds no locks at all
+---------- char gran, 0 .. 99, skip 13 ----------
+
+Thread #28 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #29 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #28
+  New state: shared-modified by threads #28, #29
+  Reason:    this thread, #29, holds no locks at all
+---------- char gran, 0 .. 99, skip 14 ----------
+
+Thread #30 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #31 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #30
+  New state: shared-modified by threads #30, #31
+  Reason:    this thread, #31, holds no locks at all
+---------- char gran, 0 .. 99, skip 15 ----------
+
+Thread #32 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #33 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #32
+  New state: shared-modified by threads #32, #33
+  Reason:    this thread, #33, holds no locks at all
+---------- char gran, 0 .. 99, skip 16 ----------
+
+Thread #34 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #35 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #34
+  New state: shared-modified by threads #34, #35
+  Reason:    this thread, #35, holds no locks at all
+---------- char gran, 0 .. 99, skip 17 ----------
+
+Thread #36 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #37 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #36
+  New state: shared-modified by threads #36, #37
+  Reason:    this thread, #37, holds no locks at all
+---------- char gran, 0 .. 99, skip 18 ----------
+
+Thread #38 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #39 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #38
+  New state: shared-modified by threads #38, #39
+  Reason:    this thread, #39, holds no locks at all
+---------- char gran, 0 .. 99, skip 19 ----------
+
+Thread #40 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #41 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #40
+  New state: shared-modified by threads #40, #41
+  Reason:    this thread, #41, holds no locks at all
+---------- char gran, 0 .. 99, skip 20 ----------
+
+Thread #42 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #43 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #42
+  New state: shared-modified by threads #42, #43
+  Reason:    this thread, #43, holds no locks at all
+---------- char gran, 0 .. 99, skip 21 ----------
+
+Thread #44 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #45 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #44
+  New state: shared-modified by threads #44, #45
+  Reason:    this thread, #45, holds no locks at all
+---------- char gran, 0 .. 99, skip 22 ----------
+
+Thread #46 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #47 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #46
+  New state: shared-modified by threads #46, #47
+  Reason:    this thread, #47, holds no locks at all
+---------- char gran, 0 .. 99, skip 23 ----------
+
+Thread #48 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #49 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #48
+  New state: shared-modified by threads #48, #49
+  Reason:    this thread, #49, holds no locks at all
+---------- char gran, 0 .. 99, skip 24 ----------
+
+Thread #50 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #51 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #50
+  New state: shared-modified by threads #50, #51
+  Reason:    this thread, #51, holds no locks at all
+---------- char gran, 0 .. 99, skip 25 ----------
+
+Thread #52 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #53 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #52
+  New state: shared-modified by threads #52, #53
+  Reason:    this thread, #53, holds no locks at all
+---------- char gran, 0 .. 99, skip 26 ----------
+
+Thread #54 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #55 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #54
+  New state: shared-modified by threads #54, #55
+  Reason:    this thread, #55, holds no locks at all
+---------- char gran, 0 .. 99, skip 27 ----------
+
+Thread #56 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #57 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #56
+  New state: shared-modified by threads #56, #57
+  Reason:    this thread, #57, holds no locks at all
+---------- char gran, 0 .. 99, skip 28 ----------
+
+Thread #58 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #59 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #58
+  New state: shared-modified by threads #58, #59
+  Reason:    this thread, #59, holds no locks at all
+---------- char gran, 0 .. 99, skip 29 ----------
+
+Thread #60 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #61 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #60
+  New state: shared-modified by threads #60, #61
+  Reason:    this thread, #61, holds no locks at all
+---------- char gran, 0 .. 99, skip 30 ----------
+
+Thread #62 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #63 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #62
+  New state: shared-modified by threads #62, #63
+  Reason:    this thread, #63, holds no locks at all
+---------- char gran, 0 .. 99, skip 31 ----------
+
+Thread #64 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #65 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #64
+  New state: shared-modified by threads #64, #65
+  Reason:    this thread, #65, holds no locks at all
+---------- char gran, 0 .. 99, skip 32 ----------
+
+Thread #66 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #67 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #66
+  New state: shared-modified by threads #66, #67
+  Reason:    this thread, #67, holds no locks at all
+---------- char gran, 0 .. 99, skip 33 ----------
+
+Thread #68 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #69 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #68
+  New state: shared-modified by threads #68, #69
+  Reason:    this thread, #69, holds no locks at all
+---------- char gran, 0 .. 99, skip 34 ----------
+
+Thread #70 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #71 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #70
+  New state: shared-modified by threads #70, #71
+  Reason:    this thread, #71, holds no locks at all
+---------- char gran, 0 .. 99, skip 35 ----------
+
+Thread #72 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #73 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #72
+  New state: shared-modified by threads #72, #73
+  Reason:    this thread, #73, holds no locks at all
+---------- char gran, 0 .. 99, skip 36 ----------
+
+Thread #74 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #75 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #74
+  New state: shared-modified by threads #74, #75
+  Reason:    this thread, #75, holds no locks at all
+---------- char gran, 0 .. 99, skip 37 ----------
+
+Thread #76 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #77 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #76
+  New state: shared-modified by threads #76, #77
+  Reason:    this thread, #77, holds no locks at all
+---------- char gran, 0 .. 99, skip 38 ----------
+
+Thread #78 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #79 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #78
+  New state: shared-modified by threads #78, #79
+  Reason:    this thread, #79, holds no locks at all
+---------- char gran, 0 .. 99, skip 39 ----------
+
+Thread #80 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #81 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #80
+  New state: shared-modified by threads #80, #81
+  Reason:    this thread, #81, holds no locks at all
+---------- char gran, 0 .. 99, skip 40 ----------
+
+Thread #82 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #83 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #82
+  New state: shared-modified by threads #82, #83
+  Reason:    this thread, #83, holds no locks at all
+---------- char gran, 0 .. 99, skip 41 ----------
+
+Thread #84 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #85 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #84
+  New state: shared-modified by threads #84, #85
+  Reason:    this thread, #85, holds no locks at all
+---------- char gran, 0 .. 99, skip 42 ----------
+
+Thread #86 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #87 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #86
+  New state: shared-modified by threads #86, #87
+  Reason:    this thread, #87, holds no locks at all
+---------- char gran, 0 .. 99, skip 43 ----------
+
+Thread #88 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #89 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #88
+  New state: shared-modified by threads #88, #89
+  Reason:    this thread, #89, holds no locks at all
+---------- char gran, 0 .. 99, skip 44 ----------
+
+Thread #90 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #91 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #90
+  New state: shared-modified by threads #90, #91
+  Reason:    this thread, #91, holds no locks at all
+---------- char gran, 0 .. 99, skip 45 ----------
+
+Thread #92 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #93 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #92
+  New state: shared-modified by threads #92, #93
+  Reason:    this thread, #93, holds no locks at all
+---------- char gran, 0 .. 99, skip 46 ----------
+
+Thread #94 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #95 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #94
+  New state: shared-modified by threads #94, #95
+  Reason:    this thread, #95, holds no locks at all
+---------- char gran, 0 .. 99, skip 47 ----------
+
+Thread #96 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #97 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #96
+  New state: shared-modified by threads #96, #97
+  Reason:    this thread, #97, holds no locks at all
+---------- char gran, 0 .. 99, skip 48 ----------
+
+Thread #98 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #99 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #98
+  New state: shared-modified by threads #98, #99
+  Reason:    this thread, #99, holds no locks at all
+---------- char gran, 0 .. 99, skip 49 ----------
+
+Thread #100 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #101 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #100
+  New state: shared-modified by threads #100, #101
+  Reason:    this thread, #101, holds no locks at all
+---------- char gran, 0 .. 99, skip 50 ----------
+
+Thread #102 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #103 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #102
+  New state: shared-modified by threads #102, #103
+  Reason:    this thread, #103, holds no locks at all
+---------- char gran, 0 .. 99, skip 51 ----------
+
+Thread #104 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #105 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #104
+  New state: shared-modified by threads #104, #105
+  Reason:    this thread, #105, holds no locks at all
+---------- char gran, 0 .. 99, skip 52 ----------
+
+Thread #106 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #107 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #106
+  New state: shared-modified by threads #106, #107
+  Reason:    this thread, #107, holds no locks at all
+---------- char gran, 0 .. 99, skip 53 ----------
+
+Thread #108 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #109 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #108
+  New state: shared-modified by threads #108, #109
+  Reason:    this thread, #109, holds no locks at all
+---------- char gran, 0 .. 99, skip 54 ----------
+
+Thread #110 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #111 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #110
+  New state: shared-modified by threads #110, #111
+  Reason:    this thread, #111, holds no locks at all
+---------- char gran, 0 .. 99, skip 55 ----------
+
+Thread #112 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #113 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #112
+  New state: shared-modified by threads #112, #113
+  Reason:    this thread, #113, holds no locks at all
+---------- char gran, 0 .. 99, skip 56 ----------
+
+Thread #114 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #115 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #114
+  New state: shared-modified by threads #114, #115
+  Reason:    this thread, #115, holds no locks at all
+---------- char gran, 0 .. 99, skip 57 ----------
+
+Thread #116 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #117 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #116
+  New state: shared-modified by threads #116, #117
+  Reason:    this thread, #117, holds no locks at all
+---------- char gran, 0 .. 99, skip 58 ----------
+
+Thread #118 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #119 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #118
+  New state: shared-modified by threads #118, #119
+  Reason:    this thread, #119, holds no locks at all
+---------- char gran, 0 .. 99, skip 59 ----------
+
+Thread #120 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #121 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #120
+  New state: shared-modified by threads #120, #121
+  Reason:    this thread, #121, holds no locks at all
+---------- char gran, 0 .. 99, skip 60 ----------
+
+Thread #122 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #123 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #122
+  New state: shared-modified by threads #122, #123
+  Reason:    this thread, #123, holds no locks at all
+---------- char gran, 0 .. 99, skip 61 ----------
+
+Thread #124 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #125 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #124
+  New state: shared-modified by threads #124, #125
+  Reason:    this thread, #125, holds no locks at all
+---------- char gran, 0 .. 99, skip 62 ----------
+
+Thread #126 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #127 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #126
+  New state: shared-modified by threads #126, #127
+  Reason:    this thread, #127, holds no locks at all
+---------- char gran, 0 .. 99, skip 63 ----------
+
+Thread #128 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #129 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #128
+  New state: shared-modified by threads #128, #129
+  Reason:    this thread, #129, holds no locks at all
+---------- char gran, 0 .. 99, skip 64 ----------
+
+Thread #130 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #131 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #130
+  New state: shared-modified by threads #130, #131
+  Reason:    this thread, #131, holds no locks at all
+---------- char gran, 0 .. 99, skip 65 ----------
+
+Thread #132 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #133 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #132
+  New state: shared-modified by threads #132, #133
+  Reason:    this thread, #133, holds no locks at all
+---------- char gran, 0 .. 99, skip 66 ----------
+
+Thread #134 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #135 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #134
+  New state: shared-modified by threads #134, #135
+  Reason:    this thread, #135, holds no locks at all
+---------- char gran, 0 .. 99, skip 67 ----------
+
+Thread #136 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #137 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #136
+  New state: shared-modified by threads #136, #137
+  Reason:    this thread, #137, holds no locks at all
+---------- char gran, 0 .. 99, skip 68 ----------
+
+Thread #138 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #139 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #138
+  New state: shared-modified by threads #138, #139
+  Reason:    this thread, #139, holds no locks at all
+---------- char gran, 0 .. 99, skip 69 ----------
+
+Thread #140 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #141 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #140
+  New state: shared-modified by threads #140, #141
+  Reason:    this thread, #141, holds no locks at all
+---------- char gran, 0 .. 99, skip 70 ----------
+
+Thread #142 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #143 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #142
+  New state: shared-modified by threads #142, #143
+  Reason:    this thread, #143, holds no locks at all
+---------- char gran, 0 .. 99, skip 71 ----------
+
+Thread #144 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #145 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #144
+  New state: shared-modified by threads #144, #145
+  Reason:    this thread, #145, holds no locks at all
+---------- char gran, 0 .. 99, skip 72 ----------
+
+Thread #146 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #147 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #146
+  New state: shared-modified by threads #146, #147
+  Reason:    this thread, #147, holds no locks at all
+---------- char gran, 0 .. 99, skip 73 ----------
+
+Thread #148 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #149 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #148
+  New state: shared-modified by threads #148, #149
+  Reason:    this thread, #149, holds no locks at all
+---------- char gran, 0 .. 99, skip 74 ----------
+
+Thread #150 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #151 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #150
+  New state: shared-modified by threads #150, #151
+  Reason:    this thread, #151, holds no locks at all
+---------- char gran, 0 .. 99, skip 75 ----------
+
+Thread #152 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #153 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #152
+  New state: shared-modified by threads #152, #153
+  Reason:    this thread, #153, holds no locks at all
+---------- char gran, 0 .. 99, skip 76 ----------
+
+Thread #154 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #155 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #154
+  New state: shared-modified by threads #154, #155
+  Reason:    this thread, #155, holds no locks at all
+---------- char gran, 0 .. 99, skip 77 ----------
+
+Thread #156 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #157 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #156
+  New state: shared-modified by threads #156, #157
+  Reason:    this thread, #157, holds no locks at all
+---------- char gran, 0 .. 99, skip 78 ----------
+
+Thread #158 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #159 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #158
+  New state: shared-modified by threads #158, #159
+  Reason:    this thread, #159, holds no locks at all
+---------- char gran, 0 .. 99, skip 79 ----------
+
+Thread #160 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #161 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #160
+  New state: shared-modified by threads #160, #161
+  Reason:    this thread, #161, holds no locks at all
+---------- char gran, 0 .. 99, skip 80 ----------
+
+Thread #162 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #163 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #162
+  New state: shared-modified by threads #162, #163
+  Reason:    this thread, #163, holds no locks at all
+---------- char gran, 0 .. 99, skip 81 ----------
+
+Thread #164 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #165 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #164
+  New state: shared-modified by threads #164, #165
+  Reason:    this thread, #165, holds no locks at all
+---------- char gran, 0 .. 99, skip 82 ----------
+
+Thread #166 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #167 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #166
+  New state: shared-modified by threads #166, #167
+  Reason:    this thread, #167, holds no locks at all
+---------- char gran, 0 .. 99, skip 83 ----------
+
+Thread #168 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #169 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #168
+  New state: shared-modified by threads #168, #169
+  Reason:    this thread, #169, holds no locks at all
+---------- char gran, 0 .. 99, skip 84 ----------
+
+Thread #170 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #171 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #170
+  New state: shared-modified by threads #170, #171
+  Reason:    this thread, #171, holds no locks at all
+---------- char gran, 0 .. 99, skip 85 ----------
+
+Thread #172 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #173 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #172
+  New state: shared-modified by threads #172, #173
+  Reason:    this thread, #173, holds no locks at all
+---------- char gran, 0 .. 99, skip 86 ----------
+
+Thread #174 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #175 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #174
+  New state: shared-modified by threads #174, #175
+  Reason:    this thread, #175, holds no locks at all
+---------- char gran, 0 .. 99, skip 87 ----------
+
+Thread #176 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #177 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #176
+  New state: shared-modified by threads #176, #177
+  Reason:    this thread, #177, holds no locks at all
+---------- char gran, 0 .. 99, skip 88 ----------
+
+Thread #178 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #179 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #178
+  New state: shared-modified by threads #178, #179
+  Reason:    this thread, #179, holds no locks at all
+---------- char gran, 0 .. 99, skip 89 ----------
+
+Thread #180 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #181 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #180
+  New state: shared-modified by threads #180, #181
+  Reason:    this thread, #181, holds no locks at all
+---------- char gran, 0 .. 99, skip 90 ----------
+
+Thread #182 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #183 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #182
+  New state: shared-modified by threads #182, #183
+  Reason:    this thread, #183, holds no locks at all
+---------- char gran, 0 .. 99, skip 91 ----------
+
+Thread #184 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #185 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #184
+  New state: shared-modified by threads #184, #185
+  Reason:    this thread, #185, holds no locks at all
+---------- char gran, 0 .. 99, skip 92 ----------
+
+Thread #186 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #187 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #186
+  New state: shared-modified by threads #186, #187
+  Reason:    this thread, #187, holds no locks at all
+---------- char gran, 0 .. 99, skip 93 ----------
+
+Thread #188 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #189 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #188
+  New state: shared-modified by threads #188, #189
+  Reason:    this thread, #189, holds no locks at all
+---------- char gran, 0 .. 99, skip 94 ----------
+
+Thread #190 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #191 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #190
+  New state: shared-modified by threads #190, #191
+  Reason:    this thread, #191, holds no locks at all
+---------- char gran, 0 .. 99, skip 95 ----------
+
+Thread #192 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #193 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #192
+  New state: shared-modified by threads #192, #193
+  Reason:    this thread, #193, holds no locks at all
+---------- char gran, 0 .. 99, skip 96 ----------
+
+Thread #194 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #195 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:480)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #194
+  New state: shared-modified by threads #194, #195
+  Reason:    this thread, #195, holds no locks at all
+---------- char gran, 0 .. 99, skip 97 ----------
+
+Thread #196 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #197 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #196
+  New state: shared-modified by threads #196, #197
+  Reason:    this thread, #197, holds no locks at all
+---------- char gran, 0 .. 99, skip 98 ----------
+
+Thread #198 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #199 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:484)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #198
+  New state: shared-modified by threads #198, #199
+  Reason:    this thread, #199, holds no locks at all
+
+==========================================================
+=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===
+==========================================================
+
+---------- short gran, 0 .. 98, skip 0 ----------
+
+Thread #200 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #201 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #200
+  New state: shared-modified by threads #200, #201
+  Reason:    this thread, #201, holds no locks at all
+
+More than 100 errors detected.  Subsequent errors
+will still be recorded, but in less detail than before.
+---------- short gran, 1 .. 98, skip 1 ----------
+
+Thread #202 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #203 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #202
+  New state: shared-modified by threads #202, #203
+  Reason:    this thread, #203, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #202
+  New state: shared-modified by threads #202, #203
+  Reason:    this thread, #203, holds no locks at all
+---------- short gran, 0 .. 98, skip 2 ----------
+
+Thread #204 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #205 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #204
+  New state: shared-modified by threads #204, #205
+  Reason:    this thread, #205, holds no locks at all
+---------- short gran, 1 .. 98, skip 3 ----------
+
+Thread #206 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #207 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #206
+  New state: shared-modified by threads #206, #207
+  Reason:    this thread, #207, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #206
+  New state: shared-modified by threads #206, #207
+  Reason:    this thread, #207, holds no locks at all
+---------- short gran, 0 .. 98, skip 4 ----------
+
+Thread #208 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #209 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #208
+  New state: shared-modified by threads #208, #209
+  Reason:    this thread, #209, holds no locks at all
+---------- short gran, 1 .. 98, skip 5 ----------
+
+Thread #210 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #211 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #210
+  New state: shared-modified by threads #210, #211
+  Reason:    this thread, #211, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #210
+  New state: shared-modified by threads #210, #211
+  Reason:    this thread, #211, holds no locks at all
+---------- short gran, 0 .. 98, skip 6 ----------
+
+Thread #212 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #213 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #212
+  New state: shared-modified by threads #212, #213
+  Reason:    this thread, #213, holds no locks at all
+---------- short gran, 1 .. 98, skip 7 ----------
+
+Thread #214 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #215 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #214
+  New state: shared-modified by threads #214, #215
+  Reason:    this thread, #215, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #214
+  New state: shared-modified by threads #214, #215
+  Reason:    this thread, #215, holds no locks at all
+---------- short gran, 0 .. 98, skip 8 ----------
+
+Thread #216 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #217 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #216
+  New state: shared-modified by threads #216, #217
+  Reason:    this thread, #217, holds no locks at all
+---------- short gran, 1 .. 98, skip 9 ----------
+
+Thread #218 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #219 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #218
+  New state: shared-modified by threads #218, #219
+  Reason:    this thread, #219, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #218
+  New state: shared-modified by threads #218, #219
+  Reason:    this thread, #219, holds no locks at all
+---------- short gran, 0 .. 98, skip 10 ----------
+
+Thread #220 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #221 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #220
+  New state: shared-modified by threads #220, #221
+  Reason:    this thread, #221, holds no locks at all
+---------- short gran, 1 .. 98, skip 11 ----------
+
+Thread #222 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #223 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #222
+  New state: shared-modified by threads #222, #223
+  Reason:    this thread, #223, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #222
+  New state: shared-modified by threads #222, #223
+  Reason:    this thread, #223, holds no locks at all
+---------- short gran, 0 .. 98, skip 12 ----------
+
+Thread #224 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #225 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #224
+  New state: shared-modified by threads #224, #225
+  Reason:    this thread, #225, holds no locks at all
+---------- short gran, 1 .. 98, skip 13 ----------
+
+Thread #226 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #227 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #226
+  New state: shared-modified by threads #226, #227
+  Reason:    this thread, #227, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #226
+  New state: shared-modified by threads #226, #227
+  Reason:    this thread, #227, holds no locks at all
+---------- short gran, 0 .. 98, skip 14 ----------
+
+Thread #228 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #229 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #228
+  New state: shared-modified by threads #228, #229
+  Reason:    this thread, #229, holds no locks at all
+---------- short gran, 1 .. 98, skip 15 ----------
+
+Thread #230 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #231 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #230
+  New state: shared-modified by threads #230, #231
+  Reason:    this thread, #231, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #230
+  New state: shared-modified by threads #230, #231
+  Reason:    this thread, #231, holds no locks at all
+---------- short gran, 0 .. 98, skip 16 ----------
+
+Thread #232 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #233 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #232
+  New state: shared-modified by threads #232, #233
+  Reason:    this thread, #233, holds no locks at all
+---------- short gran, 1 .. 98, skip 17 ----------
+
+Thread #234 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #235 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #234
+  New state: shared-modified by threads #234, #235
+  Reason:    this thread, #235, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #234
+  New state: shared-modified by threads #234, #235
+  Reason:    this thread, #235, holds no locks at all
+---------- short gran, 0 .. 98, skip 18 ----------
+
+Thread #236 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #237 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #236
+  New state: shared-modified by threads #236, #237
+  Reason:    this thread, #237, holds no locks at all
+---------- short gran, 1 .. 98, skip 19 ----------
+
+Thread #238 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #239 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #238
+  New state: shared-modified by threads #238, #239
+  Reason:    this thread, #239, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #238
+  New state: shared-modified by threads #238, #239
+  Reason:    this thread, #239, holds no locks at all
+---------- short gran, 0 .. 98, skip 20 ----------
+
+Thread #240 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #241 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #240
+  New state: shared-modified by threads #240, #241
+  Reason:    this thread, #241, holds no locks at all
+---------- short gran, 1 .. 98, skip 21 ----------
+
+Thread #242 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #243 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #242
+  New state: shared-modified by threads #242, #243
+  Reason:    this thread, #243, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #242
+  New state: shared-modified by threads #242, #243
+  Reason:    this thread, #243, holds no locks at all
+---------- short gran, 0 .. 98, skip 22 ----------
+
+Thread #244 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #245 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #244
+  New state: shared-modified by threads #244, #245
+  Reason:    this thread, #245, holds no locks at all
+---------- short gran, 1 .. 98, skip 23 ----------
+
+Thread #246 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #247 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #246
+  New state: shared-modified by threads #246, #247
+  Reason:    this thread, #247, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #246
+  New state: shared-modified by threads #246, #247
+  Reason:    this thread, #247, holds no locks at all
+---------- short gran, 0 .. 98, skip 24 ----------
+
+Thread #248 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #249 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #248
+  New state: shared-modified by threads #248, #249
+  Reason:    this thread, #249, holds no locks at all
+---------- short gran, 1 .. 98, skip 25 ----------
+
+Thread #250 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #251 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #250
+  New state: shared-modified by threads #250, #251
+  Reason:    this thread, #251, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #250
+  New state: shared-modified by threads #250, #251
+  Reason:    this thread, #251, holds no locks at all
+---------- short gran, 0 .. 98, skip 26 ----------
+
+Thread #252 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #253 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #252
+  New state: shared-modified by threads #252, #253
+  Reason:    this thread, #253, holds no locks at all
+---------- short gran, 1 .. 98, skip 27 ----------
+
+Thread #254 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #255 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #254
+  New state: shared-modified by threads #254, #255
+  Reason:    this thread, #255, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #254
+  New state: shared-modified by threads #254, #255
+  Reason:    this thread, #255, holds no locks at all
+---------- short gran, 0 .. 98, skip 28 ----------
+
+Thread #256 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #257 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #256
+  New state: shared-modified by threads #256, #257
+  Reason:    this thread, #257, holds no locks at all
+---------- short gran, 1 .. 98, skip 29 ----------
+
+Thread #258 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #259 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #258
+  New state: shared-modified by threads #258, #259
+  Reason:    this thread, #259, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #258
+  New state: shared-modified by threads #258, #259
+  Reason:    this thread, #259, holds no locks at all
+---------- short gran, 0 .. 98, skip 30 ----------
+
+Thread #260 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #261 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #260
+  New state: shared-modified by threads #260, #261
+  Reason:    this thread, #261, holds no locks at all
+---------- short gran, 1 .. 98, skip 31 ----------
+
+Thread #262 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #263 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #262
+  New state: shared-modified by threads #262, #263
+  Reason:    this thread, #263, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #262
+  New state: shared-modified by threads #262, #263
+  Reason:    this thread, #263, holds no locks at all
+---------- short gran, 0 .. 98, skip 32 ----------
+
+Thread #264 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #265 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #264
+  New state: shared-modified by threads #264, #265
+  Reason:    this thread, #265, holds no locks at all
+---------- short gran, 1 .. 98, skip 33 ----------
+
+Thread #266 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #267 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #266
+  New state: shared-modified by threads #266, #267
+  Reason:    this thread, #267, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #266
+  New state: shared-modified by threads #266, #267
+  Reason:    this thread, #267, holds no locks at all
+---------- short gran, 0 .. 98, skip 34 ----------
+
+Thread #268 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #269 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #268
+  New state: shared-modified by threads #268, #269
+  Reason:    this thread, #269, holds no locks at all
+---------- short gran, 1 .. 98, skip 35 ----------
+
+Thread #270 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #271 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #270
+  New state: shared-modified by threads #270, #271
+  Reason:    this thread, #271, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #270
+  New state: shared-modified by threads #270, #271
+  Reason:    this thread, #271, holds no locks at all
+---------- short gran, 0 .. 98, skip 36 ----------
+
+Thread #272 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #273 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #272
+  New state: shared-modified by threads #272, #273
+  Reason:    this thread, #273, holds no locks at all
+---------- short gran, 1 .. 98, skip 37 ----------
+
+Thread #274 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #275 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #274
+  New state: shared-modified by threads #274, #275
+  Reason:    this thread, #275, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #274
+  New state: shared-modified by threads #274, #275
+  Reason:    this thread, #275, holds no locks at all
+---------- short gran, 0 .. 98, skip 38 ----------
+
+Thread #276 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #277 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #276
+  New state: shared-modified by threads #276, #277
+  Reason:    this thread, #277, holds no locks at all
+---------- short gran, 1 .. 98, skip 39 ----------
+
+Thread #278 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #279 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #278
+  New state: shared-modified by threads #278, #279
+  Reason:    this thread, #279, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #278
+  New state: shared-modified by threads #278, #279
+  Reason:    this thread, #279, holds no locks at all
+---------- short gran, 0 .. 98, skip 40 ----------
+
+Thread #280 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #281 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #280
+  New state: shared-modified by threads #280, #281
+  Reason:    this thread, #281, holds no locks at all
+---------- short gran, 1 .. 98, skip 41 ----------
+
+Thread #282 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #283 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #282
+  New state: shared-modified by threads #282, #283
+  Reason:    this thread, #283, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #282
+  New state: shared-modified by threads #282, #283
+  Reason:    this thread, #283, holds no locks at all
+---------- short gran, 0 .. 98, skip 42 ----------
+
+Thread #284 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #285 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #284
+  New state: shared-modified by threads #284, #285
+  Reason:    this thread, #285, holds no locks at all
+---------- short gran, 1 .. 98, skip 43 ----------
+
+Thread #286 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #287 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #286
+  New state: shared-modified by threads #286, #287
+  Reason:    this thread, #287, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #286
+  New state: shared-modified by threads #286, #287
+  Reason:    this thread, #287, holds no locks at all
+---------- short gran, 0 .. 98, skip 44 ----------
+
+Thread #288 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #289 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #288
+  New state: shared-modified by threads #288, #289
+  Reason:    this thread, #289, holds no locks at all
+---------- short gran, 1 .. 98, skip 45 ----------
+
+Thread #290 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #291 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #290
+  New state: shared-modified by threads #290, #291
+  Reason:    this thread, #291, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #290
+  New state: shared-modified by threads #290, #291
+  Reason:    this thread, #291, holds no locks at all
+---------- short gran, 0 .. 98, skip 46 ----------
+
+Thread #292 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #293 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #292
+  New state: shared-modified by threads #292, #293
+  Reason:    this thread, #293, holds no locks at all
+---------- short gran, 1 .. 98, skip 47 ----------
+
+Thread #294 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #295 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #294
+  New state: shared-modified by threads #294, #295
+  Reason:    this thread, #295, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #294
+  New state: shared-modified by threads #294, #295
+  Reason:    this thread, #295, holds no locks at all
+---------- short gran, 0 .. 98, skip 48 ----------
+
+Thread #296 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #297 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #296
+  New state: shared-modified by threads #296, #297
+  Reason:    this thread, #297, holds no locks at all
+---------- short gran, 1 .. 98, skip 49 ----------
+
+Thread #298 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #299 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #298
+  New state: shared-modified by threads #298, #299
+  Reason:    this thread, #299, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #298
+  New state: shared-modified by threads #298, #299
+  Reason:    this thread, #299, holds no locks at all
+---------- short gran, 0 .. 98, skip 50 ----------
+
+Thread #300 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #301 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #300
+  New state: shared-modified by threads #300, #301
+  Reason:    this thread, #301, holds no locks at all
+---------- short gran, 1 .. 98, skip 51 ----------
+
+Thread #302 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #303 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #302
+  New state: shared-modified by threads #302, #303
+  Reason:    this thread, #303, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #302
+  New state: shared-modified by threads #302, #303
+  Reason:    this thread, #303, holds no locks at all
+---------- short gran, 0 .. 98, skip 52 ----------
+
+Thread #304 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #305 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #304
+  New state: shared-modified by threads #304, #305
+  Reason:    this thread, #305, holds no locks at all
+---------- short gran, 1 .. 98, skip 53 ----------
+
+Thread #306 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #307 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #306
+  New state: shared-modified by threads #306, #307
+  Reason:    this thread, #307, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #306
+  New state: shared-modified by threads #306, #307
+  Reason:    this thread, #307, holds no locks at all
+---------- short gran, 0 .. 98, skip 54 ----------
+
+Thread #308 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #309 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #308
+  New state: shared-modified by threads #308, #309
+  Reason:    this thread, #309, holds no locks at all
+---------- short gran, 1 .. 98, skip 55 ----------
+
+Thread #310 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #311 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #310
+  New state: shared-modified by threads #310, #311
+  Reason:    this thread, #311, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #310
+  New state: shared-modified by threads #310, #311
+  Reason:    this thread, #311, holds no locks at all
+---------- short gran, 0 .. 98, skip 56 ----------
+
+Thread #312 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #313 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #312
+  New state: shared-modified by threads #312, #313
+  Reason:    this thread, #313, holds no locks at all
+---------- short gran, 1 .. 98, skip 57 ----------
+
+Thread #314 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #315 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #314
+  New state: shared-modified by threads #314, #315
+  Reason:    this thread, #315, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #314
+  New state: shared-modified by threads #314, #315
+  Reason:    this thread, #315, holds no locks at all
+---------- short gran, 0 .. 98, skip 58 ----------
+
+Thread #316 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #317 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #316
+  New state: shared-modified by threads #316, #317
+  Reason:    this thread, #317, holds no locks at all
+---------- short gran, 1 .. 98, skip 59 ----------
+
+Thread #318 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #319 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #318
+  New state: shared-modified by threads #318, #319
+  Reason:    this thread, #319, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #318
+  New state: shared-modified by threads #318, #319
+  Reason:    this thread, #319, holds no locks at all
+---------- short gran, 0 .. 98, skip 60 ----------
+
+Thread #320 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #321 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #320
+  New state: shared-modified by threads #320, #321
+  Reason:    this thread, #321, holds no locks at all
+---------- short gran, 1 .. 98, skip 61 ----------
+
+Thread #322 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #323 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #322
+  New state: shared-modified by threads #322, #323
+  Reason:    this thread, #323, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #322
+  New state: shared-modified by threads #322, #323
+  Reason:    this thread, #323, holds no locks at all
+---------- short gran, 0 .. 98, skip 62 ----------
+
+Thread #324 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #325 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #324
+  New state: shared-modified by threads #324, #325
+  Reason:    this thread, #325, holds no locks at all
+---------- short gran, 1 .. 98, skip 63 ----------
+
+Thread #326 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #327 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #326
+  New state: shared-modified by threads #326, #327
+  Reason:    this thread, #327, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #326
+  New state: shared-modified by threads #326, #327
+  Reason:    this thread, #327, holds no locks at all
+---------- short gran, 0 .. 98, skip 64 ----------
+
+Thread #328 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #329 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #328
+  New state: shared-modified by threads #328, #329
+  Reason:    this thread, #329, holds no locks at all
+---------- short gran, 1 .. 98, skip 65 ----------
+
+Thread #330 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #331 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #330
+  New state: shared-modified by threads #330, #331
+  Reason:    this thread, #331, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #330
+  New state: shared-modified by threads #330, #331
+  Reason:    this thread, #331, holds no locks at all
+---------- short gran, 0 .. 98, skip 66 ----------
+
+Thread #332 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #333 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #332
+  New state: shared-modified by threads #332, #333
+  Reason:    this thread, #333, holds no locks at all
+---------- short gran, 1 .. 98, skip 67 ----------
+
+Thread #334 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #335 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #334
+  New state: shared-modified by threads #334, #335
+  Reason:    this thread, #335, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #334
+  New state: shared-modified by threads #334, #335
+  Reason:    this thread, #335, holds no locks at all
+---------- short gran, 0 .. 98, skip 68 ----------
+
+Thread #336 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #337 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #336
+  New state: shared-modified by threads #336, #337
+  Reason:    this thread, #337, holds no locks at all
+---------- short gran, 1 .. 98, skip 69 ----------
+
+Thread #338 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #339 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #338
+  New state: shared-modified by threads #338, #339
+  Reason:    this thread, #339, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #338
+  New state: shared-modified by threads #338, #339
+  Reason:    this thread, #339, holds no locks at all
+---------- short gran, 0 .. 98, skip 70 ----------
+
+Thread #340 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #341 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #340
+  New state: shared-modified by threads #340, #341
+  Reason:    this thread, #341, holds no locks at all
+---------- short gran, 1 .. 98, skip 71 ----------
+
+Thread #342 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #343 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #342
+  New state: shared-modified by threads #342, #343
+  Reason:    this thread, #343, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #342
+  New state: shared-modified by threads #342, #343
+  Reason:    this thread, #343, holds no locks at all
+---------- short gran, 0 .. 98, skip 72 ----------
+
+Thread #344 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #345 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #344
+  New state: shared-modified by threads #344, #345
+  Reason:    this thread, #345, holds no locks at all
+---------- short gran, 1 .. 98, skip 73 ----------
+
+Thread #346 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #347 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #346
+  New state: shared-modified by threads #346, #347
+  Reason:    this thread, #347, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #346
+  New state: shared-modified by threads #346, #347
+  Reason:    this thread, #347, holds no locks at all
+---------- short gran, 0 .. 98, skip 74 ----------
+
+Thread #348 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #349 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #348
+  New state: shared-modified by threads #348, #349
+  Reason:    this thread, #349, holds no locks at all
+---------- short gran, 1 .. 98, skip 75 ----------
+
+Thread #350 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #351 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #350
+  New state: shared-modified by threads #350, #351
+  Reason:    this thread, #351, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #350
+  New state: shared-modified by threads #350, #351
+  Reason:    this thread, #351, holds no locks at all
+---------- short gran, 0 .. 98, skip 76 ----------
+
+Thread #352 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #353 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #352
+  New state: shared-modified by threads #352, #353
+  Reason:    this thread, #353, holds no locks at all
+---------- short gran, 1 .. 98, skip 77 ----------
+
+Thread #354 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #355 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #354
+  New state: shared-modified by threads #354, #355
+  Reason:    this thread, #355, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #354
+  New state: shared-modified by threads #354, #355
+  Reason:    this thread, #355, holds no locks at all
+---------- short gran, 0 .. 98, skip 78 ----------
+
+Thread #356 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #357 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #356
+  New state: shared-modified by threads #356, #357
+  Reason:    this thread, #357, holds no locks at all
+---------- short gran, 1 .. 98, skip 79 ----------
+
+Thread #358 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #359 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #358
+  New state: shared-modified by threads #358, #359
+  Reason:    this thread, #359, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #358
+  New state: shared-modified by threads #358, #359
+  Reason:    this thread, #359, holds no locks at all
+---------- short gran, 0 .. 98, skip 80 ----------
+
+Thread #360 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #361 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #360
+  New state: shared-modified by threads #360, #361
+  Reason:    this thread, #361, holds no locks at all
+---------- short gran, 1 .. 98, skip 81 ----------
+
+Thread #362 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #363 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #362
+  New state: shared-modified by threads #362, #363
+  Reason:    this thread, #363, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #362
+  New state: shared-modified by threads #362, #363
+  Reason:    this thread, #363, holds no locks at all
+---------- short gran, 0 .. 98, skip 82 ----------
+
+Thread #364 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #365 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #364
+  New state: shared-modified by threads #364, #365
+  Reason:    this thread, #365, holds no locks at all
+---------- short gran, 1 .. 98, skip 83 ----------
+
+Thread #366 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #367 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #366
+  New state: shared-modified by threads #366, #367
+  Reason:    this thread, #367, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #366
+  New state: shared-modified by threads #366, #367
+  Reason:    this thread, #367, holds no locks at all
+---------- short gran, 0 .. 98, skip 84 ----------
+
+Thread #368 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #369 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #368
+  New state: shared-modified by threads #368, #369
+  Reason:    this thread, #369, holds no locks at all
+---------- short gran, 1 .. 98, skip 85 ----------
+
+Thread #370 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #371 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #370
+  New state: shared-modified by threads #370, #371
+  Reason:    this thread, #371, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #370
+  New state: shared-modified by threads #370, #371
+  Reason:    this thread, #371, holds no locks at all
+---------- short gran, 0 .. 98, skip 86 ----------
+
+Thread #372 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #373 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #372
+  New state: shared-modified by threads #372, #373
+  Reason:    this thread, #373, holds no locks at all
+---------- short gran, 1 .. 98, skip 87 ----------
+
+Thread #374 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #375 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #374
+  New state: shared-modified by threads #374, #375
+  Reason:    this thread, #375, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #374
+  New state: shared-modified by threads #374, #375
+  Reason:    this thread, #375, holds no locks at all
+---------- short gran, 0 .. 98, skip 88 ----------
+
+Thread #376 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #377 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #376
+  New state: shared-modified by threads #376, #377
+  Reason:    this thread, #377, holds no locks at all
+---------- short gran, 1 .. 98, skip 89 ----------
+
+Thread #378 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #379 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #378
+  New state: shared-modified by threads #378, #379
+  Reason:    this thread, #379, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #378
+  New state: shared-modified by threads #378, #379
+  Reason:    this thread, #379, holds no locks at all
+---------- short gran, 0 .. 98, skip 90 ----------
+
+Thread #380 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #381 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #380
+  New state: shared-modified by threads #380, #381
+  Reason:    this thread, #381, holds no locks at all
+---------- short gran, 1 .. 98, skip 91 ----------
+
+Thread #382 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #383 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #382
+  New state: shared-modified by threads #382, #383
+  Reason:    this thread, #383, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #382
+  New state: shared-modified by threads #382, #383
+  Reason:    this thread, #383, holds no locks at all
+---------- short gran, 0 .. 98, skip 92 ----------
+
+Thread #384 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #385 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #384
+  New state: shared-modified by threads #384, #385
+  Reason:    this thread, #385, holds no locks at all
+---------- short gran, 1 .. 98, skip 93 ----------
+
+Thread #386 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #387 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #386
+  New state: shared-modified by threads #386, #387
+  Reason:    this thread, #387, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #386
+  New state: shared-modified by threads #386, #387
+  Reason:    this thread, #387, holds no locks at all
+---------- short gran, 0 .. 98, skip 94 ----------
+
+Thread #388 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #389 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #388
+  New state: shared-modified by threads #388, #389
+  Reason:    this thread, #389, holds no locks at all
+---------- short gran, 1 .. 98, skip 95 ----------
+
+Thread #390 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #391 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #390
+  New state: shared-modified by threads #390, #391
+  Reason:    this thread, #391, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #390
+  New state: shared-modified by threads #390, #391
+  Reason:    this thread, #391, holds no locks at all
+---------- short gran, 0 .. 98, skip 96 ----------
+
+Thread #392 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #393 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:480)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #392
+  New state: shared-modified by threads #392, #393
+  Reason:    this thread, #393, holds no locks at all
+---------- short gran, 1 .. 98, skip 97 ----------
+
+Thread #394 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #395 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #394
+  New state: shared-modified by threads #394, #395
+  Reason:    this thread, #395, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #394
+  New state: shared-modified by threads #394, #395
+  Reason:    this thread, #395, holds no locks at all
+
+==========================================================
+=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===
+==========================================================
+
+---------- int gran, 0 .. 96, skip 0 ----------
+
+Thread #396 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #397 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #396
+  New state: shared-modified by threads #396, #397
+  Reason:    this thread, #397, holds no locks at all
+---------- int gran, 1 .. 96, skip 1 ----------
+
+Thread #398 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #399 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+---------- int gran, 2 .. 96, skip 2 ----------
+
+Thread #400 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #401 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #400
+  New state: shared-modified by threads #400, #401
+  Reason:    this thread, #401, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #400
+  New state: shared-modified by threads #400, #401
+  Reason:    this thread, #401, holds no locks at all
+---------- int gran, 3 .. 96, skip 3 ----------
+
+Thread #402 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #403 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+---------- int gran, 0 .. 96, skip 4 ----------
+
+Thread #404 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #405 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #404
+  New state: shared-modified by threads #404, #405
+  Reason:    this thread, #405, holds no locks at all
+---------- int gran, 1 .. 96, skip 5 ----------
+
+Thread #406 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #407 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+---------- int gran, 2 .. 96, skip 6 ----------
+
+Thread #408 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #409 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #408
+  New state: shared-modified by threads #408, #409
+  Reason:    this thread, #409, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #408
+  New state: shared-modified by threads #408, #409
+  Reason:    this thread, #409, holds no locks at all
+---------- int gran, 3 .. 96, skip 7 ----------
+
+Thread #410 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #411 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+---------- int gran, 0 .. 96, skip 8 ----------
+
+Thread #412 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #413 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #412
+  New state: shared-modified by threads #412, #413
+  Reason:    this thread, #413, holds no locks at all
+---------- int gran, 1 .. 96, skip 9 ----------
+
+Thread #414 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #415 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+---------- int gran, 2 .. 96, skip 10 ----------
+
+Thread #416 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #417 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #416
+  New state: shared-modified by threads #416, #417
+  Reason:    this thread, #417, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #416
+  New state: shared-modified by threads #416, #417
+  Reason:    this thread, #417, holds no locks at all
+---------- int gran, 3 .. 96, skip 11 ----------
+
+Thread #418 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #419 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+---------- int gran, 0 .. 96, skip 12 ----------
+
+Thread #420 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #421 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #420
+  New state: shared-modified by threads #420, #421
+  Reason:    this thread, #421, holds no locks at all
+---------- int gran, 1 .. 96, skip 13 ----------
+
+Thread #422 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #423 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+---------- int gran, 2 .. 96, skip 14 ----------
+
+Thread #424 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #425 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #424
+  New state: shared-modified by threads #424, #425
+  Reason:    this thread, #425, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #424
+  New state: shared-modified by threads #424, #425
+  Reason:    this thread, #425, holds no locks at all
+---------- int gran, 3 .. 96, skip 15 ----------
+
+Thread #426 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #427 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+---------- int gran, 0 .. 96, skip 16 ----------
+
+Thread #428 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #429 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #428
+  New state: shared-modified by threads #428, #429
+  Reason:    this thread, #429, holds no locks at all
+---------- int gran, 1 .. 96, skip 17 ----------
+
+Thread #430 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #431 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+---------- int gran, 2 .. 96, skip 18 ----------
+
+Thread #432 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #433 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #432
+  New state: shared-modified by threads #432, #433
+  Reason:    this thread, #433, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #432
+  New state: shared-modified by threads #432, #433
+  Reason:    this thread, #433, holds no locks at all
+---------- int gran, 3 .. 96, skip 19 ----------
+
+Thread #434 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #435 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+---------- int gran, 0 .. 96, skip 20 ----------
+
+Thread #436 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #437 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #436
+  New state: shared-modified by threads #436, #437
+  Reason:    this thread, #437, holds no locks at all
+---------- int gran, 1 .. 96, skip 21 ----------
+
+Thread #438 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #439 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+---------- int gran, 2 .. 96, skip 22 ----------
+
+Thread #440 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #441 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #440
+  New state: shared-modified by threads #440, #441
+  Reason:    this thread, #441, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #440
+  New state: shared-modified by threads #440, #441
+  Reason:    this thread, #441, holds no locks at all
+---------- int gran, 3 .. 96, skip 23 ----------
+
+Thread #442 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #443 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+---------- int gran, 0 .. 96, skip 24 ----------
+
+Thread #444 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #445 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #444
+  New state: shared-modified by threads #444, #445
+  Reason:    this thread, #445, holds no locks at all
+---------- int gran, 1 .. 96, skip 25 ----------
+
+Thread #446 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #447 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+---------- int gran, 2 .. 96, skip 26 ----------
+
+Thread #448 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #449 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #448
+  New state: shared-modified by threads #448, #449
+  Reason:    this thread, #449, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #448
+  New state: shared-modified by threads #448, #449
+  Reason:    this thread, #449, holds no locks at all
+---------- int gran, 3 .. 96, skip 27 ----------
+
+Thread #450 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #451 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+---------- int gran, 0 .. 96, skip 28 ----------
+
+Thread #452 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #453 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #452
+  New state: shared-modified by threads #452, #453
+  Reason:    this thread, #453, holds no locks at all
+---------- int gran, 1 .. 96, skip 29 ----------
+
+Thread #454 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #455 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+---------- int gran, 2 .. 96, skip 30 ----------
+
+Thread #456 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #457 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #456
+  New state: shared-modified by threads #456, #457
+  Reason:    this thread, #457, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #456
+  New state: shared-modified by threads #456, #457
+  Reason:    this thread, #457, holds no locks at all
+---------- int gran, 3 .. 96, skip 31 ----------
+
+Thread #458 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #459 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+---------- int gran, 0 .. 96, skip 32 ----------
+
+Thread #460 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #461 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #460
+  New state: shared-modified by threads #460, #461
+  Reason:    this thread, #461, holds no locks at all
+---------- int gran, 1 .. 96, skip 33 ----------
+
+Thread #462 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #463 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+---------- int gran, 2 .. 96, skip 34 ----------
+
+Thread #464 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #465 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #464
+  New state: shared-modified by threads #464, #465
+  Reason:    this thread, #465, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #464
+  New state: shared-modified by threads #464, #465
+  Reason:    this thread, #465, holds no locks at all
+---------- int gran, 3 .. 96, skip 35 ----------
+
+Thread #466 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #467 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+---------- int gran, 0 .. 96, skip 36 ----------
+
+Thread #468 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #469 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #468
+  New state: shared-modified by threads #468, #469
+  Reason:    this thread, #469, holds no locks at all
+---------- int gran, 1 .. 96, skip 37 ----------
+
+Thread #470 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #471 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+---------- int gran, 2 .. 96, skip 38 ----------
+
+Thread #472 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #473 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #472
+  New state: shared-modified by threads #472, #473
+  Reason:    this thread, #473, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #472
+  New state: shared-modified by threads #472, #473
+  Reason:    this thread, #473, holds no locks at all
+---------- int gran, 3 .. 96, skip 39 ----------
+
+Thread #474 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #475 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+---------- int gran, 0 .. 96, skip 40 ----------
+
+Thread #476 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #477 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #476
+  New state: shared-modified by threads #476, #477
+  Reason:    this thread, #477, holds no locks at all
+---------- int gran, 1 .. 96, skip 41 ----------
+
+Thread #478 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #479 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+---------- int gran, 2 .. 96, skip 42 ----------
+
+Thread #480 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #481 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #480
+  New state: shared-modified by threads #480, #481
+  Reason:    this thread, #481, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #480
+  New state: shared-modified by threads #480, #481
+  Reason:    this thread, #481, holds no locks at all
+---------- int gran, 3 .. 96, skip 43 ----------
+
+Thread #482 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #483 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+---------- int gran, 0 .. 96, skip 44 ----------
+
+Thread #484 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #485 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #484
+  New state: shared-modified by threads #484, #485
+  Reason:    this thread, #485, holds no locks at all
+---------- int gran, 1 .. 96, skip 45 ----------
+
+Thread #486 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #487 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+---------- int gran, 2 .. 96, skip 46 ----------
+
+Thread #488 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #489 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #488
+  New state: shared-modified by threads #488, #489
+  Reason:    this thread, #489, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #488
+  New state: shared-modified by threads #488, #489
+  Reason:    this thread, #489, holds no locks at all
+---------- int gran, 3 .. 96, skip 47 ----------
+
+Thread #490 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #491 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+---------- int gran, 0 .. 96, skip 48 ----------
+
+Thread #492 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #493 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #492
+  New state: shared-modified by threads #492, #493
+  Reason:    this thread, #493, holds no locks at all
+---------- int gran, 1 .. 96, skip 49 ----------
+
+Thread #494 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #495 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+---------- int gran, 2 .. 96, skip 50 ----------
+
+Thread #496 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #497 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #496
+  New state: shared-modified by threads #496, #497
+  Reason:    this thread, #497, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #496
+  New state: shared-modified by threads #496, #497
+  Reason:    this thread, #497, holds no locks at all
+---------- int gran, 3 .. 96, skip 51 ----------
+
+Thread #498 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #499 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+---------- int gran, 0 .. 96, skip 52 ----------
+
+Thread #500 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #501 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #500
+  New state: shared-modified by threads #500, #501
+  Reason:    this thread, #501, holds no locks at all
+---------- int gran, 1 .. 96, skip 53 ----------
+
+Thread #502 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #503 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+---------- int gran, 2 .. 96, skip 54 ----------
+
+Thread #504 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #505 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #504
+  New state: shared-modified by threads #504, #505
+  Reason:    this thread, #505, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #504
+  New state: shared-modified by threads #504, #505
+  Reason:    this thread, #505, holds no locks at all
+---------- int gran, 3 .. 96, skip 55 ----------
+
+Thread #506 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #507 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+---------- int gran, 0 .. 96, skip 56 ----------
+
+Thread #508 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #509 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #508
+  New state: shared-modified by threads #508, #509
+  Reason:    this thread, #509, holds no locks at all
+---------- int gran, 1 .. 96, skip 57 ----------
+
+Thread #510 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #511 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+---------- int gran, 2 .. 96, skip 58 ----------
+
+Thread #512 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #513 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #512
+  New state: shared-modified by threads #512, #513
+  Reason:    this thread, #513, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #512
+  New state: shared-modified by threads #512, #513
+  Reason:    this thread, #513, holds no locks at all
+---------- int gran, 3 .. 96, skip 59 ----------
+
+Thread #514 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #515 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+---------- int gran, 0 .. 96, skip 60 ----------
+
+Thread #516 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #517 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #516
+  New state: shared-modified by threads #516, #517
+  Reason:    this thread, #517, holds no locks at all
+---------- int gran, 1 .. 96, skip 61 ----------
+
+Thread #518 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #519 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+---------- int gran, 2 .. 96, skip 62 ----------
+
+Thread #520 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #521 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #520
+  New state: shared-modified by threads #520, #521
+  Reason:    this thread, #521, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #520
+  New state: shared-modified by threads #520, #521
+  Reason:    this thread, #521, holds no locks at all
+---------- int gran, 3 .. 96, skip 63 ----------
+
+Thread #522 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #523 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+---------- int gran, 0 .. 96, skip 64 ----------
+
+Thread #524 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #525 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #524
+  New state: shared-modified by threads #524, #525
+  Reason:    this thread, #525, holds no locks at all
+---------- int gran, 1 .. 96, skip 65 ----------
+
+Thread #526 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #527 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+---------- int gran, 2 .. 96, skip 66 ----------
+
+Thread #528 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #529 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #528
+  New state: shared-modified by threads #528, #529
+  Reason:    this thread, #529, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #528
+  New state: shared-modified by threads #528, #529
+  Reason:    this thread, #529, holds no locks at all
+---------- int gran, 3 .. 96, skip 67 ----------
+
+Thread #530 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #531 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+---------- int gran, 0 .. 96, skip 68 ----------
+
+Thread #532 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #533 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #532
+  New state: shared-modified by threads #532, #533
+  Reason:    this thread, #533, holds no locks at all
+---------- int gran, 1 .. 96, skip 69 ----------
+
+Thread #534 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #535 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+---------- int gran, 2 .. 96, skip 70 ----------
+
+Thread #536 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #537 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #536
+  New state: shared-modified by threads #536, #537
+  Reason:    this thread, #537, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #536
+  New state: shared-modified by threads #536, #537
+  Reason:    this thread, #537, holds no locks at all
+---------- int gran, 3 .. 96, skip 71 ----------
+
+Thread #538 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #539 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+---------- int gran, 0 .. 96, skip 72 ----------
+
+Thread #540 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #541 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #540
+  New state: shared-modified by threads #540, #541
+  Reason:    this thread, #541, holds no locks at all
+---------- int gran, 1 .. 96, skip 73 ----------
+
+Thread #542 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #543 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+---------- int gran, 2 .. 96, skip 74 ----------
+
+Thread #544 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #545 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #544
+  New state: shared-modified by threads #544, #545
+  Reason:    this thread, #545, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #544
+  New state: shared-modified by threads #544, #545
+  Reason:    this thread, #545, holds no locks at all
+---------- int gran, 3 .. 96, skip 75 ----------
+
+Thread #546 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #547 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+---------- int gran, 0 .. 96, skip 76 ----------
+
+Thread #548 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #549 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #548
+  New state: shared-modified by threads #548, #549
+  Reason:    this thread, #549, holds no locks at all
+---------- int gran, 1 .. 96, skip 77 ----------
+
+Thread #550 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #551 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+---------- int gran, 2 .. 96, skip 78 ----------
+
+Thread #552 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #553 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #552
+  New state: shared-modified by threads #552, #553
+  Reason:    this thread, #553, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #552
+  New state: shared-modified by threads #552, #553
+  Reason:    this thread, #553, holds no locks at all
+---------- int gran, 3 .. 96, skip 79 ----------
+
+Thread #554 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #555 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+---------- int gran, 0 .. 96, skip 80 ----------
+
+Thread #556 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #557 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #556
+  New state: shared-modified by threads #556, #557
+  Reason:    this thread, #557, holds no locks at all
+---------- int gran, 1 .. 96, skip 81 ----------
+
+Thread #558 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #559 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+---------- int gran, 2 .. 96, skip 82 ----------
+
+Thread #560 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #561 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #560
+  New state: shared-modified by threads #560, #561
+  Reason:    this thread, #561, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #560
+  New state: shared-modified by threads #560, #561
+  Reason:    this thread, #561, holds no locks at all
+---------- int gran, 3 .. 96, skip 83 ----------
+
+Thread #562 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #563 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+---------- int gran, 0 .. 96, skip 84 ----------
+
+Thread #564 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #565 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #564
+  New state: shared-modified by threads #564, #565
+  Reason:    this thread, #565, holds no locks at all
+---------- int gran, 1 .. 96, skip 85 ----------
+
+Thread #566 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #567 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+---------- int gran, 2 .. 96, skip 86 ----------
+
+Thread #568 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #569 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #568
+  New state: shared-modified by threads #568, #569
+  Reason:    this thread, #569, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #568
+  New state: shared-modified by threads #568, #569
+  Reason:    this thread, #569, holds no locks at all
+---------- int gran, 3 .. 96, skip 87 ----------
+
+Thread #570 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #571 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+---------- int gran, 0 .. 96, skip 88 ----------
+
+Thread #572 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #573 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #572
+  New state: shared-modified by threads #572, #573
+  Reason:    this thread, #573, holds no locks at all
+---------- int gran, 1 .. 96, skip 89 ----------
+
+Thread #574 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #575 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+---------- int gran, 2 .. 96, skip 90 ----------
+
+Thread #576 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #577 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #576
+  New state: shared-modified by threads #576, #577
+  Reason:    this thread, #577, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #576
+  New state: shared-modified by threads #576, #577
+  Reason:    this thread, #577, holds no locks at all
+---------- int gran, 3 .. 96, skip 91 ----------
+
+Thread #578 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #579 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+---------- int gran, 0 .. 96, skip 92 ----------
+
+Thread #580 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #581 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #580
+  New state: shared-modified by threads #580, #581
+  Reason:    this thread, #581, holds no locks at all
+---------- int gran, 1 .. 96, skip 93 ----------
+
+Thread #582 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #583 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+---------- int gran, 2 .. 96, skip 94 ----------
+
+Thread #584 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #585 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #584
+  New state: shared-modified by threads #584, #585
+  Reason:    this thread, #585, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #584
+  New state: shared-modified by threads #584, #585
+  Reason:    this thread, #585, holds no locks at all
+---------- int gran, 3 .. 96, skip 95 ----------
+
+Thread #586 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #587 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+==========================================================
+=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===
+==========================================================
+
+---------- double gran, 0 .. 92, skip 0 ----------
+
+Thread #588 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #589 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #588
+  New state: shared-modified by threads #588, #589
+  Reason:    this thread, #589, holds no locks at all
+---------- double gran, 1 .. 92, skip 1 ----------
+
+Thread #590 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #591 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+---------- double gran, 2 .. 92, skip 2 ----------
+
+Thread #592 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #593 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+---------- double gran, 3 .. 92, skip 3 ----------
+
+Thread #594 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #595 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+---------- double gran, 4 .. 92, skip 4 ----------
+
+Thread #596 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #597 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #596
+  New state: shared-modified by threads #596, #597
+  Reason:    this thread, #597, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #596
+  New state: shared-modified by threads #596, #597
+  Reason:    this thread, #597, holds no locks at all
+---------- double gran, 5 .. 92, skip 5 ----------
+
+Thread #598 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #599 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+---------- double gran, 6 .. 92, skip 6 ----------
+
+Thread #600 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #601 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+---------- double gran, 7 .. 92, skip 7 ----------
+
+Thread #602 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #603 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+---------- double gran, 0 .. 92, skip 8 ----------
+
+Thread #604 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #605 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #604
+  New state: shared-modified by threads #604, #605
+  Reason:    this thread, #605, holds no locks at all
+---------- double gran, 1 .. 92, skip 9 ----------
+
+Thread #606 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #607 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+---------- double gran, 2 .. 92, skip 10 ----------
+
+Thread #608 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #609 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+---------- double gran, 3 .. 92, skip 11 ----------
+
+Thread #610 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #611 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+---------- double gran, 4 .. 92, skip 12 ----------
+
+Thread #612 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #613 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #612
+  New state: shared-modified by threads #612, #613
+  Reason:    this thread, #613, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #612
+  New state: shared-modified by threads #612, #613
+  Reason:    this thread, #613, holds no locks at all
+---------- double gran, 5 .. 92, skip 13 ----------
+
+Thread #614 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #615 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+---------- double gran, 6 .. 92, skip 14 ----------
+
+Thread #616 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #617 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+---------- double gran, 7 .. 92, skip 15 ----------
+
+Thread #618 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #619 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+---------- double gran, 0 .. 92, skip 16 ----------
+
+Thread #620 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #621 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #620
+  New state: shared-modified by threads #620, #621
+  Reason:    this thread, #621, holds no locks at all
+---------- double gran, 1 .. 92, skip 17 ----------
+
+Thread #622 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #623 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+---------- double gran, 2 .. 92, skip 18 ----------
+
+Thread #624 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #625 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+---------- double gran, 3 .. 92, skip 19 ----------
+
+Thread #626 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #627 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+---------- double gran, 4 .. 92, skip 20 ----------
+
+Thread #628 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #629 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #628
+  New state: shared-modified by threads #628, #629
+  Reason:    this thread, #629, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #628
+  New state: shared-modified by threads #628, #629
+  Reason:    this thread, #629, holds no locks at all
+---------- double gran, 5 .. 92, skip 21 ----------
+
+Thread #630 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #631 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+---------- double gran, 6 .. 92, skip 22 ----------
+
+Thread #632 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #633 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+---------- double gran, 7 .. 92, skip 23 ----------
+
+Thread #634 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #635 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+---------- double gran, 0 .. 92, skip 24 ----------
+
+Thread #636 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #637 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #636
+  New state: shared-modified by threads #636, #637
+  Reason:    this thread, #637, holds no locks at all
+---------- double gran, 1 .. 92, skip 25 ----------
+
+Thread #638 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #639 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+---------- double gran, 2 .. 92, skip 26 ----------
+
+Thread #640 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #641 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+---------- double gran, 3 .. 92, skip 27 ----------
+
+Thread #642 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #643 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+---------- double gran, 4 .. 92, skip 28 ----------
+
+Thread #644 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #645 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #644
+  New state: shared-modified by threads #644, #645
+  Reason:    this thread, #645, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #644
+  New state: shared-modified by threads #644, #645
+  Reason:    this thread, #645, holds no locks at all
+---------- double gran, 5 .. 92, skip 29 ----------
+
+Thread #646 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #647 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+---------- double gran, 6 .. 92, skip 30 ----------
+
+Thread #648 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #649 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+---------- double gran, 7 .. 92, skip 31 ----------
+
+Thread #650 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #651 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+---------- double gran, 0 .. 92, skip 32 ----------
+
+Thread #652 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #653 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #652
+  New state: shared-modified by threads #652, #653
+  Reason:    this thread, #653, holds no locks at all
+---------- double gran, 1 .. 92, skip 33 ----------
+
+Thread #654 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #655 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+---------- double gran, 2 .. 92, skip 34 ----------
+
+Thread #656 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #657 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+---------- double gran, 3 .. 92, skip 35 ----------
+
+Thread #658 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #659 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+---------- double gran, 4 .. 92, skip 36 ----------
+
+Thread #660 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #661 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #660
+  New state: shared-modified by threads #660, #661
+  Reason:    this thread, #661, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #660
+  New state: shared-modified by threads #660, #661
+  Reason:    this thread, #661, holds no locks at all
+---------- double gran, 5 .. 92, skip 37 ----------
+
+Thread #662 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #663 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+---------- double gran, 6 .. 92, skip 38 ----------
+
+Thread #664 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #665 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+---------- double gran, 7 .. 92, skip 39 ----------
+
+Thread #666 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #667 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+---------- double gran, 0 .. 92, skip 40 ----------
+
+Thread #668 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #669 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #668
+  New state: shared-modified by threads #668, #669
+  Reason:    this thread, #669, holds no locks at all
+---------- double gran, 1 .. 92, skip 41 ----------
+
+Thread #670 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #671 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+---------- double gran, 2 .. 92, skip 42 ----------
+
+Thread #672 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #673 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+---------- double gran, 3 .. 92, skip 43 ----------
+
+Thread #674 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #675 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+---------- double gran, 4 .. 92, skip 44 ----------
+
+Thread #676 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #677 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #676
+  New state: shared-modified by threads #676, #677
+  Reason:    this thread, #677, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #676
+  New state: shared-modified by threads #676, #677
+  Reason:    this thread, #677, holds no locks at all
+---------- double gran, 5 .. 92, skip 45 ----------
+
+Thread #678 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #679 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+---------- double gran, 6 .. 92, skip 46 ----------
+
+Thread #680 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #681 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+---------- double gran, 7 .. 92, skip 47 ----------
+
+Thread #682 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #683 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+---------- double gran, 0 .. 92, skip 48 ----------
+
+Thread #684 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #685 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #684
+  New state: shared-modified by threads #684, #685
+  Reason:    this thread, #685, holds no locks at all
+---------- double gran, 1 .. 92, skip 49 ----------
+
+Thread #686 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #687 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+---------- double gran, 2 .. 92, skip 50 ----------
+
+Thread #688 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #689 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+---------- double gran, 3 .. 92, skip 51 ----------
+
+Thread #690 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #691 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+---------- double gran, 4 .. 92, skip 52 ----------
+
+Thread #692 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #693 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #692
+  New state: shared-modified by threads #692, #693
+  Reason:    this thread, #693, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #692
+  New state: shared-modified by threads #692, #693
+  Reason:    this thread, #693, holds no locks at all
+---------- double gran, 5 .. 92, skip 53 ----------
+
+Thread #694 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #695 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+---------- double gran, 6 .. 92, skip 54 ----------
+
+Thread #696 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #697 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+---------- double gran, 7 .. 92, skip 55 ----------
+
+Thread #698 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #699 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+---------- double gran, 0 .. 92, skip 56 ----------
+
+Thread #700 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #701 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #700
+  New state: shared-modified by threads #700, #701
+  Reason:    this thread, #701, holds no locks at all
+---------- double gran, 1 .. 92, skip 57 ----------
+
+Thread #702 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #703 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+---------- double gran, 2 .. 92, skip 58 ----------
+
+Thread #704 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #705 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+---------- double gran, 3 .. 92, skip 59 ----------
+
+Thread #706 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #707 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+---------- double gran, 4 .. 92, skip 60 ----------
+
+Thread #708 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #709 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #708
+  New state: shared-modified by threads #708, #709
+  Reason:    this thread, #709, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #708
+  New state: shared-modified by threads #708, #709
+  Reason:    this thread, #709, holds no locks at all
+---------- double gran, 5 .. 92, skip 61 ----------
+
+Thread #710 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #711 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+---------- double gran, 6 .. 92, skip 62 ----------
+
+Thread #712 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #713 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+---------- double gran, 7 .. 92, skip 63 ----------
+
+Thread #714 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #715 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+---------- double gran, 0 .. 92, skip 64 ----------
+
+Thread #716 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #717 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #716
+  New state: shared-modified by threads #716, #717
+  Reason:    this thread, #717, holds no locks at all
+---------- double gran, 1 .. 92, skip 65 ----------
+
+Thread #718 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #719 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+---------- double gran, 2 .. 92, skip 66 ----------
+
+Thread #720 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #721 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+---------- double gran, 3 .. 92, skip 67 ----------
+
+Thread #722 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #723 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+---------- double gran, 4 .. 92, skip 68 ----------
+
+Thread #724 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #725 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #724
+  New state: shared-modified by threads #724, #725
+  Reason:    this thread, #725, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #724
+  New state: shared-modified by threads #724, #725
+  Reason:    this thread, #725, holds no locks at all
+---------- double gran, 5 .. 92, skip 69 ----------
+
+Thread #726 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #727 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+---------- double gran, 6 .. 92, skip 70 ----------
+
+Thread #728 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #729 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+---------- double gran, 7 .. 92, skip 71 ----------
+
+Thread #730 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #731 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+---------- double gran, 0 .. 92, skip 72 ----------
+
+Thread #732 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #733 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #732
+  New state: shared-modified by threads #732, #733
+  Reason:    this thread, #733, holds no locks at all
+---------- double gran, 1 .. 92, skip 73 ----------
+
+Thread #734 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #735 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+---------- double gran, 2 .. 92, skip 74 ----------
+
+Thread #736 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #737 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+---------- double gran, 3 .. 92, skip 75 ----------
+
+Thread #738 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #739 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+---------- double gran, 4 .. 92, skip 76 ----------
+
+Thread #740 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #741 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #740
+  New state: shared-modified by threads #740, #741
+  Reason:    this thread, #741, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #740
+  New state: shared-modified by threads #740, #741
+  Reason:    this thread, #741, holds no locks at all
+---------- double gran, 5 .. 92, skip 77 ----------
+
+Thread #742 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #743 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+---------- double gran, 6 .. 92, skip 78 ----------
+
+Thread #744 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #745 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+---------- double gran, 7 .. 92, skip 79 ----------
+
+Thread #746 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #747 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+---------- double gran, 0 .. 92, skip 80 ----------
+
+Thread #748 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #749 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #748
+  New state: shared-modified by threads #748, #749
+  Reason:    this thread, #749, holds no locks at all
+---------- double gran, 1 .. 92, skip 81 ----------
+
+Thread #750 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #751 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+---------- double gran, 2 .. 92, skip 82 ----------
+
+Thread #752 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #753 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+---------- double gran, 3 .. 92, skip 83 ----------
+
+Thread #754 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #755 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+---------- double gran, 4 .. 92, skip 84 ----------
+
+Thread #756 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #757 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #756
+  New state: shared-modified by threads #756, #757
+  Reason:    this thread, #757, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #756
+  New state: shared-modified by threads #756, #757
+  Reason:    this thread, #757, holds no locks at all
+---------- double gran, 5 .. 92, skip 85 ----------
+
+Thread #758 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #759 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+---------- double gran, 6 .. 92, skip 86 ----------
+
+Thread #760 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #761 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+---------- double gran, 7 .. 92, skip 87 ----------
+
+Thread #762 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #763 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+---------- double gran, 0 .. 92, skip 88 ----------
+
+Thread #764 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #765 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #764
+  New state: shared-modified by threads #764, #765
+  Reason:    this thread, #765, holds no locks at all
+---------- double gran, 1 .. 92, skip 89 ----------
+
+Thread #766 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #767 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+---------- double gran, 2 .. 92, skip 90 ----------
+
+Thread #768 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #769 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+---------- double gran, 3 .. 92, skip 91 ----------
+
+Thread #770 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #771 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+ERROR SUMMARY: 1004 errors from 1004 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86 b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..efa6730
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stderr.exp-glibc25-x86
@@ -0,0 +1,15070 @@
+
+
+===========================================================
+=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===
+===========================================================
+
+---------- char gran, 0 .. 99, skip 0 ----------
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #2
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no locks at all
+---------- char gran, 0 .. 99, skip 1 ----------
+
+Thread #4 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #5 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #4
+  New state: shared-modified by threads #4, #5
+  Reason:    this thread, #5, holds no locks at all
+---------- char gran, 0 .. 99, skip 2 ----------
+
+Thread #6 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #7 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #6
+  New state: shared-modified by threads #6, #7
+  Reason:    this thread, #7, holds no locks at all
+---------- char gran, 0 .. 99, skip 3 ----------
+
+Thread #8 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #9 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #8
+  New state: shared-modified by threads #8, #9
+  Reason:    this thread, #9, holds no locks at all
+---------- char gran, 0 .. 99, skip 4 ----------
+
+Thread #10 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #11 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #10
+  New state: shared-modified by threads #10, #11
+  Reason:    this thread, #11, holds no locks at all
+---------- char gran, 0 .. 99, skip 5 ----------
+
+Thread #12 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #13 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #12
+  New state: shared-modified by threads #12, #13
+  Reason:    this thread, #13, holds no locks at all
+---------- char gran, 0 .. 99, skip 6 ----------
+
+Thread #14 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #15 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #14
+  New state: shared-modified by threads #14, #15
+  Reason:    this thread, #15, holds no locks at all
+---------- char gran, 0 .. 99, skip 7 ----------
+
+Thread #16 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #17 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #16
+  New state: shared-modified by threads #16, #17
+  Reason:    this thread, #17, holds no locks at all
+---------- char gran, 0 .. 99, skip 8 ----------
+
+Thread #18 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #19 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #18
+  New state: shared-modified by threads #18, #19
+  Reason:    this thread, #19, holds no locks at all
+---------- char gran, 0 .. 99, skip 9 ----------
+
+Thread #20 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #21 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #20
+  New state: shared-modified by threads #20, #21
+  Reason:    this thread, #21, holds no locks at all
+---------- char gran, 0 .. 99, skip 10 ----------
+
+Thread #22 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #23 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #22
+  New state: shared-modified by threads #22, #23
+  Reason:    this thread, #23, holds no locks at all
+---------- char gran, 0 .. 99, skip 11 ----------
+
+Thread #24 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #25 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #24
+  New state: shared-modified by threads #24, #25
+  Reason:    this thread, #25, holds no locks at all
+---------- char gran, 0 .. 99, skip 12 ----------
+
+Thread #26 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #27 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #26
+  New state: shared-modified by threads #26, #27
+  Reason:    this thread, #27, holds no locks at all
+---------- char gran, 0 .. 99, skip 13 ----------
+
+Thread #28 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #29 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #28
+  New state: shared-modified by threads #28, #29
+  Reason:    this thread, #29, holds no locks at all
+---------- char gran, 0 .. 99, skip 14 ----------
+
+Thread #30 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #31 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #30
+  New state: shared-modified by threads #30, #31
+  Reason:    this thread, #31, holds no locks at all
+---------- char gran, 0 .. 99, skip 15 ----------
+
+Thread #32 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #33 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #32
+  New state: shared-modified by threads #32, #33
+  Reason:    this thread, #33, holds no locks at all
+---------- char gran, 0 .. 99, skip 16 ----------
+
+Thread #34 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #35 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #34
+  New state: shared-modified by threads #34, #35
+  Reason:    this thread, #35, holds no locks at all
+---------- char gran, 0 .. 99, skip 17 ----------
+
+Thread #36 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #37 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #36
+  New state: shared-modified by threads #36, #37
+  Reason:    this thread, #37, holds no locks at all
+---------- char gran, 0 .. 99, skip 18 ----------
+
+Thread #38 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #39 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #38
+  New state: shared-modified by threads #38, #39
+  Reason:    this thread, #39, holds no locks at all
+---------- char gran, 0 .. 99, skip 19 ----------
+
+Thread #40 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #41 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #40
+  New state: shared-modified by threads #40, #41
+  Reason:    this thread, #41, holds no locks at all
+---------- char gran, 0 .. 99, skip 20 ----------
+
+Thread #42 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #43 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #42
+  New state: shared-modified by threads #42, #43
+  Reason:    this thread, #43, holds no locks at all
+---------- char gran, 0 .. 99, skip 21 ----------
+
+Thread #44 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #45 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #44
+  New state: shared-modified by threads #44, #45
+  Reason:    this thread, #45, holds no locks at all
+---------- char gran, 0 .. 99, skip 22 ----------
+
+Thread #46 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #47 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #46
+  New state: shared-modified by threads #46, #47
+  Reason:    this thread, #47, holds no locks at all
+---------- char gran, 0 .. 99, skip 23 ----------
+
+Thread #48 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #49 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #48
+  New state: shared-modified by threads #48, #49
+  Reason:    this thread, #49, holds no locks at all
+---------- char gran, 0 .. 99, skip 24 ----------
+
+Thread #50 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #51 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #50
+  New state: shared-modified by threads #50, #51
+  Reason:    this thread, #51, holds no locks at all
+---------- char gran, 0 .. 99, skip 25 ----------
+
+Thread #52 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #53 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #52
+  New state: shared-modified by threads #52, #53
+  Reason:    this thread, #53, holds no locks at all
+---------- char gran, 0 .. 99, skip 26 ----------
+
+Thread #54 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #55 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #54
+  New state: shared-modified by threads #54, #55
+  Reason:    this thread, #55, holds no locks at all
+---------- char gran, 0 .. 99, skip 27 ----------
+
+Thread #56 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #57 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #56
+  New state: shared-modified by threads #56, #57
+  Reason:    this thread, #57, holds no locks at all
+---------- char gran, 0 .. 99, skip 28 ----------
+
+Thread #58 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #59 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #58
+  New state: shared-modified by threads #58, #59
+  Reason:    this thread, #59, holds no locks at all
+---------- char gran, 0 .. 99, skip 29 ----------
+
+Thread #60 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #61 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #60
+  New state: shared-modified by threads #60, #61
+  Reason:    this thread, #61, holds no locks at all
+---------- char gran, 0 .. 99, skip 30 ----------
+
+Thread #62 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #63 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #62
+  New state: shared-modified by threads #62, #63
+  Reason:    this thread, #63, holds no locks at all
+---------- char gran, 0 .. 99, skip 31 ----------
+
+Thread #64 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #65 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #64
+  New state: shared-modified by threads #64, #65
+  Reason:    this thread, #65, holds no locks at all
+---------- char gran, 0 .. 99, skip 32 ----------
+
+Thread #66 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #67 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #66
+  New state: shared-modified by threads #66, #67
+  Reason:    this thread, #67, holds no locks at all
+---------- char gran, 0 .. 99, skip 33 ----------
+
+Thread #68 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #69 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #68
+  New state: shared-modified by threads #68, #69
+  Reason:    this thread, #69, holds no locks at all
+---------- char gran, 0 .. 99, skip 34 ----------
+
+Thread #70 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #71 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #70
+  New state: shared-modified by threads #70, #71
+  Reason:    this thread, #71, holds no locks at all
+---------- char gran, 0 .. 99, skip 35 ----------
+
+Thread #72 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #73 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #72
+  New state: shared-modified by threads #72, #73
+  Reason:    this thread, #73, holds no locks at all
+---------- char gran, 0 .. 99, skip 36 ----------
+
+Thread #74 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #75 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #74
+  New state: shared-modified by threads #74, #75
+  Reason:    this thread, #75, holds no locks at all
+---------- char gran, 0 .. 99, skip 37 ----------
+
+Thread #76 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #77 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #76
+  New state: shared-modified by threads #76, #77
+  Reason:    this thread, #77, holds no locks at all
+---------- char gran, 0 .. 99, skip 38 ----------
+
+Thread #78 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #79 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #78
+  New state: shared-modified by threads #78, #79
+  Reason:    this thread, #79, holds no locks at all
+---------- char gran, 0 .. 99, skip 39 ----------
+
+Thread #80 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #81 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #80
+  New state: shared-modified by threads #80, #81
+  Reason:    this thread, #81, holds no locks at all
+---------- char gran, 0 .. 99, skip 40 ----------
+
+Thread #82 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #83 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #82
+  New state: shared-modified by threads #82, #83
+  Reason:    this thread, #83, holds no locks at all
+---------- char gran, 0 .. 99, skip 41 ----------
+
+Thread #84 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #85 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #84
+  New state: shared-modified by threads #84, #85
+  Reason:    this thread, #85, holds no locks at all
+---------- char gran, 0 .. 99, skip 42 ----------
+
+Thread #86 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #87 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #86
+  New state: shared-modified by threads #86, #87
+  Reason:    this thread, #87, holds no locks at all
+---------- char gran, 0 .. 99, skip 43 ----------
+
+Thread #88 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #89 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #88
+  New state: shared-modified by threads #88, #89
+  Reason:    this thread, #89, holds no locks at all
+---------- char gran, 0 .. 99, skip 44 ----------
+
+Thread #90 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #91 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #90
+  New state: shared-modified by threads #90, #91
+  Reason:    this thread, #91, holds no locks at all
+---------- char gran, 0 .. 99, skip 45 ----------
+
+Thread #92 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #93 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #92
+  New state: shared-modified by threads #92, #93
+  Reason:    this thread, #93, holds no locks at all
+---------- char gran, 0 .. 99, skip 46 ----------
+
+Thread #94 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #95 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #94
+  New state: shared-modified by threads #94, #95
+  Reason:    this thread, #95, holds no locks at all
+---------- char gran, 0 .. 99, skip 47 ----------
+
+Thread #96 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #97 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #96
+  New state: shared-modified by threads #96, #97
+  Reason:    this thread, #97, holds no locks at all
+---------- char gran, 0 .. 99, skip 48 ----------
+
+Thread #98 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #99 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #98
+  New state: shared-modified by threads #98, #99
+  Reason:    this thread, #99, holds no locks at all
+---------- char gran, 0 .. 99, skip 49 ----------
+
+Thread #100 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #101 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #100
+  New state: shared-modified by threads #100, #101
+  Reason:    this thread, #101, holds no locks at all
+---------- char gran, 0 .. 99, skip 50 ----------
+
+Thread #102 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #103 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #102
+  New state: shared-modified by threads #102, #103
+  Reason:    this thread, #103, holds no locks at all
+---------- char gran, 0 .. 99, skip 51 ----------
+
+Thread #104 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #105 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #104
+  New state: shared-modified by threads #104, #105
+  Reason:    this thread, #105, holds no locks at all
+---------- char gran, 0 .. 99, skip 52 ----------
+
+Thread #106 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #107 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #106
+  New state: shared-modified by threads #106, #107
+  Reason:    this thread, #107, holds no locks at all
+---------- char gran, 0 .. 99, skip 53 ----------
+
+Thread #108 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #109 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #108
+  New state: shared-modified by threads #108, #109
+  Reason:    this thread, #109, holds no locks at all
+---------- char gran, 0 .. 99, skip 54 ----------
+
+Thread #110 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #111 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #110
+  New state: shared-modified by threads #110, #111
+  Reason:    this thread, #111, holds no locks at all
+---------- char gran, 0 .. 99, skip 55 ----------
+
+Thread #112 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #113 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #112
+  New state: shared-modified by threads #112, #113
+  Reason:    this thread, #113, holds no locks at all
+---------- char gran, 0 .. 99, skip 56 ----------
+
+Thread #114 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #115 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #114
+  New state: shared-modified by threads #114, #115
+  Reason:    this thread, #115, holds no locks at all
+---------- char gran, 0 .. 99, skip 57 ----------
+
+Thread #116 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #117 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #116
+  New state: shared-modified by threads #116, #117
+  Reason:    this thread, #117, holds no locks at all
+---------- char gran, 0 .. 99, skip 58 ----------
+
+Thread #118 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #119 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #118
+  New state: shared-modified by threads #118, #119
+  Reason:    this thread, #119, holds no locks at all
+---------- char gran, 0 .. 99, skip 59 ----------
+
+Thread #120 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #121 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #120
+  New state: shared-modified by threads #120, #121
+  Reason:    this thread, #121, holds no locks at all
+---------- char gran, 0 .. 99, skip 60 ----------
+
+Thread #122 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #123 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #122
+  New state: shared-modified by threads #122, #123
+  Reason:    this thread, #123, holds no locks at all
+---------- char gran, 0 .. 99, skip 61 ----------
+
+Thread #124 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #125 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #124
+  New state: shared-modified by threads #124, #125
+  Reason:    this thread, #125, holds no locks at all
+---------- char gran, 0 .. 99, skip 62 ----------
+
+Thread #126 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #127 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #126
+  New state: shared-modified by threads #126, #127
+  Reason:    this thread, #127, holds no locks at all
+---------- char gran, 0 .. 99, skip 63 ----------
+
+Thread #128 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #129 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #128
+  New state: shared-modified by threads #128, #129
+  Reason:    this thread, #129, holds no locks at all
+---------- char gran, 0 .. 99, skip 64 ----------
+
+Thread #130 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #131 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #130
+  New state: shared-modified by threads #130, #131
+  Reason:    this thread, #131, holds no locks at all
+---------- char gran, 0 .. 99, skip 65 ----------
+
+Thread #132 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #133 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #132
+  New state: shared-modified by threads #132, #133
+  Reason:    this thread, #133, holds no locks at all
+---------- char gran, 0 .. 99, skip 66 ----------
+
+Thread #134 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #135 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #134
+  New state: shared-modified by threads #134, #135
+  Reason:    this thread, #135, holds no locks at all
+---------- char gran, 0 .. 99, skip 67 ----------
+
+Thread #136 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #137 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #136
+  New state: shared-modified by threads #136, #137
+  Reason:    this thread, #137, holds no locks at all
+---------- char gran, 0 .. 99, skip 68 ----------
+
+Thread #138 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #139 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #138
+  New state: shared-modified by threads #138, #139
+  Reason:    this thread, #139, holds no locks at all
+---------- char gran, 0 .. 99, skip 69 ----------
+
+Thread #140 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #141 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #140
+  New state: shared-modified by threads #140, #141
+  Reason:    this thread, #141, holds no locks at all
+---------- char gran, 0 .. 99, skip 70 ----------
+
+Thread #142 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #143 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #142
+  New state: shared-modified by threads #142, #143
+  Reason:    this thread, #143, holds no locks at all
+---------- char gran, 0 .. 99, skip 71 ----------
+
+Thread #144 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #145 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #144
+  New state: shared-modified by threads #144, #145
+  Reason:    this thread, #145, holds no locks at all
+---------- char gran, 0 .. 99, skip 72 ----------
+
+Thread #146 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #147 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #146
+  New state: shared-modified by threads #146, #147
+  Reason:    this thread, #147, holds no locks at all
+---------- char gran, 0 .. 99, skip 73 ----------
+
+Thread #148 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #149 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #148
+  New state: shared-modified by threads #148, #149
+  Reason:    this thread, #149, holds no locks at all
+---------- char gran, 0 .. 99, skip 74 ----------
+
+Thread #150 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #151 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #150
+  New state: shared-modified by threads #150, #151
+  Reason:    this thread, #151, holds no locks at all
+---------- char gran, 0 .. 99, skip 75 ----------
+
+Thread #152 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #153 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #152
+  New state: shared-modified by threads #152, #153
+  Reason:    this thread, #153, holds no locks at all
+---------- char gran, 0 .. 99, skip 76 ----------
+
+Thread #154 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #155 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #154
+  New state: shared-modified by threads #154, #155
+  Reason:    this thread, #155, holds no locks at all
+---------- char gran, 0 .. 99, skip 77 ----------
+
+Thread #156 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #157 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #156
+  New state: shared-modified by threads #156, #157
+  Reason:    this thread, #157, holds no locks at all
+---------- char gran, 0 .. 99, skip 78 ----------
+
+Thread #158 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #159 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #158
+  New state: shared-modified by threads #158, #159
+  Reason:    this thread, #159, holds no locks at all
+---------- char gran, 0 .. 99, skip 79 ----------
+
+Thread #160 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #161 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #160
+  New state: shared-modified by threads #160, #161
+  Reason:    this thread, #161, holds no locks at all
+---------- char gran, 0 .. 99, skip 80 ----------
+
+Thread #162 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #163 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #162
+  New state: shared-modified by threads #162, #163
+  Reason:    this thread, #163, holds no locks at all
+---------- char gran, 0 .. 99, skip 81 ----------
+
+Thread #164 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #165 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #164
+  New state: shared-modified by threads #164, #165
+  Reason:    this thread, #165, holds no locks at all
+---------- char gran, 0 .. 99, skip 82 ----------
+
+Thread #166 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #167 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #166
+  New state: shared-modified by threads #166, #167
+  Reason:    this thread, #167, holds no locks at all
+---------- char gran, 0 .. 99, skip 83 ----------
+
+Thread #168 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #169 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #168
+  New state: shared-modified by threads #168, #169
+  Reason:    this thread, #169, holds no locks at all
+---------- char gran, 0 .. 99, skip 84 ----------
+
+Thread #170 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #171 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #170
+  New state: shared-modified by threads #170, #171
+  Reason:    this thread, #171, holds no locks at all
+---------- char gran, 0 .. 99, skip 85 ----------
+
+Thread #172 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #173 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #172
+  New state: shared-modified by threads #172, #173
+  Reason:    this thread, #173, holds no locks at all
+---------- char gran, 0 .. 99, skip 86 ----------
+
+Thread #174 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #175 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #174
+  New state: shared-modified by threads #174, #175
+  Reason:    this thread, #175, holds no locks at all
+---------- char gran, 0 .. 99, skip 87 ----------
+
+Thread #176 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #177 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #176
+  New state: shared-modified by threads #176, #177
+  Reason:    this thread, #177, holds no locks at all
+---------- char gran, 0 .. 99, skip 88 ----------
+
+Thread #178 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #179 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #178
+  New state: shared-modified by threads #178, #179
+  Reason:    this thread, #179, holds no locks at all
+---------- char gran, 0 .. 99, skip 89 ----------
+
+Thread #180 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #181 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #180
+  New state: shared-modified by threads #180, #181
+  Reason:    this thread, #181, holds no locks at all
+---------- char gran, 0 .. 99, skip 90 ----------
+
+Thread #182 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #183 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #182
+  New state: shared-modified by threads #182, #183
+  Reason:    this thread, #183, holds no locks at all
+---------- char gran, 0 .. 99, skip 91 ----------
+
+Thread #184 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #185 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #184
+  New state: shared-modified by threads #184, #185
+  Reason:    this thread, #185, holds no locks at all
+---------- char gran, 0 .. 99, skip 92 ----------
+
+Thread #186 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #187 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #186
+  New state: shared-modified by threads #186, #187
+  Reason:    this thread, #187, holds no locks at all
+---------- char gran, 0 .. 99, skip 93 ----------
+
+Thread #188 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #189 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #188
+  New state: shared-modified by threads #188, #189
+  Reason:    this thread, #189, holds no locks at all
+---------- char gran, 0 .. 99, skip 94 ----------
+
+Thread #190 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #191 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #190
+  New state: shared-modified by threads #190, #191
+  Reason:    this thread, #191, holds no locks at all
+---------- char gran, 0 .. 99, skip 95 ----------
+
+Thread #192 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #193 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #192
+  New state: shared-modified by threads #192, #193
+  Reason:    this thread, #193, holds no locks at all
+---------- char gran, 0 .. 99, skip 96 ----------
+
+Thread #194 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #195 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:480)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #194
+  New state: shared-modified by threads #194, #195
+  Reason:    this thread, #195, holds no locks at all
+---------- char gran, 0 .. 99, skip 97 ----------
+
+Thread #196 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #197 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #196
+  New state: shared-modified by threads #196, #197
+  Reason:    this thread, #197, holds no locks at all
+---------- char gran, 0 .. 99, skip 98 ----------
+
+Thread #198 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:172)
+
+Thread #199 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:173)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child8 (tc19_shadowmem.c:35)
+   by 0x........: steer (tc19_shadowmem.c:484)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #198
+  New state: shared-modified by threads #198, #199
+  Reason:    this thread, #199, holds no locks at all
+
+==========================================================
+=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===
+==========================================================
+
+---------- short gran, 0 .. 98, skip 0 ----------
+
+Thread #200 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #201 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #200
+  New state: shared-modified by threads #200, #201
+  Reason:    this thread, #201, holds no locks at all
+
+More than 100 errors detected.  Subsequent errors
+will still be recorded, but in less detail than before.
+---------- short gran, 1 .. 98, skip 1 ----------
+
+Thread #202 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #203 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #202
+  New state: shared-modified by threads #202, #203
+  Reason:    this thread, #203, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #202
+  New state: shared-modified by threads #202, #203
+  Reason:    this thread, #203, holds no locks at all
+---------- short gran, 0 .. 98, skip 2 ----------
+
+Thread #204 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #205 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #204
+  New state: shared-modified by threads #204, #205
+  Reason:    this thread, #205, holds no locks at all
+---------- short gran, 1 .. 98, skip 3 ----------
+
+Thread #206 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #207 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #206
+  New state: shared-modified by threads #206, #207
+  Reason:    this thread, #207, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #206
+  New state: shared-modified by threads #206, #207
+  Reason:    this thread, #207, holds no locks at all
+---------- short gran, 0 .. 98, skip 4 ----------
+
+Thread #208 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #209 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #208
+  New state: shared-modified by threads #208, #209
+  Reason:    this thread, #209, holds no locks at all
+---------- short gran, 1 .. 98, skip 5 ----------
+
+Thread #210 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #211 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #210
+  New state: shared-modified by threads #210, #211
+  Reason:    this thread, #211, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #210
+  New state: shared-modified by threads #210, #211
+  Reason:    this thread, #211, holds no locks at all
+---------- short gran, 0 .. 98, skip 6 ----------
+
+Thread #212 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #213 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #212
+  New state: shared-modified by threads #212, #213
+  Reason:    this thread, #213, holds no locks at all
+---------- short gran, 1 .. 98, skip 7 ----------
+
+Thread #214 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #215 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #214
+  New state: shared-modified by threads #214, #215
+  Reason:    this thread, #215, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #214
+  New state: shared-modified by threads #214, #215
+  Reason:    this thread, #215, holds no locks at all
+---------- short gran, 0 .. 98, skip 8 ----------
+
+Thread #216 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #217 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #216
+  New state: shared-modified by threads #216, #217
+  Reason:    this thread, #217, holds no locks at all
+---------- short gran, 1 .. 98, skip 9 ----------
+
+Thread #218 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #219 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #218
+  New state: shared-modified by threads #218, #219
+  Reason:    this thread, #219, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #218
+  New state: shared-modified by threads #218, #219
+  Reason:    this thread, #219, holds no locks at all
+---------- short gran, 0 .. 98, skip 10 ----------
+
+Thread #220 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #221 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #220
+  New state: shared-modified by threads #220, #221
+  Reason:    this thread, #221, holds no locks at all
+---------- short gran, 1 .. 98, skip 11 ----------
+
+Thread #222 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #223 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #222
+  New state: shared-modified by threads #222, #223
+  Reason:    this thread, #223, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #222
+  New state: shared-modified by threads #222, #223
+  Reason:    this thread, #223, holds no locks at all
+---------- short gran, 0 .. 98, skip 12 ----------
+
+Thread #224 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #225 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #224
+  New state: shared-modified by threads #224, #225
+  Reason:    this thread, #225, holds no locks at all
+---------- short gran, 1 .. 98, skip 13 ----------
+
+Thread #226 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #227 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #226
+  New state: shared-modified by threads #226, #227
+  Reason:    this thread, #227, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #226
+  New state: shared-modified by threads #226, #227
+  Reason:    this thread, #227, holds no locks at all
+---------- short gran, 0 .. 98, skip 14 ----------
+
+Thread #228 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #229 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #228
+  New state: shared-modified by threads #228, #229
+  Reason:    this thread, #229, holds no locks at all
+---------- short gran, 1 .. 98, skip 15 ----------
+
+Thread #230 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #231 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #230
+  New state: shared-modified by threads #230, #231
+  Reason:    this thread, #231, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #230
+  New state: shared-modified by threads #230, #231
+  Reason:    this thread, #231, holds no locks at all
+---------- short gran, 0 .. 98, skip 16 ----------
+
+Thread #232 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #233 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #232
+  New state: shared-modified by threads #232, #233
+  Reason:    this thread, #233, holds no locks at all
+---------- short gran, 1 .. 98, skip 17 ----------
+
+Thread #234 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #235 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #234
+  New state: shared-modified by threads #234, #235
+  Reason:    this thread, #235, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #234
+  New state: shared-modified by threads #234, #235
+  Reason:    this thread, #235, holds no locks at all
+---------- short gran, 0 .. 98, skip 18 ----------
+
+Thread #236 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #237 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #236
+  New state: shared-modified by threads #236, #237
+  Reason:    this thread, #237, holds no locks at all
+---------- short gran, 1 .. 98, skip 19 ----------
+
+Thread #238 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #239 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #238
+  New state: shared-modified by threads #238, #239
+  Reason:    this thread, #239, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #238
+  New state: shared-modified by threads #238, #239
+  Reason:    this thread, #239, holds no locks at all
+---------- short gran, 0 .. 98, skip 20 ----------
+
+Thread #240 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #241 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #240
+  New state: shared-modified by threads #240, #241
+  Reason:    this thread, #241, holds no locks at all
+---------- short gran, 1 .. 98, skip 21 ----------
+
+Thread #242 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #243 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #242
+  New state: shared-modified by threads #242, #243
+  Reason:    this thread, #243, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #242
+  New state: shared-modified by threads #242, #243
+  Reason:    this thread, #243, holds no locks at all
+---------- short gran, 0 .. 98, skip 22 ----------
+
+Thread #244 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #245 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #244
+  New state: shared-modified by threads #244, #245
+  Reason:    this thread, #245, holds no locks at all
+---------- short gran, 1 .. 98, skip 23 ----------
+
+Thread #246 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #247 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #246
+  New state: shared-modified by threads #246, #247
+  Reason:    this thread, #247, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #246
+  New state: shared-modified by threads #246, #247
+  Reason:    this thread, #247, holds no locks at all
+---------- short gran, 0 .. 98, skip 24 ----------
+
+Thread #248 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #249 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #248
+  New state: shared-modified by threads #248, #249
+  Reason:    this thread, #249, holds no locks at all
+---------- short gran, 1 .. 98, skip 25 ----------
+
+Thread #250 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #251 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #250
+  New state: shared-modified by threads #250, #251
+  Reason:    this thread, #251, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #250
+  New state: shared-modified by threads #250, #251
+  Reason:    this thread, #251, holds no locks at all
+---------- short gran, 0 .. 98, skip 26 ----------
+
+Thread #252 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #253 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #252
+  New state: shared-modified by threads #252, #253
+  Reason:    this thread, #253, holds no locks at all
+---------- short gran, 1 .. 98, skip 27 ----------
+
+Thread #254 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #255 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #254
+  New state: shared-modified by threads #254, #255
+  Reason:    this thread, #255, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #254
+  New state: shared-modified by threads #254, #255
+  Reason:    this thread, #255, holds no locks at all
+---------- short gran, 0 .. 98, skip 28 ----------
+
+Thread #256 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #257 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #256
+  New state: shared-modified by threads #256, #257
+  Reason:    this thread, #257, holds no locks at all
+---------- short gran, 1 .. 98, skip 29 ----------
+
+Thread #258 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #259 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #258
+  New state: shared-modified by threads #258, #259
+  Reason:    this thread, #259, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #258
+  New state: shared-modified by threads #258, #259
+  Reason:    this thread, #259, holds no locks at all
+---------- short gran, 0 .. 98, skip 30 ----------
+
+Thread #260 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #261 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #260
+  New state: shared-modified by threads #260, #261
+  Reason:    this thread, #261, holds no locks at all
+---------- short gran, 1 .. 98, skip 31 ----------
+
+Thread #262 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #263 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #262
+  New state: shared-modified by threads #262, #263
+  Reason:    this thread, #263, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #262
+  New state: shared-modified by threads #262, #263
+  Reason:    this thread, #263, holds no locks at all
+---------- short gran, 0 .. 98, skip 32 ----------
+
+Thread #264 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #265 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #264
+  New state: shared-modified by threads #264, #265
+  Reason:    this thread, #265, holds no locks at all
+---------- short gran, 1 .. 98, skip 33 ----------
+
+Thread #266 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #267 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #266
+  New state: shared-modified by threads #266, #267
+  Reason:    this thread, #267, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #266
+  New state: shared-modified by threads #266, #267
+  Reason:    this thread, #267, holds no locks at all
+---------- short gran, 0 .. 98, skip 34 ----------
+
+Thread #268 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #269 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #268
+  New state: shared-modified by threads #268, #269
+  Reason:    this thread, #269, holds no locks at all
+---------- short gran, 1 .. 98, skip 35 ----------
+
+Thread #270 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #271 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #270
+  New state: shared-modified by threads #270, #271
+  Reason:    this thread, #271, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #270
+  New state: shared-modified by threads #270, #271
+  Reason:    this thread, #271, holds no locks at all
+---------- short gran, 0 .. 98, skip 36 ----------
+
+Thread #272 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #273 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #272
+  New state: shared-modified by threads #272, #273
+  Reason:    this thread, #273, holds no locks at all
+---------- short gran, 1 .. 98, skip 37 ----------
+
+Thread #274 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #275 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #274
+  New state: shared-modified by threads #274, #275
+  Reason:    this thread, #275, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #274
+  New state: shared-modified by threads #274, #275
+  Reason:    this thread, #275, holds no locks at all
+---------- short gran, 0 .. 98, skip 38 ----------
+
+Thread #276 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #277 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #276
+  New state: shared-modified by threads #276, #277
+  Reason:    this thread, #277, holds no locks at all
+---------- short gran, 1 .. 98, skip 39 ----------
+
+Thread #278 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #279 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #278
+  New state: shared-modified by threads #278, #279
+  Reason:    this thread, #279, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #278
+  New state: shared-modified by threads #278, #279
+  Reason:    this thread, #279, holds no locks at all
+---------- short gran, 0 .. 98, skip 40 ----------
+
+Thread #280 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #281 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #280
+  New state: shared-modified by threads #280, #281
+  Reason:    this thread, #281, holds no locks at all
+---------- short gran, 1 .. 98, skip 41 ----------
+
+Thread #282 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #283 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #282
+  New state: shared-modified by threads #282, #283
+  Reason:    this thread, #283, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #282
+  New state: shared-modified by threads #282, #283
+  Reason:    this thread, #283, holds no locks at all
+---------- short gran, 0 .. 98, skip 42 ----------
+
+Thread #284 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #285 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #284
+  New state: shared-modified by threads #284, #285
+  Reason:    this thread, #285, holds no locks at all
+---------- short gran, 1 .. 98, skip 43 ----------
+
+Thread #286 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #287 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #286
+  New state: shared-modified by threads #286, #287
+  Reason:    this thread, #287, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #286
+  New state: shared-modified by threads #286, #287
+  Reason:    this thread, #287, holds no locks at all
+---------- short gran, 0 .. 98, skip 44 ----------
+
+Thread #288 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #289 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #288
+  New state: shared-modified by threads #288, #289
+  Reason:    this thread, #289, holds no locks at all
+---------- short gran, 1 .. 98, skip 45 ----------
+
+Thread #290 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #291 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #290
+  New state: shared-modified by threads #290, #291
+  Reason:    this thread, #291, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #290
+  New state: shared-modified by threads #290, #291
+  Reason:    this thread, #291, holds no locks at all
+---------- short gran, 0 .. 98, skip 46 ----------
+
+Thread #292 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #293 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #292
+  New state: shared-modified by threads #292, #293
+  Reason:    this thread, #293, holds no locks at all
+---------- short gran, 1 .. 98, skip 47 ----------
+
+Thread #294 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #295 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #294
+  New state: shared-modified by threads #294, #295
+  Reason:    this thread, #295, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #294
+  New state: shared-modified by threads #294, #295
+  Reason:    this thread, #295, holds no locks at all
+---------- short gran, 0 .. 98, skip 48 ----------
+
+Thread #296 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #297 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #296
+  New state: shared-modified by threads #296, #297
+  Reason:    this thread, #297, holds no locks at all
+---------- short gran, 1 .. 98, skip 49 ----------
+
+Thread #298 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #299 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #298
+  New state: shared-modified by threads #298, #299
+  Reason:    this thread, #299, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #298
+  New state: shared-modified by threads #298, #299
+  Reason:    this thread, #299, holds no locks at all
+---------- short gran, 0 .. 98, skip 50 ----------
+
+Thread #300 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #301 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #300
+  New state: shared-modified by threads #300, #301
+  Reason:    this thread, #301, holds no locks at all
+---------- short gran, 1 .. 98, skip 51 ----------
+
+Thread #302 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #303 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #302
+  New state: shared-modified by threads #302, #303
+  Reason:    this thread, #303, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #302
+  New state: shared-modified by threads #302, #303
+  Reason:    this thread, #303, holds no locks at all
+---------- short gran, 0 .. 98, skip 52 ----------
+
+Thread #304 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #305 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #304
+  New state: shared-modified by threads #304, #305
+  Reason:    this thread, #305, holds no locks at all
+---------- short gran, 1 .. 98, skip 53 ----------
+
+Thread #306 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #307 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #306
+  New state: shared-modified by threads #306, #307
+  Reason:    this thread, #307, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #306
+  New state: shared-modified by threads #306, #307
+  Reason:    this thread, #307, holds no locks at all
+---------- short gran, 0 .. 98, skip 54 ----------
+
+Thread #308 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #309 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #308
+  New state: shared-modified by threads #308, #309
+  Reason:    this thread, #309, holds no locks at all
+---------- short gran, 1 .. 98, skip 55 ----------
+
+Thread #310 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #311 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #310
+  New state: shared-modified by threads #310, #311
+  Reason:    this thread, #311, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #310
+  New state: shared-modified by threads #310, #311
+  Reason:    this thread, #311, holds no locks at all
+---------- short gran, 0 .. 98, skip 56 ----------
+
+Thread #312 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #313 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #312
+  New state: shared-modified by threads #312, #313
+  Reason:    this thread, #313, holds no locks at all
+---------- short gran, 1 .. 98, skip 57 ----------
+
+Thread #314 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #315 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #314
+  New state: shared-modified by threads #314, #315
+  Reason:    this thread, #315, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #314
+  New state: shared-modified by threads #314, #315
+  Reason:    this thread, #315, holds no locks at all
+---------- short gran, 0 .. 98, skip 58 ----------
+
+Thread #316 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #317 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #316
+  New state: shared-modified by threads #316, #317
+  Reason:    this thread, #317, holds no locks at all
+---------- short gran, 1 .. 98, skip 59 ----------
+
+Thread #318 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #319 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #318
+  New state: shared-modified by threads #318, #319
+  Reason:    this thread, #319, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #318
+  New state: shared-modified by threads #318, #319
+  Reason:    this thread, #319, holds no locks at all
+---------- short gran, 0 .. 98, skip 60 ----------
+
+Thread #320 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #321 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #320
+  New state: shared-modified by threads #320, #321
+  Reason:    this thread, #321, holds no locks at all
+---------- short gran, 1 .. 98, skip 61 ----------
+
+Thread #322 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #323 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #322
+  New state: shared-modified by threads #322, #323
+  Reason:    this thread, #323, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #322
+  New state: shared-modified by threads #322, #323
+  Reason:    this thread, #323, holds no locks at all
+---------- short gran, 0 .. 98, skip 62 ----------
+
+Thread #324 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #325 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #324
+  New state: shared-modified by threads #324, #325
+  Reason:    this thread, #325, holds no locks at all
+---------- short gran, 1 .. 98, skip 63 ----------
+
+Thread #326 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #327 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #326
+  New state: shared-modified by threads #326, #327
+  Reason:    this thread, #327, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #326
+  New state: shared-modified by threads #326, #327
+  Reason:    this thread, #327, holds no locks at all
+---------- short gran, 0 .. 98, skip 64 ----------
+
+Thread #328 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #329 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #328
+  New state: shared-modified by threads #328, #329
+  Reason:    this thread, #329, holds no locks at all
+---------- short gran, 1 .. 98, skip 65 ----------
+
+Thread #330 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #331 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #330
+  New state: shared-modified by threads #330, #331
+  Reason:    this thread, #331, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #330
+  New state: shared-modified by threads #330, #331
+  Reason:    this thread, #331, holds no locks at all
+---------- short gran, 0 .. 98, skip 66 ----------
+
+Thread #332 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #333 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #332
+  New state: shared-modified by threads #332, #333
+  Reason:    this thread, #333, holds no locks at all
+---------- short gran, 1 .. 98, skip 67 ----------
+
+Thread #334 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #335 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #334
+  New state: shared-modified by threads #334, #335
+  Reason:    this thread, #335, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #334
+  New state: shared-modified by threads #334, #335
+  Reason:    this thread, #335, holds no locks at all
+---------- short gran, 0 .. 98, skip 68 ----------
+
+Thread #336 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #337 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #336
+  New state: shared-modified by threads #336, #337
+  Reason:    this thread, #337, holds no locks at all
+---------- short gran, 1 .. 98, skip 69 ----------
+
+Thread #338 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #339 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #338
+  New state: shared-modified by threads #338, #339
+  Reason:    this thread, #339, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #338
+  New state: shared-modified by threads #338, #339
+  Reason:    this thread, #339, holds no locks at all
+---------- short gran, 0 .. 98, skip 70 ----------
+
+Thread #340 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #341 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #340
+  New state: shared-modified by threads #340, #341
+  Reason:    this thread, #341, holds no locks at all
+---------- short gran, 1 .. 98, skip 71 ----------
+
+Thread #342 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #343 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #342
+  New state: shared-modified by threads #342, #343
+  Reason:    this thread, #343, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #342
+  New state: shared-modified by threads #342, #343
+  Reason:    this thread, #343, holds no locks at all
+---------- short gran, 0 .. 98, skip 72 ----------
+
+Thread #344 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #345 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #344
+  New state: shared-modified by threads #344, #345
+  Reason:    this thread, #345, holds no locks at all
+---------- short gran, 1 .. 98, skip 73 ----------
+
+Thread #346 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #347 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #346
+  New state: shared-modified by threads #346, #347
+  Reason:    this thread, #347, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #346
+  New state: shared-modified by threads #346, #347
+  Reason:    this thread, #347, holds no locks at all
+---------- short gran, 0 .. 98, skip 74 ----------
+
+Thread #348 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #349 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #348
+  New state: shared-modified by threads #348, #349
+  Reason:    this thread, #349, holds no locks at all
+---------- short gran, 1 .. 98, skip 75 ----------
+
+Thread #350 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #351 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #350
+  New state: shared-modified by threads #350, #351
+  Reason:    this thread, #351, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #350
+  New state: shared-modified by threads #350, #351
+  Reason:    this thread, #351, holds no locks at all
+---------- short gran, 0 .. 98, skip 76 ----------
+
+Thread #352 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #353 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #352
+  New state: shared-modified by threads #352, #353
+  Reason:    this thread, #353, holds no locks at all
+---------- short gran, 1 .. 98, skip 77 ----------
+
+Thread #354 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #355 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #354
+  New state: shared-modified by threads #354, #355
+  Reason:    this thread, #355, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #354
+  New state: shared-modified by threads #354, #355
+  Reason:    this thread, #355, holds no locks at all
+---------- short gran, 0 .. 98, skip 78 ----------
+
+Thread #356 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #357 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #356
+  New state: shared-modified by threads #356, #357
+  Reason:    this thread, #357, holds no locks at all
+---------- short gran, 1 .. 98, skip 79 ----------
+
+Thread #358 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #359 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #358
+  New state: shared-modified by threads #358, #359
+  Reason:    this thread, #359, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #358
+  New state: shared-modified by threads #358, #359
+  Reason:    this thread, #359, holds no locks at all
+---------- short gran, 0 .. 98, skip 80 ----------
+
+Thread #360 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #361 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #360
+  New state: shared-modified by threads #360, #361
+  Reason:    this thread, #361, holds no locks at all
+---------- short gran, 1 .. 98, skip 81 ----------
+
+Thread #362 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #363 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #362
+  New state: shared-modified by threads #362, #363
+  Reason:    this thread, #363, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #362
+  New state: shared-modified by threads #362, #363
+  Reason:    this thread, #363, holds no locks at all
+---------- short gran, 0 .. 98, skip 82 ----------
+
+Thread #364 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #365 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #364
+  New state: shared-modified by threads #364, #365
+  Reason:    this thread, #365, holds no locks at all
+---------- short gran, 1 .. 98, skip 83 ----------
+
+Thread #366 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #367 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #366
+  New state: shared-modified by threads #366, #367
+  Reason:    this thread, #367, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #366
+  New state: shared-modified by threads #366, #367
+  Reason:    this thread, #367, holds no locks at all
+---------- short gran, 0 .. 98, skip 84 ----------
+
+Thread #368 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #369 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #368
+  New state: shared-modified by threads #368, #369
+  Reason:    this thread, #369, holds no locks at all
+---------- short gran, 1 .. 98, skip 85 ----------
+
+Thread #370 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #371 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #370
+  New state: shared-modified by threads #370, #371
+  Reason:    this thread, #371, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #370
+  New state: shared-modified by threads #370, #371
+  Reason:    this thread, #371, holds no locks at all
+---------- short gran, 0 .. 98, skip 86 ----------
+
+Thread #372 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #373 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #372
+  New state: shared-modified by threads #372, #373
+  Reason:    this thread, #373, holds no locks at all
+---------- short gran, 1 .. 98, skip 87 ----------
+
+Thread #374 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #375 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #374
+  New state: shared-modified by threads #374, #375
+  Reason:    this thread, #375, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #374
+  New state: shared-modified by threads #374, #375
+  Reason:    this thread, #375, holds no locks at all
+---------- short gran, 0 .. 98, skip 88 ----------
+
+Thread #376 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #377 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #376
+  New state: shared-modified by threads #376, #377
+  Reason:    this thread, #377, holds no locks at all
+---------- short gran, 1 .. 98, skip 89 ----------
+
+Thread #378 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #379 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #378
+  New state: shared-modified by threads #378, #379
+  Reason:    this thread, #379, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #378
+  New state: shared-modified by threads #378, #379
+  Reason:    this thread, #379, holds no locks at all
+---------- short gran, 0 .. 98, skip 90 ----------
+
+Thread #380 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #381 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #380
+  New state: shared-modified by threads #380, #381
+  Reason:    this thread, #381, holds no locks at all
+---------- short gran, 1 .. 98, skip 91 ----------
+
+Thread #382 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #383 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #382
+  New state: shared-modified by threads #382, #383
+  Reason:    this thread, #383, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #382
+  New state: shared-modified by threads #382, #383
+  Reason:    this thread, #383, holds no locks at all
+---------- short gran, 0 .. 98, skip 92 ----------
+
+Thread #384 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #385 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #384
+  New state: shared-modified by threads #384, #385
+  Reason:    this thread, #385, holds no locks at all
+---------- short gran, 1 .. 98, skip 93 ----------
+
+Thread #386 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #387 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #386
+  New state: shared-modified by threads #386, #387
+  Reason:    this thread, #387, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #386
+  New state: shared-modified by threads #386, #387
+  Reason:    this thread, #387, holds no locks at all
+---------- short gran, 0 .. 98, skip 94 ----------
+
+Thread #388 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #389 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #388
+  New state: shared-modified by threads #388, #389
+  Reason:    this thread, #389, holds no locks at all
+---------- short gran, 1 .. 98, skip 95 ----------
+
+Thread #390 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #391 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #390
+  New state: shared-modified by threads #390, #391
+  Reason:    this thread, #391, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #390
+  New state: shared-modified by threads #390, #391
+  Reason:    this thread, #391, holds no locks at all
+---------- short gran, 0 .. 98, skip 96 ----------
+
+Thread #392 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #393 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:480)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #392
+  New state: shared-modified by threads #392, #393
+  Reason:    this thread, #393, holds no locks at all
+---------- short gran, 1 .. 98, skip 97 ----------
+
+Thread #394 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:203)
+
+Thread #395 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:204)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #394
+  New state: shared-modified by threads #394, #395
+  Reason:    this thread, #395, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child16 (tc19_shadowmem.c:59)
+   by 0x........: steer (tc19_shadowmem.c:482)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #394
+  New state: shared-modified by threads #394, #395
+  Reason:    this thread, #395, holds no locks at all
+
+==========================================================
+=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===
+==========================================================
+
+---------- int gran, 0 .. 96, skip 0 ----------
+
+Thread #396 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #397 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #396
+  New state: shared-modified by threads #396, #397
+  Reason:    this thread, #397, holds no locks at all
+---------- int gran, 1 .. 96, skip 1 ----------
+
+Thread #398 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #399 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #398
+  New state: shared-modified by threads #398, #399
+  Reason:    this thread, #399, holds no locks at all
+---------- int gran, 2 .. 96, skip 2 ----------
+
+Thread #400 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #401 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #400
+  New state: shared-modified by threads #400, #401
+  Reason:    this thread, #401, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #400
+  New state: shared-modified by threads #400, #401
+  Reason:    this thread, #401, holds no locks at all
+---------- int gran, 3 .. 96, skip 3 ----------
+
+Thread #402 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #403 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #402
+  New state: shared-modified by threads #402, #403
+  Reason:    this thread, #403, holds no locks at all
+---------- int gran, 0 .. 96, skip 4 ----------
+
+Thread #404 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #405 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #404
+  New state: shared-modified by threads #404, #405
+  Reason:    this thread, #405, holds no locks at all
+---------- int gran, 1 .. 96, skip 5 ----------
+
+Thread #406 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #407 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #406
+  New state: shared-modified by threads #406, #407
+  Reason:    this thread, #407, holds no locks at all
+---------- int gran, 2 .. 96, skip 6 ----------
+
+Thread #408 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #409 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #408
+  New state: shared-modified by threads #408, #409
+  Reason:    this thread, #409, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #408
+  New state: shared-modified by threads #408, #409
+  Reason:    this thread, #409, holds no locks at all
+---------- int gran, 3 .. 96, skip 7 ----------
+
+Thread #410 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #411 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #410
+  New state: shared-modified by threads #410, #411
+  Reason:    this thread, #411, holds no locks at all
+---------- int gran, 0 .. 96, skip 8 ----------
+
+Thread #412 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #413 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #412
+  New state: shared-modified by threads #412, #413
+  Reason:    this thread, #413, holds no locks at all
+---------- int gran, 1 .. 96, skip 9 ----------
+
+Thread #414 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #415 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #414
+  New state: shared-modified by threads #414, #415
+  Reason:    this thread, #415, holds no locks at all
+---------- int gran, 2 .. 96, skip 10 ----------
+
+Thread #416 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #417 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #416
+  New state: shared-modified by threads #416, #417
+  Reason:    this thread, #417, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #416
+  New state: shared-modified by threads #416, #417
+  Reason:    this thread, #417, holds no locks at all
+---------- int gran, 3 .. 96, skip 11 ----------
+
+Thread #418 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #419 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #418
+  New state: shared-modified by threads #418, #419
+  Reason:    this thread, #419, holds no locks at all
+---------- int gran, 0 .. 96, skip 12 ----------
+
+Thread #420 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #421 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #420
+  New state: shared-modified by threads #420, #421
+  Reason:    this thread, #421, holds no locks at all
+---------- int gran, 1 .. 96, skip 13 ----------
+
+Thread #422 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #423 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #422
+  New state: shared-modified by threads #422, #423
+  Reason:    this thread, #423, holds no locks at all
+---------- int gran, 2 .. 96, skip 14 ----------
+
+Thread #424 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #425 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #424
+  New state: shared-modified by threads #424, #425
+  Reason:    this thread, #425, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #424
+  New state: shared-modified by threads #424, #425
+  Reason:    this thread, #425, holds no locks at all
+---------- int gran, 3 .. 96, skip 15 ----------
+
+Thread #426 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #427 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #426
+  New state: shared-modified by threads #426, #427
+  Reason:    this thread, #427, holds no locks at all
+---------- int gran, 0 .. 96, skip 16 ----------
+
+Thread #428 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #429 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #428
+  New state: shared-modified by threads #428, #429
+  Reason:    this thread, #429, holds no locks at all
+---------- int gran, 1 .. 96, skip 17 ----------
+
+Thread #430 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #431 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #430
+  New state: shared-modified by threads #430, #431
+  Reason:    this thread, #431, holds no locks at all
+---------- int gran, 2 .. 96, skip 18 ----------
+
+Thread #432 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #433 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #432
+  New state: shared-modified by threads #432, #433
+  Reason:    this thread, #433, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #432
+  New state: shared-modified by threads #432, #433
+  Reason:    this thread, #433, holds no locks at all
+---------- int gran, 3 .. 96, skip 19 ----------
+
+Thread #434 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #435 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #434
+  New state: shared-modified by threads #434, #435
+  Reason:    this thread, #435, holds no locks at all
+---------- int gran, 0 .. 96, skip 20 ----------
+
+Thread #436 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #437 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #436
+  New state: shared-modified by threads #436, #437
+  Reason:    this thread, #437, holds no locks at all
+---------- int gran, 1 .. 96, skip 21 ----------
+
+Thread #438 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #439 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #438
+  New state: shared-modified by threads #438, #439
+  Reason:    this thread, #439, holds no locks at all
+---------- int gran, 2 .. 96, skip 22 ----------
+
+Thread #440 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #441 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #440
+  New state: shared-modified by threads #440, #441
+  Reason:    this thread, #441, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #440
+  New state: shared-modified by threads #440, #441
+  Reason:    this thread, #441, holds no locks at all
+---------- int gran, 3 .. 96, skip 23 ----------
+
+Thread #442 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #443 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #442
+  New state: shared-modified by threads #442, #443
+  Reason:    this thread, #443, holds no locks at all
+---------- int gran, 0 .. 96, skip 24 ----------
+
+Thread #444 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #445 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #444
+  New state: shared-modified by threads #444, #445
+  Reason:    this thread, #445, holds no locks at all
+---------- int gran, 1 .. 96, skip 25 ----------
+
+Thread #446 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #447 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #446
+  New state: shared-modified by threads #446, #447
+  Reason:    this thread, #447, holds no locks at all
+---------- int gran, 2 .. 96, skip 26 ----------
+
+Thread #448 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #449 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #448
+  New state: shared-modified by threads #448, #449
+  Reason:    this thread, #449, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #448
+  New state: shared-modified by threads #448, #449
+  Reason:    this thread, #449, holds no locks at all
+---------- int gran, 3 .. 96, skip 27 ----------
+
+Thread #450 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #451 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #450
+  New state: shared-modified by threads #450, #451
+  Reason:    this thread, #451, holds no locks at all
+---------- int gran, 0 .. 96, skip 28 ----------
+
+Thread #452 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #453 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #452
+  New state: shared-modified by threads #452, #453
+  Reason:    this thread, #453, holds no locks at all
+---------- int gran, 1 .. 96, skip 29 ----------
+
+Thread #454 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #455 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #454
+  New state: shared-modified by threads #454, #455
+  Reason:    this thread, #455, holds no locks at all
+---------- int gran, 2 .. 96, skip 30 ----------
+
+Thread #456 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #457 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #456
+  New state: shared-modified by threads #456, #457
+  Reason:    this thread, #457, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #456
+  New state: shared-modified by threads #456, #457
+  Reason:    this thread, #457, holds no locks at all
+---------- int gran, 3 .. 96, skip 31 ----------
+
+Thread #458 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #459 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #458
+  New state: shared-modified by threads #458, #459
+  Reason:    this thread, #459, holds no locks at all
+---------- int gran, 0 .. 96, skip 32 ----------
+
+Thread #460 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #461 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #460
+  New state: shared-modified by threads #460, #461
+  Reason:    this thread, #461, holds no locks at all
+---------- int gran, 1 .. 96, skip 33 ----------
+
+Thread #462 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #463 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #462
+  New state: shared-modified by threads #462, #463
+  Reason:    this thread, #463, holds no locks at all
+---------- int gran, 2 .. 96, skip 34 ----------
+
+Thread #464 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #465 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #464
+  New state: shared-modified by threads #464, #465
+  Reason:    this thread, #465, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #464
+  New state: shared-modified by threads #464, #465
+  Reason:    this thread, #465, holds no locks at all
+---------- int gran, 3 .. 96, skip 35 ----------
+
+Thread #466 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #467 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #466
+  New state: shared-modified by threads #466, #467
+  Reason:    this thread, #467, holds no locks at all
+---------- int gran, 0 .. 96, skip 36 ----------
+
+Thread #468 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #469 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #468
+  New state: shared-modified by threads #468, #469
+  Reason:    this thread, #469, holds no locks at all
+---------- int gran, 1 .. 96, skip 37 ----------
+
+Thread #470 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #471 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #470
+  New state: shared-modified by threads #470, #471
+  Reason:    this thread, #471, holds no locks at all
+---------- int gran, 2 .. 96, skip 38 ----------
+
+Thread #472 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #473 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #472
+  New state: shared-modified by threads #472, #473
+  Reason:    this thread, #473, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #472
+  New state: shared-modified by threads #472, #473
+  Reason:    this thread, #473, holds no locks at all
+---------- int gran, 3 .. 96, skip 39 ----------
+
+Thread #474 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #475 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #474
+  New state: shared-modified by threads #474, #475
+  Reason:    this thread, #475, holds no locks at all
+---------- int gran, 0 .. 96, skip 40 ----------
+
+Thread #476 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #477 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #476
+  New state: shared-modified by threads #476, #477
+  Reason:    this thread, #477, holds no locks at all
+---------- int gran, 1 .. 96, skip 41 ----------
+
+Thread #478 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #479 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #478
+  New state: shared-modified by threads #478, #479
+  Reason:    this thread, #479, holds no locks at all
+---------- int gran, 2 .. 96, skip 42 ----------
+
+Thread #480 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #481 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #480
+  New state: shared-modified by threads #480, #481
+  Reason:    this thread, #481, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #480
+  New state: shared-modified by threads #480, #481
+  Reason:    this thread, #481, holds no locks at all
+---------- int gran, 3 .. 96, skip 43 ----------
+
+Thread #482 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #483 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #482
+  New state: shared-modified by threads #482, #483
+  Reason:    this thread, #483, holds no locks at all
+---------- int gran, 0 .. 96, skip 44 ----------
+
+Thread #484 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #485 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #484
+  New state: shared-modified by threads #484, #485
+  Reason:    this thread, #485, holds no locks at all
+---------- int gran, 1 .. 96, skip 45 ----------
+
+Thread #486 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #487 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #486
+  New state: shared-modified by threads #486, #487
+  Reason:    this thread, #487, holds no locks at all
+---------- int gran, 2 .. 96, skip 46 ----------
+
+Thread #488 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #489 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #488
+  New state: shared-modified by threads #488, #489
+  Reason:    this thread, #489, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #488
+  New state: shared-modified by threads #488, #489
+  Reason:    this thread, #489, holds no locks at all
+---------- int gran, 3 .. 96, skip 47 ----------
+
+Thread #490 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #491 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #490
+  New state: shared-modified by threads #490, #491
+  Reason:    this thread, #491, holds no locks at all
+---------- int gran, 0 .. 96, skip 48 ----------
+
+Thread #492 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #493 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #492
+  New state: shared-modified by threads #492, #493
+  Reason:    this thread, #493, holds no locks at all
+---------- int gran, 1 .. 96, skip 49 ----------
+
+Thread #494 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #495 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #494
+  New state: shared-modified by threads #494, #495
+  Reason:    this thread, #495, holds no locks at all
+---------- int gran, 2 .. 96, skip 50 ----------
+
+Thread #496 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #497 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #496
+  New state: shared-modified by threads #496, #497
+  Reason:    this thread, #497, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #496
+  New state: shared-modified by threads #496, #497
+  Reason:    this thread, #497, holds no locks at all
+---------- int gran, 3 .. 96, skip 51 ----------
+
+Thread #498 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #499 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #498
+  New state: shared-modified by threads #498, #499
+  Reason:    this thread, #499, holds no locks at all
+---------- int gran, 0 .. 96, skip 52 ----------
+
+Thread #500 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #501 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #500
+  New state: shared-modified by threads #500, #501
+  Reason:    this thread, #501, holds no locks at all
+---------- int gran, 1 .. 96, skip 53 ----------
+
+Thread #502 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #503 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #502
+  New state: shared-modified by threads #502, #503
+  Reason:    this thread, #503, holds no locks at all
+---------- int gran, 2 .. 96, skip 54 ----------
+
+Thread #504 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #505 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #504
+  New state: shared-modified by threads #504, #505
+  Reason:    this thread, #505, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #504
+  New state: shared-modified by threads #504, #505
+  Reason:    this thread, #505, holds no locks at all
+---------- int gran, 3 .. 96, skip 55 ----------
+
+Thread #506 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #507 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #506
+  New state: shared-modified by threads #506, #507
+  Reason:    this thread, #507, holds no locks at all
+---------- int gran, 0 .. 96, skip 56 ----------
+
+Thread #508 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #509 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #508
+  New state: shared-modified by threads #508, #509
+  Reason:    this thread, #509, holds no locks at all
+---------- int gran, 1 .. 96, skip 57 ----------
+
+Thread #510 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #511 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #510
+  New state: shared-modified by threads #510, #511
+  Reason:    this thread, #511, holds no locks at all
+---------- int gran, 2 .. 96, skip 58 ----------
+
+Thread #512 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #513 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #512
+  New state: shared-modified by threads #512, #513
+  Reason:    this thread, #513, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #512
+  New state: shared-modified by threads #512, #513
+  Reason:    this thread, #513, holds no locks at all
+---------- int gran, 3 .. 96, skip 59 ----------
+
+Thread #514 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #515 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #514
+  New state: shared-modified by threads #514, #515
+  Reason:    this thread, #515, holds no locks at all
+---------- int gran, 0 .. 96, skip 60 ----------
+
+Thread #516 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #517 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #516
+  New state: shared-modified by threads #516, #517
+  Reason:    this thread, #517, holds no locks at all
+---------- int gran, 1 .. 96, skip 61 ----------
+
+Thread #518 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #519 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #518
+  New state: shared-modified by threads #518, #519
+  Reason:    this thread, #519, holds no locks at all
+---------- int gran, 2 .. 96, skip 62 ----------
+
+Thread #520 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #521 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #520
+  New state: shared-modified by threads #520, #521
+  Reason:    this thread, #521, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #520
+  New state: shared-modified by threads #520, #521
+  Reason:    this thread, #521, holds no locks at all
+---------- int gran, 3 .. 96, skip 63 ----------
+
+Thread #522 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #523 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #522
+  New state: shared-modified by threads #522, #523
+  Reason:    this thread, #523, holds no locks at all
+---------- int gran, 0 .. 96, skip 64 ----------
+
+Thread #524 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #525 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #524
+  New state: shared-modified by threads #524, #525
+  Reason:    this thread, #525, holds no locks at all
+---------- int gran, 1 .. 96, skip 65 ----------
+
+Thread #526 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #527 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #526
+  New state: shared-modified by threads #526, #527
+  Reason:    this thread, #527, holds no locks at all
+---------- int gran, 2 .. 96, skip 66 ----------
+
+Thread #528 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #529 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #528
+  New state: shared-modified by threads #528, #529
+  Reason:    this thread, #529, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #528
+  New state: shared-modified by threads #528, #529
+  Reason:    this thread, #529, holds no locks at all
+---------- int gran, 3 .. 96, skip 67 ----------
+
+Thread #530 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #531 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #530
+  New state: shared-modified by threads #530, #531
+  Reason:    this thread, #531, holds no locks at all
+---------- int gran, 0 .. 96, skip 68 ----------
+
+Thread #532 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #533 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #532
+  New state: shared-modified by threads #532, #533
+  Reason:    this thread, #533, holds no locks at all
+---------- int gran, 1 .. 96, skip 69 ----------
+
+Thread #534 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #535 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #534
+  New state: shared-modified by threads #534, #535
+  Reason:    this thread, #535, holds no locks at all
+---------- int gran, 2 .. 96, skip 70 ----------
+
+Thread #536 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #537 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #536
+  New state: shared-modified by threads #536, #537
+  Reason:    this thread, #537, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #536
+  New state: shared-modified by threads #536, #537
+  Reason:    this thread, #537, holds no locks at all
+---------- int gran, 3 .. 96, skip 71 ----------
+
+Thread #538 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #539 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #538
+  New state: shared-modified by threads #538, #539
+  Reason:    this thread, #539, holds no locks at all
+---------- int gran, 0 .. 96, skip 72 ----------
+
+Thread #540 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #541 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #540
+  New state: shared-modified by threads #540, #541
+  Reason:    this thread, #541, holds no locks at all
+---------- int gran, 1 .. 96, skip 73 ----------
+
+Thread #542 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #543 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #542
+  New state: shared-modified by threads #542, #543
+  Reason:    this thread, #543, holds no locks at all
+---------- int gran, 2 .. 96, skip 74 ----------
+
+Thread #544 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #545 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #544
+  New state: shared-modified by threads #544, #545
+  Reason:    this thread, #545, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #544
+  New state: shared-modified by threads #544, #545
+  Reason:    this thread, #545, holds no locks at all
+---------- int gran, 3 .. 96, skip 75 ----------
+
+Thread #546 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #547 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #546
+  New state: shared-modified by threads #546, #547
+  Reason:    this thread, #547, holds no locks at all
+---------- int gran, 0 .. 96, skip 76 ----------
+
+Thread #548 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #549 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #548
+  New state: shared-modified by threads #548, #549
+  Reason:    this thread, #549, holds no locks at all
+---------- int gran, 1 .. 96, skip 77 ----------
+
+Thread #550 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #551 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #550
+  New state: shared-modified by threads #550, #551
+  Reason:    this thread, #551, holds no locks at all
+---------- int gran, 2 .. 96, skip 78 ----------
+
+Thread #552 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #553 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #552
+  New state: shared-modified by threads #552, #553
+  Reason:    this thread, #553, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #552
+  New state: shared-modified by threads #552, #553
+  Reason:    this thread, #553, holds no locks at all
+---------- int gran, 3 .. 96, skip 79 ----------
+
+Thread #554 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #555 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #554
+  New state: shared-modified by threads #554, #555
+  Reason:    this thread, #555, holds no locks at all
+---------- int gran, 0 .. 96, skip 80 ----------
+
+Thread #556 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #557 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #556
+  New state: shared-modified by threads #556, #557
+  Reason:    this thread, #557, holds no locks at all
+---------- int gran, 1 .. 96, skip 81 ----------
+
+Thread #558 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #559 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #558
+  New state: shared-modified by threads #558, #559
+  Reason:    this thread, #559, holds no locks at all
+---------- int gran, 2 .. 96, skip 82 ----------
+
+Thread #560 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #561 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #560
+  New state: shared-modified by threads #560, #561
+  Reason:    this thread, #561, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #560
+  New state: shared-modified by threads #560, #561
+  Reason:    this thread, #561, holds no locks at all
+---------- int gran, 3 .. 96, skip 83 ----------
+
+Thread #562 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #563 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #562
+  New state: shared-modified by threads #562, #563
+  Reason:    this thread, #563, holds no locks at all
+---------- int gran, 0 .. 96, skip 84 ----------
+
+Thread #564 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #565 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #564
+  New state: shared-modified by threads #564, #565
+  Reason:    this thread, #565, holds no locks at all
+---------- int gran, 1 .. 96, skip 85 ----------
+
+Thread #566 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #567 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #566
+  New state: shared-modified by threads #566, #567
+  Reason:    this thread, #567, holds no locks at all
+---------- int gran, 2 .. 96, skip 86 ----------
+
+Thread #568 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #569 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #568
+  New state: shared-modified by threads #568, #569
+  Reason:    this thread, #569, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #568
+  New state: shared-modified by threads #568, #569
+  Reason:    this thread, #569, holds no locks at all
+---------- int gran, 3 .. 96, skip 87 ----------
+
+Thread #570 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #571 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #570
+  New state: shared-modified by threads #570, #571
+  Reason:    this thread, #571, holds no locks at all
+---------- int gran, 0 .. 96, skip 88 ----------
+
+Thread #572 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #573 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #572
+  New state: shared-modified by threads #572, #573
+  Reason:    this thread, #573, holds no locks at all
+---------- int gran, 1 .. 96, skip 89 ----------
+
+Thread #574 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #575 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #574
+  New state: shared-modified by threads #574, #575
+  Reason:    this thread, #575, holds no locks at all
+---------- int gran, 2 .. 96, skip 90 ----------
+
+Thread #576 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #577 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #576
+  New state: shared-modified by threads #576, #577
+  Reason:    this thread, #577, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #576
+  New state: shared-modified by threads #576, #577
+  Reason:    this thread, #577, holds no locks at all
+---------- int gran, 3 .. 96, skip 91 ----------
+
+Thread #578 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #579 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #578
+  New state: shared-modified by threads #578, #579
+  Reason:    this thread, #579, holds no locks at all
+---------- int gran, 0 .. 96, skip 92 ----------
+
+Thread #580 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #581 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:472)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #580
+  New state: shared-modified by threads #580, #581
+  Reason:    this thread, #581, holds no locks at all
+---------- int gran, 1 .. 96, skip 93 ----------
+
+Thread #582 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #583 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:474)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #582
+  New state: shared-modified by threads #582, #583
+  Reason:    this thread, #583, holds no locks at all
+---------- int gran, 2 .. 96, skip 94 ----------
+
+Thread #584 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #585 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #584
+  New state: shared-modified by threads #584, #585
+  Reason:    this thread, #585, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:476)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #584
+  New state: shared-modified by threads #584, #585
+  Reason:    this thread, #585, holds no locks at all
+---------- int gran, 3 .. 96, skip 95 ----------
+
+Thread #586 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:234)
+
+Thread #587 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:235)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child32 (tc19_shadowmem.c:83)
+   by 0x........: steer (tc19_shadowmem.c:478)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #586
+  New state: shared-modified by threads #586, #587
+  Reason:    this thread, #587, holds no locks at all
+
+==========================================================
+=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===
+==========================================================
+
+---------- double gran, 0 .. 92, skip 0 ----------
+
+Thread #588 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #589 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:288)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #588
+  New state: shared-modified by threads #588, #589
+  Reason:    this thread, #589, holds no locks at all
+---------- double gran, 1 .. 92, skip 1 ----------
+
+Thread #590 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #591 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:290)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #590
+  New state: shared-modified by threads #590, #591
+  Reason:    this thread, #591, holds no locks at all
+---------- double gran, 2 .. 92, skip 2 ----------
+
+Thread #592 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #593 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:292)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #592
+  New state: shared-modified by threads #592, #593
+  Reason:    this thread, #593, holds no locks at all
+---------- double gran, 3 .. 92, skip 3 ----------
+
+Thread #594 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #595 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:294)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #594
+  New state: shared-modified by threads #594, #595
+  Reason:    this thread, #595, holds no locks at all
+---------- double gran, 4 .. 92, skip 4 ----------
+
+Thread #596 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #597 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #596
+  New state: shared-modified by threads #596, #597
+  Reason:    this thread, #597, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:296)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #596
+  New state: shared-modified by threads #596, #597
+  Reason:    this thread, #597, holds no locks at all
+---------- double gran, 5 .. 92, skip 5 ----------
+
+Thread #598 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #599 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:298)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #598
+  New state: shared-modified by threads #598, #599
+  Reason:    this thread, #599, holds no locks at all
+---------- double gran, 6 .. 92, skip 6 ----------
+
+Thread #600 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #601 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:300)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #600
+  New state: shared-modified by threads #600, #601
+  Reason:    this thread, #601, holds no locks at all
+---------- double gran, 7 .. 92, skip 7 ----------
+
+Thread #602 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #603 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:302)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #602
+  New state: shared-modified by threads #602, #603
+  Reason:    this thread, #603, holds no locks at all
+---------- double gran, 0 .. 92, skip 8 ----------
+
+Thread #604 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #605 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:304)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #604
+  New state: shared-modified by threads #604, #605
+  Reason:    this thread, #605, holds no locks at all
+---------- double gran, 1 .. 92, skip 9 ----------
+
+Thread #606 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #607 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:306)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #606
+  New state: shared-modified by threads #606, #607
+  Reason:    this thread, #607, holds no locks at all
+---------- double gran, 2 .. 92, skip 10 ----------
+
+Thread #608 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #609 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:308)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #608
+  New state: shared-modified by threads #608, #609
+  Reason:    this thread, #609, holds no locks at all
+---------- double gran, 3 .. 92, skip 11 ----------
+
+Thread #610 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #611 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:310)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #610
+  New state: shared-modified by threads #610, #611
+  Reason:    this thread, #611, holds no locks at all
+---------- double gran, 4 .. 92, skip 12 ----------
+
+Thread #612 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #613 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #612
+  New state: shared-modified by threads #612, #613
+  Reason:    this thread, #613, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:312)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #612
+  New state: shared-modified by threads #612, #613
+  Reason:    this thread, #613, holds no locks at all
+---------- double gran, 5 .. 92, skip 13 ----------
+
+Thread #614 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #615 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:314)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #614
+  New state: shared-modified by threads #614, #615
+  Reason:    this thread, #615, holds no locks at all
+---------- double gran, 6 .. 92, skip 14 ----------
+
+Thread #616 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #617 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:316)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #616
+  New state: shared-modified by threads #616, #617
+  Reason:    this thread, #617, holds no locks at all
+---------- double gran, 7 .. 92, skip 15 ----------
+
+Thread #618 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #619 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:318)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #618
+  New state: shared-modified by threads #618, #619
+  Reason:    this thread, #619, holds no locks at all
+---------- double gran, 0 .. 92, skip 16 ----------
+
+Thread #620 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #621 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:320)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #620
+  New state: shared-modified by threads #620, #621
+  Reason:    this thread, #621, holds no locks at all
+---------- double gran, 1 .. 92, skip 17 ----------
+
+Thread #622 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #623 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:322)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #622
+  New state: shared-modified by threads #622, #623
+  Reason:    this thread, #623, holds no locks at all
+---------- double gran, 2 .. 92, skip 18 ----------
+
+Thread #624 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #625 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:324)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #624
+  New state: shared-modified by threads #624, #625
+  Reason:    this thread, #625, holds no locks at all
+---------- double gran, 3 .. 92, skip 19 ----------
+
+Thread #626 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #627 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:326)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #626
+  New state: shared-modified by threads #626, #627
+  Reason:    this thread, #627, holds no locks at all
+---------- double gran, 4 .. 92, skip 20 ----------
+
+Thread #628 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #629 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #628
+  New state: shared-modified by threads #628, #629
+  Reason:    this thread, #629, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:328)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #628
+  New state: shared-modified by threads #628, #629
+  Reason:    this thread, #629, holds no locks at all
+---------- double gran, 5 .. 92, skip 21 ----------
+
+Thread #630 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #631 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:330)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #630
+  New state: shared-modified by threads #630, #631
+  Reason:    this thread, #631, holds no locks at all
+---------- double gran, 6 .. 92, skip 22 ----------
+
+Thread #632 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #633 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:332)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #632
+  New state: shared-modified by threads #632, #633
+  Reason:    this thread, #633, holds no locks at all
+---------- double gran, 7 .. 92, skip 23 ----------
+
+Thread #634 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #635 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:334)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #634
+  New state: shared-modified by threads #634, #635
+  Reason:    this thread, #635, holds no locks at all
+---------- double gran, 0 .. 92, skip 24 ----------
+
+Thread #636 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #637 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:336)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #636
+  New state: shared-modified by threads #636, #637
+  Reason:    this thread, #637, holds no locks at all
+---------- double gran, 1 .. 92, skip 25 ----------
+
+Thread #638 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #639 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:338)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #638
+  New state: shared-modified by threads #638, #639
+  Reason:    this thread, #639, holds no locks at all
+---------- double gran, 2 .. 92, skip 26 ----------
+
+Thread #640 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #641 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:340)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #640
+  New state: shared-modified by threads #640, #641
+  Reason:    this thread, #641, holds no locks at all
+---------- double gran, 3 .. 92, skip 27 ----------
+
+Thread #642 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #643 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:342)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #642
+  New state: shared-modified by threads #642, #643
+  Reason:    this thread, #643, holds no locks at all
+---------- double gran, 4 .. 92, skip 28 ----------
+
+Thread #644 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #645 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #644
+  New state: shared-modified by threads #644, #645
+  Reason:    this thread, #645, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:344)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #644
+  New state: shared-modified by threads #644, #645
+  Reason:    this thread, #645, holds no locks at all
+---------- double gran, 5 .. 92, skip 29 ----------
+
+Thread #646 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #647 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:346)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #646
+  New state: shared-modified by threads #646, #647
+  Reason:    this thread, #647, holds no locks at all
+---------- double gran, 6 .. 92, skip 30 ----------
+
+Thread #648 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #649 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:348)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #648
+  New state: shared-modified by threads #648, #649
+  Reason:    this thread, #649, holds no locks at all
+---------- double gran, 7 .. 92, skip 31 ----------
+
+Thread #650 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #651 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:350)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #650
+  New state: shared-modified by threads #650, #651
+  Reason:    this thread, #651, holds no locks at all
+---------- double gran, 0 .. 92, skip 32 ----------
+
+Thread #652 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #653 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:352)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #652
+  New state: shared-modified by threads #652, #653
+  Reason:    this thread, #653, holds no locks at all
+---------- double gran, 1 .. 92, skip 33 ----------
+
+Thread #654 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #655 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:354)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #654
+  New state: shared-modified by threads #654, #655
+  Reason:    this thread, #655, holds no locks at all
+---------- double gran, 2 .. 92, skip 34 ----------
+
+Thread #656 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #657 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:356)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #656
+  New state: shared-modified by threads #656, #657
+  Reason:    this thread, #657, holds no locks at all
+---------- double gran, 3 .. 92, skip 35 ----------
+
+Thread #658 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #659 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:358)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #658
+  New state: shared-modified by threads #658, #659
+  Reason:    this thread, #659, holds no locks at all
+---------- double gran, 4 .. 92, skip 36 ----------
+
+Thread #660 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #661 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #660
+  New state: shared-modified by threads #660, #661
+  Reason:    this thread, #661, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:360)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #660
+  New state: shared-modified by threads #660, #661
+  Reason:    this thread, #661, holds no locks at all
+---------- double gran, 5 .. 92, skip 37 ----------
+
+Thread #662 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #663 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:362)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #662
+  New state: shared-modified by threads #662, #663
+  Reason:    this thread, #663, holds no locks at all
+---------- double gran, 6 .. 92, skip 38 ----------
+
+Thread #664 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #665 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:364)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #664
+  New state: shared-modified by threads #664, #665
+  Reason:    this thread, #665, holds no locks at all
+---------- double gran, 7 .. 92, skip 39 ----------
+
+Thread #666 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #667 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:366)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #666
+  New state: shared-modified by threads #666, #667
+  Reason:    this thread, #667, holds no locks at all
+---------- double gran, 0 .. 92, skip 40 ----------
+
+Thread #668 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #669 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:368)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #668
+  New state: shared-modified by threads #668, #669
+  Reason:    this thread, #669, holds no locks at all
+---------- double gran, 1 .. 92, skip 41 ----------
+
+Thread #670 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #671 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:370)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #670
+  New state: shared-modified by threads #670, #671
+  Reason:    this thread, #671, holds no locks at all
+---------- double gran, 2 .. 92, skip 42 ----------
+
+Thread #672 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #673 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:372)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #672
+  New state: shared-modified by threads #672, #673
+  Reason:    this thread, #673, holds no locks at all
+---------- double gran, 3 .. 92, skip 43 ----------
+
+Thread #674 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #675 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:374)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #674
+  New state: shared-modified by threads #674, #675
+  Reason:    this thread, #675, holds no locks at all
+---------- double gran, 4 .. 92, skip 44 ----------
+
+Thread #676 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #677 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #676
+  New state: shared-modified by threads #676, #677
+  Reason:    this thread, #677, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:376)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #676
+  New state: shared-modified by threads #676, #677
+  Reason:    this thread, #677, holds no locks at all
+---------- double gran, 5 .. 92, skip 45 ----------
+
+Thread #678 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #679 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:378)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #678
+  New state: shared-modified by threads #678, #679
+  Reason:    this thread, #679, holds no locks at all
+---------- double gran, 6 .. 92, skip 46 ----------
+
+Thread #680 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #681 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:380)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #680
+  New state: shared-modified by threads #680, #681
+  Reason:    this thread, #681, holds no locks at all
+---------- double gran, 7 .. 92, skip 47 ----------
+
+Thread #682 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #683 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:382)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #682
+  New state: shared-modified by threads #682, #683
+  Reason:    this thread, #683, holds no locks at all
+---------- double gran, 0 .. 92, skip 48 ----------
+
+Thread #684 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #685 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:384)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #684
+  New state: shared-modified by threads #684, #685
+  Reason:    this thread, #685, holds no locks at all
+---------- double gran, 1 .. 92, skip 49 ----------
+
+Thread #686 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #687 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:386)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #686
+  New state: shared-modified by threads #686, #687
+  Reason:    this thread, #687, holds no locks at all
+---------- double gran, 2 .. 92, skip 50 ----------
+
+Thread #688 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #689 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:388)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #688
+  New state: shared-modified by threads #688, #689
+  Reason:    this thread, #689, holds no locks at all
+---------- double gran, 3 .. 92, skip 51 ----------
+
+Thread #690 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #691 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:390)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #690
+  New state: shared-modified by threads #690, #691
+  Reason:    this thread, #691, holds no locks at all
+---------- double gran, 4 .. 92, skip 52 ----------
+
+Thread #692 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #693 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #692
+  New state: shared-modified by threads #692, #693
+  Reason:    this thread, #693, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:392)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #692
+  New state: shared-modified by threads #692, #693
+  Reason:    this thread, #693, holds no locks at all
+---------- double gran, 5 .. 92, skip 53 ----------
+
+Thread #694 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #695 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:394)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #694
+  New state: shared-modified by threads #694, #695
+  Reason:    this thread, #695, holds no locks at all
+---------- double gran, 6 .. 92, skip 54 ----------
+
+Thread #696 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #697 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:396)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #696
+  New state: shared-modified by threads #696, #697
+  Reason:    this thread, #697, holds no locks at all
+---------- double gran, 7 .. 92, skip 55 ----------
+
+Thread #698 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #699 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:398)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #698
+  New state: shared-modified by threads #698, #699
+  Reason:    this thread, #699, holds no locks at all
+---------- double gran, 0 .. 92, skip 56 ----------
+
+Thread #700 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #701 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:400)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #700
+  New state: shared-modified by threads #700, #701
+  Reason:    this thread, #701, holds no locks at all
+---------- double gran, 1 .. 92, skip 57 ----------
+
+Thread #702 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #703 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:402)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #702
+  New state: shared-modified by threads #702, #703
+  Reason:    this thread, #703, holds no locks at all
+---------- double gran, 2 .. 92, skip 58 ----------
+
+Thread #704 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #705 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:404)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #704
+  New state: shared-modified by threads #704, #705
+  Reason:    this thread, #705, holds no locks at all
+---------- double gran, 3 .. 92, skip 59 ----------
+
+Thread #706 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #707 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:406)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #706
+  New state: shared-modified by threads #706, #707
+  Reason:    this thread, #707, holds no locks at all
+---------- double gran, 4 .. 92, skip 60 ----------
+
+Thread #708 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #709 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #708
+  New state: shared-modified by threads #708, #709
+  Reason:    this thread, #709, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:408)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #708
+  New state: shared-modified by threads #708, #709
+  Reason:    this thread, #709, holds no locks at all
+---------- double gran, 5 .. 92, skip 61 ----------
+
+Thread #710 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #711 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:410)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #710
+  New state: shared-modified by threads #710, #711
+  Reason:    this thread, #711, holds no locks at all
+---------- double gran, 6 .. 92, skip 62 ----------
+
+Thread #712 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #713 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:412)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #712
+  New state: shared-modified by threads #712, #713
+  Reason:    this thread, #713, holds no locks at all
+---------- double gran, 7 .. 92, skip 63 ----------
+
+Thread #714 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #715 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:414)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #714
+  New state: shared-modified by threads #714, #715
+  Reason:    this thread, #715, holds no locks at all
+---------- double gran, 0 .. 92, skip 64 ----------
+
+Thread #716 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #717 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:416)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #716
+  New state: shared-modified by threads #716, #717
+  Reason:    this thread, #717, holds no locks at all
+---------- double gran, 1 .. 92, skip 65 ----------
+
+Thread #718 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #719 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:418)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #718
+  New state: shared-modified by threads #718, #719
+  Reason:    this thread, #719, holds no locks at all
+---------- double gran, 2 .. 92, skip 66 ----------
+
+Thread #720 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #721 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:420)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #720
+  New state: shared-modified by threads #720, #721
+  Reason:    this thread, #721, holds no locks at all
+---------- double gran, 3 .. 92, skip 67 ----------
+
+Thread #722 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #723 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:422)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #722
+  New state: shared-modified by threads #722, #723
+  Reason:    this thread, #723, holds no locks at all
+---------- double gran, 4 .. 92, skip 68 ----------
+
+Thread #724 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #725 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #724
+  New state: shared-modified by threads #724, #725
+  Reason:    this thread, #725, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:424)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #724
+  New state: shared-modified by threads #724, #725
+  Reason:    this thread, #725, holds no locks at all
+---------- double gran, 5 .. 92, skip 69 ----------
+
+Thread #726 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #727 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:426)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #726
+  New state: shared-modified by threads #726, #727
+  Reason:    this thread, #727, holds no locks at all
+---------- double gran, 6 .. 92, skip 70 ----------
+
+Thread #728 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #729 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:428)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #728
+  New state: shared-modified by threads #728, #729
+  Reason:    this thread, #729, holds no locks at all
+---------- double gran, 7 .. 92, skip 71 ----------
+
+Thread #730 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #731 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:430)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #730
+  New state: shared-modified by threads #730, #731
+  Reason:    this thread, #731, holds no locks at all
+---------- double gran, 0 .. 92, skip 72 ----------
+
+Thread #732 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #733 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:432)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #732
+  New state: shared-modified by threads #732, #733
+  Reason:    this thread, #733, holds no locks at all
+---------- double gran, 1 .. 92, skip 73 ----------
+
+Thread #734 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #735 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:434)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #734
+  New state: shared-modified by threads #734, #735
+  Reason:    this thread, #735, holds no locks at all
+---------- double gran, 2 .. 92, skip 74 ----------
+
+Thread #736 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #737 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:436)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #736
+  New state: shared-modified by threads #736, #737
+  Reason:    this thread, #737, holds no locks at all
+---------- double gran, 3 .. 92, skip 75 ----------
+
+Thread #738 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #739 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:438)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #738
+  New state: shared-modified by threads #738, #739
+  Reason:    this thread, #739, holds no locks at all
+---------- double gran, 4 .. 92, skip 76 ----------
+
+Thread #740 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #741 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #740
+  New state: shared-modified by threads #740, #741
+  Reason:    this thread, #741, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:440)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #740
+  New state: shared-modified by threads #740, #741
+  Reason:    this thread, #741, holds no locks at all
+---------- double gran, 5 .. 92, skip 77 ----------
+
+Thread #742 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #743 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:442)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #742
+  New state: shared-modified by threads #742, #743
+  Reason:    this thread, #743, holds no locks at all
+---------- double gran, 6 .. 92, skip 78 ----------
+
+Thread #744 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #745 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:444)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #744
+  New state: shared-modified by threads #744, #745
+  Reason:    this thread, #745, holds no locks at all
+---------- double gran, 7 .. 92, skip 79 ----------
+
+Thread #746 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #747 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:446)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #746
+  New state: shared-modified by threads #746, #747
+  Reason:    this thread, #747, holds no locks at all
+---------- double gran, 0 .. 92, skip 80 ----------
+
+Thread #748 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #749 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:448)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #748
+  New state: shared-modified by threads #748, #749
+  Reason:    this thread, #749, holds no locks at all
+---------- double gran, 1 .. 92, skip 81 ----------
+
+Thread #750 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #751 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:450)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #750
+  New state: shared-modified by threads #750, #751
+  Reason:    this thread, #751, holds no locks at all
+---------- double gran, 2 .. 92, skip 82 ----------
+
+Thread #752 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #753 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:452)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #752
+  New state: shared-modified by threads #752, #753
+  Reason:    this thread, #753, holds no locks at all
+---------- double gran, 3 .. 92, skip 83 ----------
+
+Thread #754 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #755 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:454)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #754
+  New state: shared-modified by threads #754, #755
+  Reason:    this thread, #755, holds no locks at all
+---------- double gran, 4 .. 92, skip 84 ----------
+
+Thread #756 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #757 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #756
+  New state: shared-modified by threads #756, #757
+  Reason:    this thread, #757, holds no locks at all
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:456)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #756
+  New state: shared-modified by threads #756, #757
+  Reason:    this thread, #757, holds no locks at all
+---------- double gran, 5 .. 92, skip 85 ----------
+
+Thread #758 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #759 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:458)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #758
+  New state: shared-modified by threads #758, #759
+  Reason:    this thread, #759, holds no locks at all
+---------- double gran, 6 .. 92, skip 86 ----------
+
+Thread #760 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #761 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:460)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #760
+  New state: shared-modified by threads #760, #761
+  Reason:    this thread, #761, holds no locks at all
+---------- double gran, 7 .. 92, skip 87 ----------
+
+Thread #762 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #763 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:462)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #762
+  New state: shared-modified by threads #762, #763
+  Reason:    this thread, #763, holds no locks at all
+---------- double gran, 0 .. 92, skip 88 ----------
+
+Thread #764 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #765 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 8 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:464)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #764
+  New state: shared-modified by threads #764, #765
+  Reason:    this thread, #765, holds no locks at all
+---------- double gran, 1 .. 92, skip 89 ----------
+
+Thread #766 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #767 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:466)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #766
+  New state: shared-modified by threads #766, #767
+  Reason:    this thread, #767, holds no locks at all
+---------- double gran, 2 .. 92, skip 90 ----------
+
+Thread #768 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #769 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:468)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #768
+  New state: shared-modified by threads #768, #769
+  Reason:    this thread, #769, holds no locks at all
+---------- double gran, 3 .. 92, skip 91 ----------
+
+Thread #770 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:265)
+
+Thread #771 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc19_shadowmem.c:266)
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+Possible data race during write of size 1 at 0x........
+   at 0x........: child64 (tc19_shadowmem.c:107)
+   by 0x........: steer (tc19_shadowmem.c:470)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: owned exclusively by thread #770
+  New state: shared-modified by threads #770, #771
+  Reason:    this thread, #771, holds no locks at all
+
+ERROR SUMMARY: 1004 errors from 1004 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc19_shadowmem.stdout.exp b/helgrind/tests/tc19_shadowmem.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.stdout.exp
diff --git a/helgrind/tests/tc19_shadowmem.vgtest b/helgrind/tests/tc19_shadowmem.vgtest
new file mode 100644
index 0000000..233e8e4
--- /dev/null
+++ b/helgrind/tests/tc19_shadowmem.vgtest
@@ -0,0 +1,2 @@
+prog: tc19_shadowmem
+vgopts: --cmp-race-err-addrs=yes --error-limit=no
diff --git a/helgrind/tests/tc20_verifywrap.c b/helgrind/tests/tc20_verifywrap.c
new file mode 100644
index 0000000..81ea512
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.c
@@ -0,0 +1,262 @@
+
+/* This program attempts to verify that all functions that are
+   supposed to be wrapped by tc_intercepts.c really are wrapped.  The
+   main way it does this is to cause failures in those functions, so
+   as to obtain various error messages which imply that the wrapper
+   really did engage.
+
+   Any regressions shown up by this program are potentially serious
+   and should be investigated carefully. */
+
+/* Needed for older glibcs (2.3 and older, at least) who don't
+   otherwise "know" about some more exotic pthread stuff, in this case
+   PTHREAD_MUTEX_ERRORCHECK. */
+#define _GNU_SOURCE 1
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+#if !defined(__GLIBC_PREREQ)
+# error "This program needs __GLIBC_PREREQ (in /usr/include/features.h)"
+#endif
+
+short unprotected = 0;
+
+void* lazy_child ( void* v ) {
+   assert(0); /* does not run */
+}
+
+void* racy_child ( void* v ) {
+   unprotected = 1234;
+   return NULL;
+}
+
+int main ( void )
+{
+   int r;
+   /* pthread_t thr; */
+   /* pthread_attr_t thra; */
+   pthread_mutexattr_t mxa, mxa2;
+   pthread_mutex_t mx, mx2, mx3, mx4;
+   pthread_cond_t cv;
+   struct timespec abstime;
+   pthread_rwlock_t rwl;
+   pthread_rwlock_t rwl2;
+   pthread_rwlock_t rwl3;
+   sem_t s1;
+
+#  if __GLIBC_PREREQ(2,4)
+   fprintf(stderr, 
+           "\n\n------ This is output for >= glibc 2.4 ------\n");
+#  else
+   fprintf(stderr,
+           "\n\n------ This is output for < glibc 2.4 ------\n");
+#  endif
+
+   /* --------- pthread_create/join --------- */
+
+   fprintf(stderr,
+   "\n---------------- pthread_create/join ----------------\n\n");
+
+   /* make pthread_create fail */
+   /* It's amazingly difficult to make pthread_create fail
+      without first soaking up all the machine's resources.
+      Instead, in order to demonstrate that it's really wrapped,
+      create a child thread, generate a race error, and join with it
+      again. */
+   /* This just segfaults:
+      memset( &thra, 0xFF, sizeof(thra) );
+      r= pthread_create( &thr, NULL, lazy_child, NULL ); assert(r);
+   */
+   { pthread_t child;
+     r= pthread_create( &child, NULL, racy_child, NULL ); assert(!r);
+     sleep(1); /* just to ensure parent thread reports race, not child */
+     unprotected = 5678;
+     r= pthread_join( child, NULL ); assert(!r);
+   }
+
+   /* make pthread_join fail */
+   r= pthread_join( pthread_self(), NULL ); assert(r);
+
+   /* --------- pthread_mutex_lock et al --------- */
+
+   fprintf(stderr,
+   "\n---------------- pthread_mutex_lock et al ----------------\n\n");
+
+   /* make pthread_mutex_init fail */
+   memset( &mxa, 0xFF, sizeof(mxa) );
+   r= pthread_mutex_init( &mx, &mxa );
+#  if __GLIBC_PREREQ(2,4)
+   assert(r); /* glibc >= 2.4: the call should fail */
+#  else
+   assert(!r); /* glibc < 2.4: oh well, glibc didn't bounce this */
+#  endif
+
+   /* make pthread_mutex_destroy fail */
+   r= pthread_mutex_init( &mx2, NULL ); assert(!r);
+   r= pthread_mutex_lock( &mx2 ); assert(!r);
+   r= pthread_mutex_destroy( &mx2 ); assert(r);
+
+   /* make pthread_mutex_lock fail (skipped on < glibc 2.4 because it
+      doesn't fail, hence hangs the test) */
+#  if __GLIBC_PREREQ(2,4)
+   memset( &mx3, 0xFF, sizeof(mx3) );
+   r= pthread_mutex_lock( &mx3 ); assert(r);
+#  else
+   fprintf(stderr, "\nmake pthread_mutex_lock fail: "
+                   "skipped on glibc < 2.4\n\n");
+#  endif
+
+   /* make pthread_mutex_trylock fail */
+   memset( &mx3, 0xFF, sizeof(mx3) );
+   r= pthread_mutex_trylock( &mx3 ); assert(r);
+
+   /* make pthread_mutex_timedlock fail */
+   memset( &abstime, 0, sizeof(abstime) );
+   memset( &mx3, 0xFF, sizeof(mx3) );
+   r= pthread_mutex_timedlock( &mx3, &abstime ); assert(r);
+
+   /* make pthread_mutex_unlock fail */
+   memset( &mx3, 0xFF, sizeof(mx3) );
+   r= pthread_mutex_unlock( &mx3 );
+#  if __GLIBC_PREREQ(2,4)
+   assert(r);
+#  else
+   assert(!r);
+#  endif
+
+   /* --------- pthread_cond_wait et al --------- */
+
+   fprintf(stderr,
+   "\n---------------- pthread_cond_wait et al ----------------\n\n");
+
+   /* make pthread_cond_wait fail.  This is difficult.  Our cunning
+      plan (tm) is to show up at pthread_cond_wait bearing a
+      not-locked mutex of the ERRORCHECK flavour and hope (as is
+      indeed the case with glibc-2.5) that pthread_cond_wait notices
+      it is not locked, and bounces our request. */
+   r= pthread_mutexattr_init( &mxa2 ); assert(!r);
+   r= pthread_mutexattr_settype( &mxa2, PTHREAD_MUTEX_ERRORCHECK );
+      assert(!r);
+   r= pthread_mutex_init( &mx4, &mxa2 ); assert(!r);
+   r= pthread_cond_init( &cv, NULL ); assert(!r);
+   r= pthread_cond_wait( &cv, &mx4 ); assert(r);
+   r= pthread_mutexattr_destroy( &mxa2 ); assert(!r);
+
+   /* make pthread_cond_signal fail.  FIXME: can't figure out how
+      to */
+   r= pthread_cond_signal( &cv ); assert(!r);
+   fprintf(stderr, "\nFIXME: can't figure out how to "
+                   "verify wrap of pthread_cond_signal\n\n");
+
+   /* make pthread_cond_broadcast fail.  FIXME: can't figure out how
+      to */
+   r= pthread_cond_broadcast( &cv ); assert(!r);
+   fprintf(stderr, "\nFIXME: can't figure out how to "
+                   "verify wrap of pthread_broadcast_signal\n\n");
+
+   /* make pthread_cond_timedwait fail. */
+   memset( &abstime, 0, sizeof(abstime) );
+   abstime.tv_nsec = 1000000000 + 1;
+   r= pthread_cond_timedwait( &cv, &mx4, &abstime ); assert(r);
+
+   /* --------- pthread_rwlock_* --------- */
+
+   fprintf(stderr,
+   "\n---------------- pthread_rwlock_* ----------------\n\n");
+
+   /* pthread_rwlock_init, pthread_rwlock_unlock */
+   /* pthread_rwlock_init: can't make glibc's implementation fail.
+      However, can demonstrate interceptedness by initialising but not
+      locking a lock and then unlocking it.  Then the unlock call
+      should say "first seen at .. the init call."  So this tests
+      wrappedness of both calls. */
+   r= pthread_rwlock_init( &rwl, NULL ); assert(!r);
+   r= pthread_rwlock_unlock( &rwl ); 
+   /* assert(r); *//* glibc doesn't complain.  It really ought to. Oh well. */
+
+   /* We can infer the presence of wrapping for pthread_rwlock_rdlock,
+      pthread_rwlock_wrlock and pthread_rwlock_unlock by making
+      Thrcheck count the lockedness state, and warning when we unlock
+      a not-locked lock.  Thusly: */
+   r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
+
+   /* w-lock it */
+   fprintf(stderr, "(1) no error on next line\n");
+   r= pthread_rwlock_wrlock( &rwl2 ); assert(!r);
+   /* unlock it */
+   fprintf(stderr, "(2) no error on next line\n");
+   r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+   /* unlock it again, get an error */
+   fprintf(stderr, "(3)    ERROR on next line\n");
+   r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+
+   /* same game with r-locks */
+   r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
+   /* r-lock it twice */
+   fprintf(stderr, "(4) no error on next line\n");
+   r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
+   fprintf(stderr, "(5) no error on next line\n");
+   r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
+   /* unlock it twice */
+   fprintf(stderr, "(6) no error on next line\n");
+   r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+   fprintf(stderr, "(7) no error on next line\n");
+   r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+   /* unlock it again, get an error */
+   fprintf(stderr, "(8)    ERROR on next line\n");
+   r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
+
+   /* Lock rwl3 so the locked-lock-at-dealloc check can complain about
+      it. */
+   r= pthread_rwlock_init( &rwl3, NULL ); assert(!r);
+   r= pthread_rwlock_rdlock( &rwl3 ); assert(!r);
+
+   /* ------------- sem_* ------------- */
+
+   /* This is pretty lame, and duplicates tc18_semabuse.c. */
+
+   fprintf(stderr,
+   "\n---------------- sem_* ----------------\n\n");
+
+   /* verifies wrap of sem_init */
+   /* Do sem_init with huge initial count - fails */
+   r= sem_init(&s1, 0, ~0); assert(r);
+
+   /* initialise properly */
+   r= sem_init(&s1, 0, 0);
+
+   /* in glibc, sem_destroy is a no-op; making it fail is
+      impossible. */
+   fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
+                   "sem_destroy\n\n");
+
+   /* verifies wrap of sem_wait */
+   /* Do 'wait' on a bogus semaphore.  This should fail, but on glibc
+      it succeeds. */
+   memset(&s1, 0x55, sizeof(s1));
+   r= sem_wait(&s1); /* assert(r != 0); */
+
+   /* this really ought to fail, but it doesn't. */
+   r= sem_post(&s1); assert(!r);
+   fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
+                   "sem_post\n\n");
+
+   sem_destroy(&s1);
+
+   /* ------------- dealloc of mem holding locks ------------- */
+
+   fprintf(stderr,
+   "\n------------ dealloc of mem holding locks ------------\n\n");
+
+   /* At this point it should complain about deallocation
+      of memory containing locked locks:
+         rwl3
+   */
+
+   return 0;
+}
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64
new file mode 100644
index 0000000..df85c25
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc23-amd64
@@ -0,0 +1,134 @@
+
+
+
+------ This is output for < glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: main (tc20_verifywrap.c:78)
+  Old state: owned exclusively by thread #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+   with error code 35 (EDEADLK: Resource deadlock would occur)
+   at 0x........: pthread_join (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+   with error code 16 (EBUSY: Device or resource busy)
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+make pthread_mutex_lock fail: skipped on glibc < 2.4
+
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+   with error code 1 (EPERM: Operation not permitted)
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:179)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:196)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:212)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: sem_init@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+   at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+   by 0x........: sem_wait (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: main (tc20_verifywrap.c:262)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 15 errors from 15 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..0b399de
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-amd64
@@ -0,0 +1,156 @@
+
+
+
+------ This is output for >= glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: main (tc20_verifywrap.c:78)
+  Old state: owned exclusively by thread #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+   with error code 35 (EDEADLK: Resource deadlock would occur)
+   at 0x........: pthread_join (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1's call to pthread_mutex_init failed
+   with error code 95 (EOPNOTSUPP: Operation not supported on transport endpoint)
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:92)
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+   with error code 16 (EBUSY: Device or resource busy)
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_lock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:108)
+
+Thread #1's call to pthread_mutex_trylock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_trylock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:116)
+
+Thread #1's call to pthread_mutex_timedlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_timedlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:121)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:125)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+   with error code 1 (EPERM: Operation not permitted)
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:179)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:196)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:212)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: sem_init@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+   at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+   by 0x........: sem_wait (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: main (tc20_verifywrap.c:262)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 20 errors from 20 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86 b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..c44e998
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stderr.exp-glibc25-x86
@@ -0,0 +1,155 @@
+
+
+
+------ This is output for >= glibc 2.4 ------
+
+---------------- pthread_create/join ----------------
+
+Thread #1 is the program's root thread
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:76)
+
+Possible data race during write of size 2 at 0x........
+   at 0x........: main (tc20_verifywrap.c:78)
+  Old state: owned exclusively by thread #2
+  New state: shared-modified by threads #1, #2
+  Reason:    this thread, #1, holds no locks at all
+
+Thread #1's call to pthread_join failed
+   with error code 35 (EDEADLK: Resource deadlock would occur)
+   at 0x........: pthread_join (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:83)
+
+---------------- pthread_mutex_lock et al ----------------
+
+
+Thread #1's call to pthread_mutex_init failed
+   with error code 95 (EOPNOTSUPP: Operation not supported on transport endpoint)
+   at 0x........: pthread_mutex_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:92)
+
+Thread #1: pthread_mutex_destroy of a locked mutex
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_destroy failed
+   with error code 16 (EBUSY: Device or resource busy)
+   at 0x........: pthread_mutex_destroy (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:102)
+
+Thread #1's call to pthread_mutex_lock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_lock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:108)
+
+Thread #1's call to pthread_mutex_trylock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_trylock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:116)
+
+Thread #1's call to pthread_mutex_timedlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_timedlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:121)
+
+Thread #1 unlocked an invalid lock at 0x........ 
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:125)
+
+Thread #1's call to pthread_mutex_unlock failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_mutex_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:125)
+
+---------------- pthread_cond_wait et al ----------------
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+Thread #1's call to pthread_cond_wait failed
+   with error code 1 (EPERM: Operation not permitted)
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:147)
+
+FIXME: can't figure out how to verify wrap of pthread_cond_signal
+
+
+FIXME: can't figure out how to verify wrap of pthread_broadcast_signal
+
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+Thread #1's call to pthread_cond_timedwait failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: pthread_cond_timedwait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:165)
+
+---------------- pthread_rwlock_* ----------------
+
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:179)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:178)
+(1) no error on next line
+(2) no error on next line
+(3)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:196)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+(4) no error on next line
+(5) no error on next line
+(6) no error on next line
+(7) no error on next line
+(8)    ERROR on next line
+
+Thread #1 unlocked a not-locked lock at 0x........ 
+   at 0x........: pthread_rwlock_unlock (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:212)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:186)
+
+---------------- sem_* ----------------
+
+
+Thread #1's call to sem_init failed
+   with error code 22 (EINVAL: Invalid argument)
+   at 0x........: sem_init@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:228)
+
+FIXME: can't figure out how to verify wrap of sem_destroy
+
+
+Thread #1: Bug in libpthread: sem_wait succeeded on semaphore without prior sem_post
+   at 0x........: sem_wait_WRK (hg_intercepts.c:...)
+   by 0x........: sem_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:242)
+
+FIXME: can't figure out how to verify wrap of sem_post
+
+
+------------ dealloc of mem holding locks ------------
+
+
+Thread #1 deallocated location 0x........ containing a locked lock
+   at 0x........: main (tc20_verifywrap.c:261)
+  Lock at 0x........ was first observed
+   at 0x........: pthread_rwlock_init (hg_intercepts.c:...)
+   by 0x........: main (tc20_verifywrap.c:216)
+
+ERROR SUMMARY: 20 errors from 20 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc20_verifywrap.stdout.exp b/helgrind/tests/tc20_verifywrap.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.stdout.exp
diff --git a/helgrind/tests/tc20_verifywrap.vgtest b/helgrind/tests/tc20_verifywrap.vgtest
new file mode 100644
index 0000000..bc61bd6
--- /dev/null
+++ b/helgrind/tests/tc20_verifywrap.vgtest
@@ -0,0 +1 @@
+prog: tc20_verifywrap
diff --git a/helgrind/tests/tc21_pthonce.c b/helgrind/tests/tc21_pthonce.c
new file mode 100644
index 0000000..69fac76
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.c
@@ -0,0 +1,96 @@
+
+/* This really exists to check that Thrcheck behaves plausibly
+   with pthread_once calls.  Which it appears to.
+
+   The original source of this program is as shown below, although it
+   has been modified somewhat.  See
+   http://www.oreilly.com/pub/a/oreilly/ask_tim/2001/codepolicy.html
+   for OReilly's policy on using bits of their code examples.
+*/
+
+
+/********************************************************
+ * An example source module to accompany...
+ *
+ * "Using POSIX Threads: Programming with Pthreads"
+ *     by Brad Nichols, Dick Buttlar, Jackie Farrell
+ *     O'Reilly & Associates, Inc.
+ *
+ ********************************************************
+ * once_exam.c
+ *
+ * An example of using the pthreads_once() call to execute an
+ * initialization procedure.
+ *
+ * A program spawns multiple threads and each one tries to
+ * execute the routine welcome() using the once call. Only
+ * the first thread into the once routine will actually
+ * execute welcome().
+ *
+ * The program's main thread synchronizes its exit with the
+ * exit of the threads using the pthread_join() operation.
+ *
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <assert.h>
+
+#include <pthread.h>
+
+/* With more than 2 threads, the precise error reports vary between
+   platforms, in terms of the number of races detected.  Make life
+   simple and just have 2 threads and so just 1 race. */
+#define  NUM_THREADS 2
+
+static pthread_once_t welcome_once_block = PTHREAD_ONCE_INIT;
+
+static int unprotected1 = 0;
+static int unprotected2 = 0;
+
+/* This is a hack: delay threads except the first enough so as to
+   ensure threads[0] gets to the pthread_once call first.  This is so
+   as to ensure that this test produces results which aren't
+   scheduling sensitive.  (sigh) */
+void maybe_stall ( int myid )
+{
+   assert(myid >= 0 && myid < NUM_THREADS);
+   if (myid > 0)
+      sleep(1);
+}
+
+void welcome(void) {
+   printf("welcome: Welcome\n");
+   unprotected1++; /* this is harmless */
+}
+
+void* child ( void* argV ) { 
+   int r; 
+   maybe_stall( *(int*)argV );
+   r= pthread_once(&welcome_once_block, welcome); assert(!r);
+   printf("child: Hi, I'm thread %d\n", *(int*)argV);
+   unprotected2++; /* whereas this is a race */
+   return NULL;
+}
+
+int main ( void ) {
+   int       *id_arg, i, r;
+   pthread_t threads[NUM_THREADS];
+
+   id_arg = (int *)malloc(NUM_THREADS*sizeof(int));
+
+   for (i = 0; i < NUM_THREADS; i++) {
+      id_arg[i] = i;
+      r= pthread_create(&threads[i], NULL, child, &id_arg[i]);
+      assert(!r);
+   }
+
+   for (i = 0; i < NUM_THREADS; i++) {
+      pthread_join(threads[i], NULL);
+      /* printf("main: joined to thread %d\n", i); */
+   }
+   printf("main: Goodbye\n");
+   return 0;
+}
diff --git a/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64 b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..4d0fd44
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-amd64
@@ -0,0 +1,26 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc21_pthonce.c:86)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc21_pthonce.c:86)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child (tc21_pthonce.c:74)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86 b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..f0b58a3
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stderr.exp-glibc25-x86
@@ -0,0 +1,24 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc21_pthonce.c:86)
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc21_pthonce.c:86)
+
+Possible data race during write of size 4 at 0x........
+   at 0x........: child (tc21_pthonce.c:74)
+   by 0x........: mythread_wrapper (hg_intercepts.c:...)
+   by 0x........: ...
+   by 0x........: ...
+  Old state: shared-readonly by threads #2, #3
+  New state: shared-modified by threads #2, #3
+  Reason:    this thread, #3, holds no consistent locks
+  Location 0x........ has never been protected by any lock
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc21_pthonce.stdout.exp b/helgrind/tests/tc21_pthonce.stdout.exp
new file mode 100644
index 0000000..e6c2dc2
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.stdout.exp
@@ -0,0 +1,4 @@
+welcome: Welcome
+child: Hi, I'm thread 0
+child: Hi, I'm thread 1
+main: Goodbye
diff --git a/helgrind/tests/tc21_pthonce.vgtest b/helgrind/tests/tc21_pthonce.vgtest
new file mode 100644
index 0000000..d9b9a81
--- /dev/null
+++ b/helgrind/tests/tc21_pthonce.vgtest
@@ -0,0 +1 @@
+prog: tc21_pthonce
diff --git a/helgrind/tests/tc22_exit_w_lock.c b/helgrind/tests/tc22_exit_w_lock.c
new file mode 100644
index 0000000..d40600e
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.c
@@ -0,0 +1,50 @@
+
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include <signal.h>
+
+/* Should see 3 threads exiting in different ways, all holding one (or
+   two) locks. */
+
+pthread_mutex_t mxC1  = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxC2  = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxC2b = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mxP   = PTHREAD_MUTEX_INITIALIZER;
+
+/* This one exits in the normal way, by joining back */
+void* child_fn1 ( void* arg )
+{
+  int r= pthread_mutex_lock( &mxC1 ); assert(!r);
+  return NULL;
+}
+
+/* This one detaches, does its own thing. */
+void* child_fn2 ( void* arg )
+{
+  int r;
+  r= pthread_mutex_lock( &mxC2 ); assert(!r);
+  r= pthread_mutex_lock( &mxC2b ); assert(!r);
+  r= pthread_detach( pthread_self() ); assert(!r);
+  return NULL;
+}
+
+/* Parent creates 2 children, takes a lock, waits, segfaults.  Use
+   sleeps to enforce exit ordering, for repeatable regtesting. */
+int main ( void )
+{
+   int r;
+   pthread_t child1, child2;
+
+   r= pthread_create(&child2, NULL, child_fn2, NULL); assert(!r);
+   sleep(1);
+
+   r= pthread_create(&child1, NULL, child_fn1, NULL); assert(!r);
+   r= pthread_join(child1, NULL); assert(!r);
+   sleep(1);
+
+   r= pthread_mutex_lock( &mxP );
+ 
+   kill( getpid(), SIGABRT );
+   return 0;
+}
diff --git a/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64 b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..f0eb6b6
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-amd64
@@ -0,0 +1,30 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc22_exit_w_lock.c:39)
+
+Thread #2: Exiting thread still holds 2 locks
+   at 0x........: start_thread (in /lib/libpthread...)
+   by 0x........: ...
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: ...
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc22_exit_w_lock.c:42)
+
+Thread #3: Exiting thread still holds 1 lock
+   at 0x........: start_thread (in /lib/libpthread...)
+   by 0x........: ...
+
+Thread #1 is the program's root thread
+
+Thread #1: Exiting thread still holds 1 lock
+   at 0x........: kill (in /...libc...)
+   by 0x........: main (tc22_exit_w_lock.c:48)
+
+ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86 b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..bc07725
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stderr.exp-glibc25-x86
@@ -0,0 +1,28 @@
+
+Thread #2 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc22_exit_w_lock.c:39)
+
+Thread #2: Exiting thread still holds 2 locks
+   at 0x........: start_thread (in /lib/libpthread...)
+   by 0x........: ...
+
+Thread #3 was created
+   at 0x........: clone (in /...libc...)
+   by 0x........: pthread_create@GLIBC_ (in /lib/libpthread...)
+   by 0x........: pthread_create@* (hg_intercepts.c:...)
+   by 0x........: main (tc22_exit_w_lock.c:42)
+
+Thread #3: Exiting thread still holds 1 lock
+   at 0x........: start_thread (in /lib/libpthread...)
+   by 0x........: ...
+
+Thread #1 is the program's root thread
+
+Thread #1: Exiting thread still holds 1 lock
+   at 0x........: kill (in /...libc...)
+   by 0x........: (below main) (in /...libc...)
+
+ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc22_exit_w_lock.stdout.exp b/helgrind/tests/tc22_exit_w_lock.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.stdout.exp
diff --git a/helgrind/tests/tc22_exit_w_lock.vgtest b/helgrind/tests/tc22_exit_w_lock.vgtest
new file mode 100644
index 0000000..4f85dd5
--- /dev/null
+++ b/helgrind/tests/tc22_exit_w_lock.vgtest
@@ -0,0 +1 @@
+prog: tc22_exit_w_lock
diff --git a/helgrind/tests/tc23_bogus_condwait.c b/helgrind/tests/tc23_bogus_condwait.c
new file mode 100644
index 0000000..a0fad5d
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.c
@@ -0,0 +1,86 @@
+
+/* Expect 5 errors total (4 re cvs, 1 re exiting w/lock.).
+   Tests passing bogus mutexes to pthread_cond_wait. */
+#define _GNU_SOURCE 1 /* needed by glibc <= 2.3 for pthread_rwlock_* */
+#include <pthread.h>
+#include <assert.h>
+#include <unistd.h>
+#include <semaphore.h>
+
+pthread_mutex_t mx[4];
+pthread_cond_t cv;
+pthread_rwlock_t rwl;
+
+sem_t quit_now;
+
+void* rescue_me ( void* uu )
+{
+  /* wait for, and unblock, the first wait */
+  sleep(1);
+  pthread_cond_signal( &cv );
+
+  /* wait for, and unblock, the second wait */
+  sleep(1);
+  pthread_cond_signal( &cv );
+
+  /* wait for, and unblock, the third wait */
+  sleep(1);
+  pthread_cond_signal( &cv );
+
+  /* wait for, and unblock, the fourth wait */
+  sleep(1);
+  pthread_cond_signal( &cv );
+
+  sem_wait( &quit_now );
+  return NULL;
+}
+
+void* grab_the_lock ( void* uu )
+{
+   int r= pthread_mutex_lock( &mx[2] ); assert(!r);
+   sem_wait( &quit_now );
+   r= pthread_mutex_unlock( &mx[2] ); assert(!r);
+   return NULL;
+}
+
+int main ( void )
+{
+  int r;
+  pthread_t my_rescuer, grabber;
+
+  r= pthread_mutex_init(&mx[0], NULL); assert(!r);
+  r= pthread_mutex_init(&mx[1], NULL); assert(!r);
+  r= pthread_mutex_init(&mx[2], NULL); assert(!r);
+  r= pthread_mutex_init(&mx[3], NULL); assert(!r);
+
+  r= pthread_cond_init(&cv, NULL); assert(!r);
+  r= pthread_rwlock_init(&rwl, NULL); assert(!r);
+
+  r= sem_init( &quit_now, 0,0 ); assert(!r);
+
+  r= pthread_create( &grabber, NULL, grab_the_lock, NULL ); assert(!r);
+  sleep(1); /* let the grabber get there first */
+
+  r= pthread_create( &my_rescuer, NULL, rescue_me, NULL );  assert(!r);
+  /* Do stupid things and hope that rescue_me gets us out of
+     trouble */
+
+  /* mx is bogus */
+  r= pthread_cond_wait(&cv, (pthread_mutex_t*)(1 + (char*)&mx[0]) );
+
+  /* mx is not locked */
+  r= pthread_cond_wait(&cv, &mx[0]);
+
+  /* wrong flavour of lock */
+  r= pthread_cond_wait(&cv, (pthread_mutex_t*)&rwl );
+
+  /* mx is held by someone else. */
+  r= pthread_cond_wait(&cv, &mx[2] );
+
+  r= sem_post( &quit_now ); assert(!r);
+  r= sem_post( &quit_now ); assert(!r);
+
+  r= pthread_join( my_rescuer, NULL ); assert(!r);
+  r= pthread_join( grabber, NULL ); assert(!r);
+  return 0;
+}
diff --git a/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64 b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64
new file mode 100644
index 0000000..2bb66de
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-amd64
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: pthread_cond_{timed}wait called with invalid mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:69)
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:72)
+
+Thread #1: pthread_cond_{timed}wait called with mutex of type pthread_rwlock_t*
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:75)
+
+Thread #1: pthread_cond_{timed}wait called with mutex held by a different thread
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:78)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86 b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86
new file mode 100644
index 0000000..2bb66de
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stderr.exp-glibc25-x86
@@ -0,0 +1,20 @@
+
+Thread #1 is the program's root thread
+
+Thread #1: pthread_cond_{timed}wait called with invalid mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:69)
+
+Thread #1: pthread_cond_{timed}wait called with un-held mutex
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:72)
+
+Thread #1: pthread_cond_{timed}wait called with mutex of type pthread_rwlock_t*
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:75)
+
+Thread #1: pthread_cond_{timed}wait called with mutex held by a different thread
+   at 0x........: pthread_cond_wait@* (hg_intercepts.c:...)
+   by 0x........: main (tc23_bogus_condwait.c:78)
+
+ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)
diff --git a/helgrind/tests/tc23_bogus_condwait.stdout.exp b/helgrind/tests/tc23_bogus_condwait.stdout.exp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.stdout.exp
diff --git a/helgrind/tests/tc23_bogus_condwait.vgtest b/helgrind/tests/tc23_bogus_condwait.vgtest
new file mode 100644
index 0000000..31c3ed8
--- /dev/null
+++ b/helgrind/tests/tc23_bogus_condwait.vgtest
@@ -0,0 +1 @@
+prog: tc23_bogus_condwait