diff --git a/gen/gen.ml b/gen/gen.ml
index cb505d1..1c3b7ee 100755
--- a/gen/gen.ml
+++ b/gen/gen.ml
@@ -98,12 +98,12 @@ let copyf : i -> (('a -> 'b, unit, string) format) = function
   | F -> "caml_copy_double(%s)"
   | I8 -> "copy_int8(%s)"
   | I16 -> "copy_int16(%s)"
-  | I24 -> "copy_int32((%s) << 8)"
-  | I32 -> "copy_int32(%s)"
-  | I40 -> "copy_int64((%s) << 24)"
-  | I48 -> "copy_int64((%s) << 16)"
-  | I56 -> "copy_int64((%s) << 8)"
-  | I64 -> "copy_int64(%s)"
+  | I24 -> "caml_copy_int32((%s) << 8)"
+  | I32 -> "caml_copy_int32(%s)"
+  | I40 -> "caml_copy_int64((%s) << 24)"
+  | I48 -> "caml_copy_int64((%s) << 16)"
+  | I56 -> "caml_copy_int64((%s) << 8)"
+  | I64 -> "caml_copy_int64(%s)"
   | I128 -> "copy_int128(%s)"
   | U8 -> "copy_uint8(%s)"
   | U16 -> "copy_uint16(%s)"
diff --git a/lib/int32_conv.c b/lib/int32_conv.c
index 89cee8a..73d20a6 100644
--- a/lib/int32_conv.c
+++ b/lib/int32_conv.c
@@ -1,3 +1,5 @@
+#define CAML_NAME_SPACE
+
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,70 +32,70 @@ CAMLprim value
 int32_of_int(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Long_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Long_val(v)));
 }
 
 CAMLprim value
 int32_of_nativeint(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Nativeint_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Nativeint_val(v)));
 }
 
 CAMLprim value
 int32_of_float(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Double_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Double_val(v)));
 }
 
 CAMLprim value
 int32_of_int8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int8_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int8_val(v)));
 }
 
 CAMLprim value
 int32_of_int16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int16_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int16_val(v)));
 }
 
 CAMLprim value
 int32_of_int24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int24_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int24_val(v)));
 }
 
 CAMLprim value
 int32_of_int40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int40_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int40_val(v)));
 }
 
 CAMLprim value
 int32_of_int48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int48_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int48_val(v)));
 }
 
 CAMLprim value
 int32_of_int56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int56_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int56_val(v)));
 }
 
 CAMLprim value
 int32_of_int64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Int64_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int64_val(v)));
 }
 
 CAMLprim value
@@ -101,7 +103,7 @@ int32_of_int128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_INT128
-  CAMLreturn (copy_int32((int32_t)Int128_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Int128_val(v)));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
@@ -112,56 +114,56 @@ CAMLprim value
 int32_of_uint8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint8_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint8_val(v)));
 }
 
 CAMLprim value
 int32_of_uint16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint16_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint16_val(v)));
 }
 
 CAMLprim value
 int32_of_uint24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint24_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint24_val(v)));
 }
 
 CAMLprim value
 int32_of_uint32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint32_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint32_val(v)));
 }
 
 CAMLprim value
 int32_of_uint40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint40_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint40_val(v)));
 }
 
 CAMLprim value
 int32_of_uint48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint48_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint48_val(v)));
 }
 
 CAMLprim value
 int32_of_uint56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint56_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint56_val(v)));
 }
 
 CAMLprim value
 int32_of_uint64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int32((int32_t)Uint64_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint64_val(v)));
 }
 
 CAMLprim value
@@ -169,7 +171,7 @@ int32_of_uint128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_UINT128
-  CAMLreturn (copy_int32((int32_t)Uint128_val(v)));
+  CAMLreturn (caml_copy_int32((int32_t)Uint128_val(v)));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
diff --git a/lib/int40.h b/lib/int40.h
index 7d23df5..22ab086 100644
--- a/lib/int40.h
+++ b/lib/int40.h
@@ -3,6 +3,6 @@
 
 #define Int40_val(v) ((*((int64_t *)Data_custom_val(v))) >> 24)
 
