diff -u -r obrowser-1.1.orig/Makefile obrowser-1.1/Makefile
--- obrowser-1.1.orig/Makefile	2010-01-22 19:16:35.000000000 +0100
+++ obrowser-1.1/Makefile	2010-04-27 16:07:08.000000000 +0200
@@ -24,6 +24,7 @@
 	@echo "[EXAMPLE] $*"
 	@cd examples/$* && $(MAKE) --no-print-directory
 
+.PHONY: AXO
 AXO:
 	@echo "[AXO]"
 	@cd axo/ && $(MAKE) --no-print-directory
diff -u -r obrowser-1.1.orig/rt/caml/pervasives.ml obrowser-1.1/rt/caml/pervasives.ml
--- obrowser-1.1.orig/rt/caml/pervasives.ml	2010-01-22 19:16:35.000000000 +0100
+++ obrowser-1.1/rt/caml/pervasives.ml	2010-04-27 16:14:45.000000000 +0200
@@ -83,6 +83,8 @@
 external (/.) : float -> float -> float = "%divfloat"
 external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float"
 external exp : float -> float = "caml_exp_float" "exp" "float"
+external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float"
+external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float"
 external acos : float -> float = "caml_acos_float" "acos" "float"
 external asin : float -> float = "caml_asin_float" "asin" "float"
 external atan : float -> float = "caml_atan_float" "atan" "float"
diff -u -r obrowser-1.1.orig/rt/caml/pervasives.mli obrowser-1.1/rt/caml/pervasives.mli
--- obrowser-1.1.orig/rt/caml/pervasives.mli	2010-01-22 19:16:35.000000000 +0100
+++ obrowser-1.1/rt/caml/pervasives.mli	2010-04-27 16:18:35.000000000 +0200
@@ -264,6 +264,14 @@
 external log10 : float -> float = "caml_log10_float" "log10" "float"
 (** Base 10 logarithm. *)
 
+external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float"
+(** [expm1 x] computes [exp x -. 1.0], giving numerically-accurate results
+    even if [x] is close to [0.0]. *)
+
+external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float"
+(** [log1p x] computes [log(1.0 +. x)] (natural logarithm),
+    giving numerically-accurate results even if [x] is close to [0.0]. *)
+
 external cos : float -> float = "caml_cos_float" "cos" "float"
 (** See {!Pervasives.atan2}. *)
 
--- obrowser-1.1/rt/caml/pervasives.mli.orig	2010-07-23 16:15:49.000000000 +0200
+++ obrowser-1.1/rt/caml/pervasives.mli	2010-07-23 16:24:44.000000000 +0200
@@ -11,19 +11,20 @@
 (*                                                                     *)
 (***********************************************************************)
 
-(* $Id: pervasives.mli,v 1.113 2008/10/06 13:33:21 doligez Exp $ *)
+(* $Id: pervasives.mli 10548 2010-06-09 10:26:19Z weis $ *)
 
 (** The initially opened module.
 
    This module provides the basic operations over the built-in types
    (numbers, booleans, strings, exceptions, references, lists, arrays,
-   input-output channels, ...)
+   input-output channels, ...).
 
    This module is automatically opened at the beginning of each compilation.
    All components of this module can therefore be referred by their short
    name, without prefixing them by [Pervasives].
 *)
 
+
 (** {6 Exceptions} *)
 
 external raise : exn -> 'a = "%raise"
@@ -42,7 +43,6 @@
 
 (** {6 Comparisons} *)
 
-
 external ( = ) : 'a -> 'a -> bool = "%equal"
 (** [e1 = e2] tests for structural equality of [e1] and [e2].
    Mutable structures (e.g. references and arrays) are equal
@@ -71,7 +71,7 @@
    The ordering is compatible with [(=)]. As in the case
    of [(=)], mutable structures are compared by contents.
    Comparison between functional values raises [Invalid_argument].
-   Comparison between cyclic structures does not terminate. *)
+   Comparison between cyclic structures may not terminate. *)
 
 external compare : 'a -> 'a -> int = "%compare"
 (** [compare x y] returns [0] if [x] is equal to [y],
@@ -93,17 +93,22 @@
    the {!List.sort} and {!Array.sort} functions. *)
 
 val min : 'a -> 'a -> 'a
