--- libgfortran/config/fpu-glibc.h.jj	2015-04-12 21:50:26.000000000 +0200

+++ libgfortran/config/fpu-glibc.h	2015-07-02 15:35:01.054869670 +0200

@@ -125,6 +125,7 @@ support_fpu_trap (int flag)

 }

+#ifndef LIBGFORTRAN_NONSHARED

 void set_fpu (void)

 {

 #ifndef FE_INVALID

@@ -165,6 +166,7 @@ void set_fpu (void)

   set_fpu_trap_exceptions (options.fpe, 0);

 }

+#endif

 int

--- libgfortran/config/fpu-387.h.jj	2015-04-12 21:50:26.000000000 +0200

+++ libgfortran/config/fpu-387.h	2015-07-02 15:33:26.692204641 +0200

@@ -206,11 +206,13 @@ set_fpu_trap_exceptions (int trap, int n

     }

 }

+#ifndef LIBGFORTRAN_NONSHARED

 void

 set_fpu (void)

 {

   set_fpu_trap_exceptions (options.fpe, 0);

 }

+#endif

 int

 get_fpu_trap_exceptions (void)

--- libgfortran/libgfortran.h.jj	2015-04-12 21:50:26.769921066 +0200

+++ libgfortran/libgfortran.h	2015-07-02 14:27:54.752340556 +0200