-#define copy_int40(v) copy_int64(v)
+#define copy_int40(v) caml_copy_int64(v)
 
 #endif
diff --git a/lib/int40_conv.c b/lib/int40_conv.c
index b3c56ff..e8c7d91 100644
--- a/lib/int40_conv.c
+++ b/lib/int40_conv.c
@@ -1,3 +1,5 @@
+#define CAML_NAME_SPACE
+
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,70 +32,70 @@ CAMLprim value
 int40_of_int(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Long_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Long_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_nativeint(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Nativeint_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Nativeint_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_float(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Double_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Double_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int8_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int8_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int16_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int16_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int24_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int24_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int32_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int32_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int48_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int48_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int56_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int56_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_int64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int64_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int64_val(v)) << 24));
 }
 
 CAMLprim value
@@ -101,7 +103,7 @@ int40_of_int128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_INT128
-  CAMLreturn (copy_int64(((int64_t)Int128_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Int128_val(v)) << 24));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
@@ -112,56 +114,56 @@ CAMLprim value
 int40_of_uint8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint8_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint8_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint16_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint16_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint24_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint24_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint32_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint32_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint40_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint40_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint48_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint48_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint56_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint56_val(v)) << 24));
 }
 
 CAMLprim value
 int40_of_uint64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint64_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint64_val(v)) << 24));
 }
 
 CAMLprim value
@@ -169,7 +171,7 @@ int40_of_uint128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_UINT128
-  CAMLreturn (copy_int64(((int64_t)Uint128_val(v)) << 24));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint128_val(v)) << 24));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
diff --git a/lib/int48.h b/lib/int48.h
index 4a58f01..c1b8d64 100644
--- a/lib/int48.h
+++ b/lib/int48.h
@@ -3,6 +3,6 @@
 
 #define Int48_val(v) ((*((int64_t *)Data_custom_val(v))) >> 16)
 
-#define copy_int48(v) copy_int64(v)
+#define copy_int48(v) caml_copy_int64(v)
 
 #endif
diff --git a/lib/int48_conv.c b/lib/int48_conv.c
index 37b1cca..115e9fc 100644
--- a/lib/int48_conv.c
+++ b/lib/int48_conv.c
@@ -1,3 +1,5 @@
+#define CAML_NAME_SPACE
+
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,70 +32,70 @@ CAMLprim value
 int48_of_int(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Long_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Long_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_nativeint(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Nativeint_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Nativeint_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_float(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Double_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Double_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int8_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int8_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int16_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int16_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int24_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int24_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int32_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int32_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int40_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int40_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int56_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int56_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_int64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int64_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int64_val(v)) << 16));
 }
 
 CAMLprim value
@@ -101,7 +103,7 @@ int48_of_int128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_INT128
-  CAMLreturn (copy_int64(((int64_t)Int128_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Int128_val(v)) << 16));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
@@ -112,56 +114,56 @@ CAMLprim value
 int48_of_uint8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint8_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint8_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint16_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint16_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint24_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint24_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint32_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint32_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint40_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint40_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint48_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint48_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint56_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint56_val(v)) << 16));
 }
 
 CAMLprim value
 int48_of_uint64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint64_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint64_val(v)) << 16));
 }
 
 CAMLprim value
@@ -169,7 +171,7 @@ int48_of_uint128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_UINT128
-  CAMLreturn (copy_int64(((int64_t)Uint128_val(v)) << 16));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint128_val(v)) << 16));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
diff --git a/lib/int56.h b/lib/int56.h
index 16503e1..013b47e 100644
--- a/lib/int56.h
+++ b/lib/int56.h
@@ -3,6 +3,6 @@
 
 #define Int56_val(v) ((*((int64_t *)Data_custom_val(v))) >> 8)
 
-#define copy_int56(v) copy_int64(v)
+#define copy_int56(v) caml_copy_int64(v)
 
 #endif