-(** Return the smaller of the two arguments. *)
+(** Return the smaller of the two arguments.
+    The result is unspecified if one of the arguments contains
+    the float value [nan]. *)
 
 val max : 'a -> 'a -> 'a
-(** Return the greater of the two arguments. *)
+(** Return the greater of the two arguments.
+    The result is unspecified if one of the arguments contains
+    the float value [nan]. *)
 
 external ( == ) : 'a -> 'a -> bool = "%eq"
 (** [e1 == e2] tests for physical equality of [e1] and [e2].
-   On integers and characters, physical equality is identical to structural
-   equality. On mutable structures, [e1 == e2] is true if and only if
-   physical modification of [e1] also affects [e2].
-   On non-mutable structures, the behavior of [(==)] is
+   On mutable types such as references, arrays, strings, records with
+   mutable fields and objects with mutable instance variables,
+   [e1 == e2] is true if and only if physical modification of [e1]
+   also affects [e2].
+   On non-mutable types, the behavior of [(==)] is
    implementation-dependent; however, it is guaranteed that
    [e1 == e2] implies [compare e1 e2 = 0]. *)
 
@@ -113,7 +118,6 @@
 
 (** {6 Boolean operations} *)
 
-
 external not : bool -> bool = "%boolnot"
 (** The boolean negation. *)
 
@@ -123,7 +127,7 @@
    [e2] is not evaluated at all. *)
 
 external ( & ) : bool -> bool -> bool = "%sequand"
-(** @deprecated {!Pervasives.(&&)} should be used instead. *)
+(** @deprecated {!Pervasives.( && )} should be used instead. *)
 
 external ( || ) : bool -> bool -> bool = "%sequor"
 (** The boolean ``or''. Evaluation is sequential, left-to-right:
@@ -131,7 +135,7 @@
    [e2] is not evaluated at all. *)
 
 external ( or ) : bool -> bool -> bool = "%sequor"
-(** @deprecated {!Pervasives.(||)} should be used instead.*)
+(** @deprecated {!Pervasives.( || )} should be used instead.*)
 
 
 (** {6 Integer arithmetic} *)
@@ -141,13 +145,18 @@
    They do not fail on overflow. *)
 
 external ( ~- ) : int -> int = "%negint"
-(** Unary negation. You can also write [-e] instead of [~-e]. *)
+(** Unary negation. You can also write [- e] instead of [~- e]. *)
+
+external ( ~+ ) : int -> int = "%identity"
+(** Unary addition. You can also write [+ e] instead of [~+ e].
+    @since 3.12.0
+*)
 
 external succ : int -> int = "%succint"
-(** [succ x] is [x+1]. *)
+(** [succ x] is [x + 1]. *)
 
 external pred : int -> int = "%predint"
-(** [pred x] is [x-1]. *)
+(** [pred x] is [x - 1]. *)
 
 external ( + ) : int -> int -> int = "%addint"
 (** Integer addition. *)
@@ -164,15 +173,15 @@
    Integer division rounds the real quotient of its arguments towards zero.
    More precisely, if [x >= 0] and [y > 0], [x / y] is the greatest integer
    less than or equal to the real quotient of [x] by [y].  Moreover,
-   [(-x) / y = x / (-y) = -(x / y)].  *)
+   [(- x) / y = x / (- y) = - (x / y)].  *)
 
 external ( mod ) : int -> int -> int = "%modint"
 (** Integer remainder.  If [y] is not zero, the result
    of [x mod y] satisfies the following properties:
    [x = (x / y) * y + x mod y] and
-   [abs(x mod y) <= abs(y)-1].
+   [abs(x mod y) <= abs(y) - 1].
    If [y = 0], [x mod y] raises [Division_by_zero].
-   Notice that [x mod y] is nonpositive if and only if [x < 0].
+   Note that [x mod y] is negative only if [x < 0].
    Raise [Division_by_zero] if [y] is zero. *)
 
 val abs : int -> int