@@ -185,7 +185,7 @@ extern int __mingw_snprintf (char *, siz

 # define internal_proto(x)	sym_rename(x, IPREFIX(x))

 #endif

-#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS)

+#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS) && !defined(LIBGFORTRAN_NONSHARED)

 # define export_proto(x)	sym_rename(x, PREFIX(x))

 # define export_proto_np(x)	extern char swallow_semicolon

 # define iexport_proto(x)	internal_proto(x)

@@ -264,6 +264,10 @@ typedef GFC_UINTEGER_4 gfc_char4_t;

 extern int big_endian;

 internal_proto(big_endian);

+#ifdef LIBGFORTRAN_NONSHARED

+#define big_endian (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

+#endif

+

 #define GFOR_POINTER_TO_L1(p, kind) \

   (big_endian * (kind - 1) + (GFC_LOGICAL_1 *)(p))

@@ -1419,4 +1423,63 @@ void cshift0_c16 (gfc_array_c16 *, const

 internal_proto(cshift0_c16);

 #endif

+#ifdef LIBGFORTRAN_NONSHARED

+#include <stdlib.h>

+#include <string.h>              

+#include <errno.h>

+

+#define internal_malloc_size nonshared_internal_malloc_size

+#define xmalloc nonshared_internal_xmalloc

+#define xmallocarray nonshared_internal_xmallocarray

+#define reshape_packed nonshared_reshape_packed

+static inline __attribute__((__always_inline__, __unused__))

+void *

+internal_malloc_size (size_t size)

+{

+  void *p;

+

+  if (size == 0)

+    return NULL;

+

+  p = (void *) malloc (size);

+  if (p == NULL)

+    os_error ("Memory allocation failed");

+  return p;

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+void *

+xmalloc (size_t size)

+{

+  return internal_malloc_size (size ? size : 1);

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+void *

+xmallocarray (size_t nmemb, size_t size)

+{

+  if (!nmemb || !size)

+    size = nmemb = 1;

+  else if (__builtin_expect ((nmemb | size)

+			     >= (((size_t) 1) << (__CHAR_BIT__

+						  * sizeof (size_t) / 2)), 0)

+	   && nmemb > __SIZE_MAX__ / size)

+    {

+      errno = ENOMEM;

+      os_error ("Integer overflow in xmallocarray");

+    }

+

+  return internal_malloc_size (nmemb * size);

+}

+

+static inline __attribute__((__always_inline__, __unused__))

+#include "intrinsics/reshape_packed.c"

+

+struct no_bounds_check { int bounds_check; };

+#define compile_options ((struct no_bounds_check) { .bounds_check = 0 })

+

+#define internal_error(x, y...) runtime_error (y)

+

+#endif

+

 #endif  /* LIBGFOR_H  */

--- libgfortran/generated/nonshared-misc_specifics.F90.jj	2015-07-02 14:27:54.775340227 +0200

+++ libgfortran/generated/nonshared-misc_specifics.F90	2015-07-02 14:27:54.775340227 +0200

@@ -0,0 +1,53 @@

+!   Copyright 2002-2014 Free Software Foundation, Inc.

+!   Contributed by Paul Brook <paul@nowt.org>

+!

+!This file is part of the GNU Fortran 95 runtime library (libgfortran).

+!

+!GNU libgfortran is free software; you can redistribute it and/or

+!modify it under the terms of the GNU General Public

+!License as published by the Free Software Foundation; either

+!version 3 of the License, or (at your option) any later version.

+!

+!GNU libgfortran 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.

+!

+!Under Section 7 of GPL version 3, you are granted additional

+!permissions described in the GCC Runtime Library Exception, version

+!3.1, as published by the Free Software Foundation.

+!

+!You should have received a copy of the GNU General Public License and

+!a copy of the GCC Runtime Library Exception along with this program;

+!see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+!<http://www.gnu.org/licenses/>.

+

+#include "config.h"

+#include "kinds.inc"

+

+

+

+

+#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)

+elemental function _gfortran_specific__nint_4_16 (parm)

+   real (kind=16) , intent (in) :: parm

+   integer (kind=4) :: _gfortran_specific__nint_4_16

+   _gfortran_specific__nint_4_16 = nint (parm)

+end function

+#endif

+

+#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)

+elemental function _gfortran_specific__nint_8_16 (parm)

+   real (kind=16) , intent (in) :: parm

+   integer (kind=8) :: _gfortran_specific__nint_8_16

+   _gfortran_specific__nint_8_16 = nint (parm)

+end function

+#endif

+

+#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)

+elemental function _gfortran_specific__nint_16_16 (parm)

+   real (kind=16) , intent (in) :: parm

+   integer (kind=16) :: _gfortran_specific__nint_16_16

+   _gfortran_specific__nint_16_16 = nint (parm)

+end function

+#endif

--- libgfortran/runtime/nonshared-stop.c.jj	2015-07-02 14:27:54.753340541 +0200

+++ libgfortran/runtime/nonshared-stop.c	2015-07-02 14:27:54.753340541 +0200

@@ -0,0 +1,93 @@

+/* Implementation of the STOP statement.

+   Copyright 2002-2014 Free Software Foundation, Inc.

+   Contributed by Paul Brook <paul@nowt.org>

+

+This file is part of the GNU Fortran 95 runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public

+License as published by the Free Software Foundation; either

+version 3 of the License, or (at your option) any later version.

+

+Libgfortran 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.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#define LIBGFORTRAN_NONSHARED

+#include "libgfortran.h"

+#include <unistd.h>

+#include <stdlib.h>

+

+/* A numeric STOP statement.  */

+

+extern void stop_numeric (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(stop_numeric);

+

+/* A Fortran 2008 numeric STOP statement.  */

+

+extern void stop_numeric_f08 (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(stop_numeric_f08);

+

+void

+stop_numeric_f08 (GFC_INTEGER_4 code)

+{

+  /* Unfortunately we can't do much here.  */

+  if (code == -1)

+    code = -1 ^ 256;

+  stop_numeric (code);

+}

+

+

+/* Per Fortran 2008, section 8.4:  "Execution of a STOP statement initiates

+   normal termination of execution. Execution of an ERROR STOP statement

+   initiates error termination of execution."  Thus, error_stop_string returns

+   a nonzero exit status code.  */

+

+extern void error_stop_string (const char *, GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(error_stop_string);

+

+void

+error_stop_string (const char *string, GFC_INTEGER_4 len)

+{

+  (void) string;

+  (void) len;

+  stop_numeric (1);

+}

+

+

+/* A numeric ERROR STOP statement.  */

+

+extern void error_stop_numeric (GFC_INTEGER_4)

+  __attribute__ ((noreturn));

+export_proto(error_stop_numeric);

+

+void

+error_stop_numeric (GFC_INTEGER_4 code)

+{

+  stop_numeric (code);

+}

+

+__attribute__((visibility ("hidden"))) void

+stop_string (const char *string, GFC_INTEGER_4 len)

+{

+  if (string)

+    {

+      (void) write (STDERR_FILENO, "STOP ", 5);

+      (void) write (STDERR_FILENO, string, len);

+      (void) write (STDERR_FILENO, "\n", 1);

+    }

+  exit (0);

+}

--- libgfortran/runtime/nonshared-fpu.c.jj	2015-07-02 15:30:00.833128724 +0200

+++ libgfortran/runtime/nonshared-fpu.c	2015-07-02 15:30:28.922729731 +0200

@@ -0,0 +1,29 @@

+/* Set FPU mask.

+   Copyright (C) 2005-2015 Free Software Foundation, Inc.

+   Contributed by Francois-Xavier Coudert <coudert@clipper.ens.fr>

+

+This file is part of the GNU Fortran runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public

+License as published by the Free Software Foundation; either

+version 3 of the License, or (at your option) any later version.

+

+Libgfortran 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.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#define LIBGFORTRAN_NONSHARED

+#include "libgfortran.h"

+

+#include "fpu-target.h"

--- libgfortran/runtime/nonshared-backtrace.c.jj	2015-07-02 14:27:54.753340541 +0200

+++ libgfortran/runtime/nonshared-backtrace.c	2015-07-02 14:27:54.753340541 +0200

@@ -0,0 +1,326 @@

+/* Copyright (C) 2006-2014 Free Software Foundation, Inc.

+   Contributed by François-Xavier Coudert

+

+This file is part of the GNU Fortran runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or modify

+it under the terms of the GNU General Public License as published by

+the Free Software Foundation; either version 3, or (at your option)

+any later version.

+

+Libgfortran 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.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#include "libgfortran.h"

+

+#include <string.h>

+#include <stdlib.h>

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+#ifdef HAVE_SYS_WAIT_H

+#include <sys/wait.h>

+#endif

+

+#include <limits.h>

+

+#include "unwind.h"

+

+

+/* Macros for common sets of capabilities: can we fork and exec, and

+   can we use pipes to communicate with the subprocess.  */

+#define CAN_FORK (defined(HAVE_FORK) && defined(HAVE_EXECVE) \

+		  && defined(HAVE_WAIT))

+#define CAN_PIPE (CAN_FORK && defined(HAVE_PIPE) \

+		  && defined(HAVE_DUP2) && defined(HAVE_CLOSE))

+

+#ifndef PATH_MAX

+#define PATH_MAX 4096

+#endif

+

+#define estr_write(str) write (STDERR_FILENO, str, strlen (str))

+

+

+/* GDB style #NUM index for each stack frame.  */

+

+static void 

+bt_header (int num)

+{

+  char buf[32];

+  snprintf (buf, sizeof buf, "#%d  ", num);

+  estr_write (buf);

+}

+

+

+/* fgets()-like function that reads a line from a fd, without

+   needing to malloc() a buffer, and does not use locks, hence should

+   be async-signal-safe.  */

+

+static char *

+fd_gets (char *s, int size, int fd)

+{

+  for (int i = 0; i < size; i++)

+    {

+      char c;

+      ssize_t nread = read (fd, &c, 1);

+      if (nread == 1)

+	{

+	  s[i] = c;

+	  if (c == '\n')

+	    {

+	      if (i + 1 < size)

+		s[i+1] = '\0';

+	      else

+		s[i] = '\0';

+	      break;

+	    }

+	}

+      else

+	{

+	  s[i] = '\0';

+	  if (i == 0)

+	    return NULL;

+	  break;

+	}

+    }

+  return s;

+}

+

+

+/* Struct containing backtrace state.  */

+typedef struct

+{

+  int frame_number;

+  int direct_output;

+  int outfd;

+  int infd;

+  int error;

+}

+bt_state;

+

+static inline const char *

+nonshared_gfc_xtoa (GFC_UINTEGER_LARGEST n, char *buffer,

+		    size_t len __attribute__((unused)))

+{

+  int digit;

+  char *p;

+

+  if (n == 0)

+    return "0";

+

+  p = buffer + GFC_XTOA_BUF_SIZE - 1;

+  *p = '\0';

+

+  while (n != 0)

+    {

+      digit = n & 0xF;

+      if (digit > 9)

+        digit += 'A' - '0' - 10;

+

+      *--p = '0' + digit;

+      n >>= 4;

+    }

+

+  return p;

+}

+#define gfc_xtoa nonshared_gfc_xtoa

+

+static _Unwind_Reason_Code

+trace_function (struct _Unwind_Context *context, void *state_ptr)

+{

+  bt_state* state = (bt_state*) state_ptr;

+  _Unwind_Ptr ip;

+#ifdef HAVE_GETIPINFO

+  int ip_before_insn = 0;

+  ip = _Unwind_GetIPInfo (context, &ip_before_insn);

+  

+  /* If the unwinder gave us a 'return' address, roll it back a little

+     to ensure we get the correct line number for the call itself.  */

+  if (! ip_before_insn)

+    --ip;

+#else  

+  ip = _Unwind_GetIP (context);

+#endif

+

+  if (state->direct_output)

+    {

+      char buf[32];

+      bt_header(state->frame_number);

+      snprintf (buf, sizeof buf, "%p\n", (void*) ip);

+      estr_write (buf);

+    }

+  else

+    {

+      char addr_buf[GFC_XTOA_BUF_SIZE], func[1024], file[PATH_MAX];

+      char *p;

+      const char* addr = gfc_xtoa (ip, addr_buf, sizeof (addr_buf));

+      write (state->outfd, addr, strlen (addr));

+      write (state->outfd, "\n", 1);

+

+      if (! fd_gets (func, sizeof(func), state->infd))

+	{

+	  state->error = 1;

+	  goto done;

+	}

+      if (! fd_gets (file, sizeof(file), state->infd))

+	{

+	  state->error = 1;

+	  goto done;

+	}

+	    

+	for (p = func; *p != '\n' && *p != '\r'; p++)

+	  ;

+	*p = '\0';

+	

+	/* _start is a setup routine that calls main(), and main() is

+	   the frontend routine that calls some setup stuff and then

+	   calls MAIN__, so at this point we should stop.  */

+	if (strcmp (func, "_start") == 0 || strcmp (func, "main") == 0)

+	  return _URC_END_OF_STACK;

+	

+	bt_header (state->frame_number);

+	estr_write ("0x");

+	estr_write (addr);

+

+	if (func[0] != '?' && func[1] != '?')

+	  {

+	    estr_write (" in ");

+	    estr_write (func);

+	  }

+	

+	if (strncmp (file, "??", 2) == 0)

+	  estr_write ("\n");

+	else

+	  {

+	    estr_write (" at ");

+	    estr_write (file);

+	  }

+    }

+

+ done:

+

+  state->frame_number++;

+  

+  return _URC_NO_REASON;

+}

+

+

+/* Display the backtrace.  */

+

+void

+backtrace (void)

+{

+  bt_state state;

+  state.frame_number = 0;

+  state.error = 0;

+

+#if CAN_PIPE

+

+#ifndef PATH_MAX

+#define PATH_MAX 1024

+#endif

+

+#ifndef DIR_SEPARATOR

+#define DIR_SEPARATOR '/'

+#endif

+

+  char exe_path[PATH_MAX];

+

+  /* Reading the /proc/self/exe symlink is Linux-specific(?), but if

+     it works it gives the correct answer.  */

+#ifdef HAVE_READLINK

+  int len;

+  if ((len = readlink ("/proc/self/exe", exe_path, sizeof (exe_path) - 1)) != -1)

+    exe_path[len] = '\0';

+  else

+#endif

+    goto fallback_noerr;

+

+  /* We attempt to extract file and line information from addr2line.  */

+  do

+  {

+    /* Local variables.  */

+    int f[2], pid, inp[2];

+

+    /* Don't output an error message if something goes wrong, we'll simply

+       fall back to printing the addresses.  */

+    if (pipe (f) != 0)

+      break;

+    if (pipe (inp) != 0)

+      break;

+    if ((pid = fork ()) == -1)

+      break;

+

+    if (pid == 0)

+      {

+	/* Child process.  */

+#define NUM_FIXEDARGS 7

+	char *arg[NUM_FIXEDARGS];

+

+	close (f[0]);

+

+	close (inp[1]);

+	if (dup2 (inp[0], STDIN_FILENO) == -1)

+	  _exit (1);

+	close (inp[0]);

+

+	close (STDERR_FILENO);

+

+	if (dup2 (f[1], STDOUT_FILENO) == -1)

+	  _exit (1);

+	close (f[1]);

+

+	arg[0] = (char *) "addr2line";

+	arg[1] = (char *) "-e";

+	arg[2] = exe_path;

+	arg[3] = (char *) "-f";

+	arg[4] = (char *) "-s";

+	arg[5] = (char *) "-C";

+	arg[6] = NULL;

+	execvp ("addr2line", arg);

+	_exit (1);

+#undef NUM_FIXEDARGS

+      }

+

+    /* Father process.  */

+    close (f[1]);

+    close (inp[0]);

+

+    state.outfd = inp[1];

+    state.infd = f[0];

+    state.direct_output = 0;

+    _Unwind_Backtrace (trace_function, &state);

+    if (state.error)

+      goto fallback;

+    close (inp[1]);

+    close (f[0]);

+    wait (NULL);

+    return;

+

+fallback:

+    estr_write ("** Something went wrong while running addr2line. **\n"

+		"** Falling back to a simpler backtrace scheme. **\n");

+  }

+  while (0);

+

+fallback_noerr:

+#endif /* CAN_PIPE */

+

+  /* Fallback to the simple backtrace without addr2line.  */

+  state.direct_output = 1;

+  _Unwind_Backtrace (trace_function, &state);

+}

+iexport(backtrace);

--- libgfortran/intrinsics/nonshared-random.c.jj	2015-07-02 14:27:54.776340212 +0200

+++ libgfortran/intrinsics/nonshared-random.c	2015-07-02 14:27:54.776340212 +0200

@@ -0,0 +1,142 @@

+/* Implementation of the RANDOM intrinsics

+   Copyright 2002-2014 Free Software Foundation, Inc.

+   Contributed by Lars Segerlund <seger@linuxmail.org>

+   and Steve Kargl.

+

+This file is part of the GNU Fortran runtime library (libgfortran).

+

+Libgfortran is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public

+License as published by the Free Software Foundation; either

+version 3 of the License, or (at your option) any later version.

+

+Ligbfortran 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.

+

+Under Section 7 of GPL version 3, you are granted additional

+permissions described in the GCC Runtime Library Exception, version

+3.1, as published by the Free Software Foundation.

+

+You should have received a copy of the GNU General Public License and

+a copy of the GCC Runtime Library Exception along with this program;

+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

+<http://www.gnu.org/licenses/>.  */

+

+#define LIBGFORTRAN_NONSHARED

+#include "libgfortran.h"

+#include <gthr.h>

+#include <string.h>

+

+#if defined HAVE_GFC_REAL_10 && defined HAVE_GFC_REAL_16 \

+    && GFC_REAL_10_RADIX == 2 && GFC_REAL_10_DIGITS == 64

+extern void random_r10 (GFC_REAL_10 *);

+iexport_proto(random_r10);

+

+extern void random_r16 (GFC_REAL_16 *);

+iexport_proto(random_r16);

+

+extern void arandom_r16 (gfc_array_r16 *);

+export_proto(arandom_r16);

+

+/* For REAL(KIND=16), we only need to mask off the lower bits.  */

+

+static inline void

+rnumber_16 (GFC_REAL_16 *f, GFC_UINTEGER_8 v1, GFC_UINTEGER_8 v2)

+{

+  GFC_UINTEGER_8 mask;

+#if GFC_REAL_16_RADIX == 2

+  mask = ~ (GFC_UINTEGER_8) 0u << (128 - GFC_REAL_16_DIGITS);

+#elif GFC_REAL_16_RADIX == 16

+  mask = ~ (GFC_UINTEGER_8) 0u << ((32 - GFC_REAL_16_DIGITS) * 4);

+#else

+#error "GFC_REAL_16_RADIX has unknown value"

+#endif

+  v2 = v2 & mask;

+  *f = (GFC_REAL_16) v1 * GFC_REAL_16_LITERAL(0x1.p-64)

+    + (GFC_REAL_16) v2 * GFC_REAL_16_LITERAL(0x1.p-128);

+}

+

+/*  This function produces a REAL(16) value from the uniform distribution

+    with range [0,1).  */

+

+void

+random_r16 (GFC_REAL_16 *x)

+{

+  GFC_UINTEGER_8 kiss1, kiss2;

+  GFC_REAL_10 num1, num2;

+

+  random_r10 (&num1;;

+  random_r10 (&num2;;

+  num1 *= GFC_REAL_10_LITERAL(0x1.p64);

+  num2 *= GFC_REAL_10_LITERAL(0x1.p64);

+  kiss1 = num1;

+  kiss2 = num2;

+

+  rnumber_16 (x, kiss1, kiss2);

+}

+iexport(random_r16);

+

+/*  This function fills a REAL(16) array with values from the uniform

+    distribution with range [0,1).  */

+

+void