diff --git a/lib/int56_conv.c b/lib/int56_conv.c
index fd8f5bc..a9f77aa 100644
--- a/lib/int56_conv.c
+++ b/lib/int56_conv.c
@@ -1,3 +1,5 @@
+#define CAML_NAME_SPACE
+
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,70 +32,70 @@ CAMLprim value
 int56_of_int(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Long_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Long_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_nativeint(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Nativeint_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Nativeint_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_float(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Double_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Double_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int8_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int8_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int16_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int16_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int24_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int24_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int32_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int32_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int40_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int40_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int48_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int48_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_int64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Int64_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int64_val(v)) << 8));
 }
 
 CAMLprim value
@@ -101,7 +103,7 @@ int56_of_int128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_INT128
-  CAMLreturn (copy_int64(((int64_t)Int128_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Int128_val(v)) << 8));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
@@ -112,56 +114,56 @@ CAMLprim value
 int56_of_uint8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint8_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint8_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint16_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint16_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint24_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint24_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint32_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint32_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint40_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint40_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint48_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint48_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint56_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint56_val(v)) << 8));
 }
 
 CAMLprim value
 int56_of_uint64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64(((int64_t)Uint64_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint64_val(v)) << 8));
 }
 
 CAMLprim value
@@ -169,7 +171,7 @@ int56_of_uint128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_UINT128
-  CAMLreturn (copy_int64(((int64_t)Uint128_val(v)) << 8));
+  CAMLreturn (caml_copy_int64(((int64_t)Uint128_val(v)) << 8));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
diff --git a/lib/int64_conv.c b/lib/int64_conv.c
index 5fe3992..2134384 100644
--- a/lib/int64_conv.c
+++ b/lib/int64_conv.c
@@ -1,3 +1,5 @@
+#define CAML_NAME_SPACE
+
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,70 +32,70 @@ CAMLprim value
 int64_of_int(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Long_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Long_val(v)));
 }
 
 CAMLprim value
 int64_of_nativeint(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Nativeint_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Nativeint_val(v)));
 }
 
 CAMLprim value
 int64_of_float(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Double_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Double_val(v)));
 }
 
 CAMLprim value
 int64_of_int8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int8_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int8_val(v)));
 }
 
 CAMLprim value
 int64_of_int16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int16_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int16_val(v)));
 }
 
 CAMLprim value
 int64_of_int24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int24_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int24_val(v)));
 }
 
 CAMLprim value
 int64_of_int32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int32_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int32_val(v)));
 }
 
 CAMLprim value
 int64_of_int40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int40_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int40_val(v)));
 }
 
 CAMLprim value
 int64_of_int48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int48_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int48_val(v)));
 }
 
 CAMLprim value
 int64_of_int56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Int56_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int56_val(v)));
 }
 
 CAMLprim value
@@ -101,7 +103,7 @@ int64_of_int128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_INT128
-  CAMLreturn (copy_int64((int64_t)Int128_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Int128_val(v)));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);
@@ -112,56 +114,56 @@ CAMLprim value
 int64_of_uint8(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint8_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint8_val(v)));
 }
 
 CAMLprim value
 int64_of_uint16(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint16_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint16_val(v)));
 }
 
 CAMLprim value
 int64_of_uint24(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint24_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint24_val(v)));
 }
 
 CAMLprim value
 int64_of_uint32(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint32_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint32_val(v)));
 }
 
 CAMLprim value
 int64_of_uint40(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint40_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint40_val(v)));
 }
 
 CAMLprim value
 int64_of_uint48(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint48_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint48_val(v)));
 }
 
 CAMLprim value
 int64_of_uint56(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint56_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint56_val(v)));
 }
 
 CAMLprim value
 int64_of_uint64(value v)
 {
   CAMLparam1(v);
-  CAMLreturn (copy_int64((int64_t)Uint64_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint64_val(v)));
 }
 
 CAMLprim value
@@ -169,7 +171,7 @@ int64_of_uint128(value v)
 {
   CAMLparam1(v);
 #ifdef HAVE_UINT128
-  CAMLreturn (copy_int64((int64_t)Uint128_val(v)));
+  CAMLreturn (caml_copy_int64((int64_t)Uint128_val(v)));
 #else
   failwith("unimplemented");
   CAMLreturn(Val_unit);