@@ -186,10 +195,8 @@
 (** The smallest representable integer. *)
 
 
-
 (** {7 Bitwise operations} *)
 
-
 external ( land ) : int -> int -> int = "%andint"
 (** Bitwise logical and. *)
 
@@ -230,12 +237,17 @@
    [neg_infinity] for [-1.0 /. 0.0], and [nan] (``not a number'')
    for [0.0 /. 0.0].  These special numbers then propagate through
    floating-point computations as expected: for instance,
-   [1.0 /. infinity] is [0.0], and any operation with [nan] as
-   argument returns [nan] as result.
+   [1.0 /. infinity] is [0.0], and any arithmetic operation with [nan]
+   as argument returns [nan] as result.
 *)
 
 external ( ~-. ) : float -> float = "%negfloat"
-(** Unary negation. You can also write [-.e] instead of [~-.e]. *)
+(** Unary negation. You can also write [-. e] instead of [~-. e]. *)
+
+external ( ~+. ) : float -> float = "%identity"
+(** Unary addition. You can also write [+. e] instead of [~+. e].
+    @since 3.12.0
+*)
 
 external ( +. ) : float -> float -> float = "%addfloat"
 (** Floating-point addition *)
@@ -250,10 +262,10 @@
 (** Floating-point division. *)
 
 external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float"
-(** Exponentiation *)
+(** Exponentiation. *)
 
 external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float"
-(** Square root *)
+(** Square root. *)
 
 external exp : float -> float = "caml_exp_float" "exp" "float"
 (** Exponential. *)
@@ -266,54 +278,64 @@
 
 external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float"
 (** [expm1 x] computes [exp x -. 1.0], giving numerically-accurate results
-    even if [x] is close to [0.0]. *)
+    even if [x] is close to [0.0].
+    @since 3.12.0
+*)
 
 external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float"
 (** [log1p x] computes [log(1.0 +. x)] (natural logarithm),
-    giving numerically-accurate results even if [x] is close to [0.0]. *)
+    giving numerically-accurate results even if [x] is close to [0.0].
+    @since 3.12.0
+*)
 
 external cos : float -> float = "caml_cos_float" "cos" "float"
-(** See {!Pervasives.atan2}. *)
+(** Cosine.  Argument is in radians. *)
 
 external sin : float -> float = "caml_sin_float" "sin" "float"
-(** See {!Pervasives.atan2}. *)
+(** Sine.  Argument is in radians. *)
 
 external tan : float -> float = "caml_tan_float" "tan" "float"
-(** See {!Pervasives.atan2}. *)
+(** Tangent.  Argument is in radians. *)
 
 external acos : float -> float = "caml_acos_float" "acos" "float"
-(** See {!Pervasives.atan2}. *)
+(** Arc cosine.  The argument must fall within the range [[-1.0, 1.0]].
+    Result is in radians and is between [0.0] and [pi]. *)
 
 external asin : float -> float = "caml_asin_float" "asin" "float"
-(** See {!Pervasives.atan2}. *)
+(** Arc sine.  The argument must fall within the range [[-1.0, 1.0]].
+    Result is in radians and is between [-pi/2] and [pi/2]. *)
 
 external atan : float -> float = "caml_atan_float" "atan" "float"
-(** See {!Pervasives.atan2}. *)
+(** Arc tangent.
+    Result is in radians and is between [-pi/2] and [pi/2]. *)
 
 external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float"
-(** The usual trigonometric functions. *)
+(** [atan x y] returns the arc tangent of [y /. x].  The signs of [x]
+    and [y] are used to determine the quadrant of the result.
+    Result is in radians and is between [-pi] and [pi]. *)
 
 external cosh : float -> float = "caml_cosh_float" "cosh" "float"
-(** See {!Pervasives.tanh}. *)
+(** Hyperbolic cosine.  Argument is in radians. *)
 
 external sinh : float -> float = "caml_sinh_float" "sinh" "float"
-(** See {!Pervasives.tanh}. *)
+(** Hyperbolic sine.  Argument is in radians. *)
 
 external tanh : float -> float = "caml_tanh_float" "tanh" "float"
-(** The usual hyperbolic trigonometric functions. *)
+(** Hyperbolic tangent.  Argument is in radians. *)
 
 external ceil : float -> float = "caml_ceil_float" "ceil" "float"
-(** See {!Pervasives.floor}. *)
+(** Round above to an integer value.
+    [ceil f] returns the least integer value greater than or equal to [f].
+    The result is returned as a float. *)
 
 external floor : float -> float = "caml_floor_float" "floor" "float"
-(** Round the given float to an integer value.
-   [floor f] returns the greatest integer value less than or
-   equal to [f].
-   [ceil f] returns the least integer value greater than or
-   equal to [f]. *)
+(** Round below to an integer value.
+    [floor f] returns the greatest integer value less than or
+    equal to [f].
+    The result is returned as a float. *)
 
 external abs_float : float -> float = "%absfloat"
-(** Return the absolute value of the argument. *)
+(** [abs_float f] returns the absolute value of [f]. *)
 
 external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float"
 (** [mod_float a b] returns the remainder of [a] with respect to
@@ -450,7 +472,6 @@
    if the given string is not a valid representation of a float. *)
 
 
-
 (** {6 Pair operations} *)
 
 external fst : 'a * 'b -> 'a = "%field0"
@@ -552,8 +573,8 @@
    The result is unspecified if the line read is not a valid
    representation of a floating-point number. *)
 
-(** {7 General output functions} *)
 
+(** {7 General output functions} *)
 
 type open_flag =
     Open_rdonly      (** open for reading. *)
@@ -779,6 +800,7 @@
    This function has no effect under operating systems that
    do not distinguish between text mode and binary mode. *)
 
+
 (** {7 Operations on large files} *)
 
 module LargeFile :
@@ -797,6 +819,7 @@
   regular integers (type [int]), these alternate functions allow
   operating on files whose sizes are greater than [max_int]. *)
 
+
 (** {6 References} *)
 
 type 'a ref = { mutable contents : 'a }
@@ -861,7 +884,6 @@
 
 (** {6 Program termination} *)
 
-
 val exit : int -> 'a
 (** Terminate the process, returning the given status code
    to the operating system: usually 0 to indicate no errors,
@@ -879,9 +901,9 @@
    The functions are called in ``last in, first out'' order:
    the function most recently added with [at_exit] is called first. *)
 
-
 (**/**)
 
+
 (** {6 For system use only, not for the casual user} *)
 
 val valid_float_lexem : string -> string
--- obrowser-1.1/rt/caml/pervasives.ml.orig	2010-07-23 16:25:56.000000000 +0200
+++ obrowser-1.1/rt/caml/pervasives.ml	2010-07-23 16:29:32.000000000 +0200
@@ -51,6 +51,7 @@
 (* Integer operations *)
 
 external (~-) : int -> int = "%negint"
+external (~+) : int -> int = "%identity"
 external succ : int -> int = "%succint"
 external pred : int -> int = "%predint"
 external (+) : int -> int -> int = "%addint"
@@ -77,6 +78,7 @@
 (* Floating-point operations *)
 
 external (~-.) : float -> float = "%negfloat"
+external (~+.) : float -> float = "%identity"
 external (+.) : float -> float -> float = "%addfloat"
 external (-.) : float -> float -> float = "%subfloat"
 external ( *. ) : float -> float -> float = "%mulfloat"
